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

package/dist/lib/catalogue/cli-version.js

@@ -0,0 +1,10 @@
+/**
+ * sdd-cli version constant, used in error messages from the catalogue
+ * builder + aggregator + validate subcommands.
+ *
+ * Read from package.json via getSddCliVersion() (the ENGINE version, also in a persona package) to guarantee the
+ * constant cannot drift from the published version.
+ */
+import { getSddCliVersion } from "../package-version.js";
+export const CLI_VERSION = getSddCliVersion();
+//# sourceMappingURL=cli-version.js.map

package/dist/lib/catalogue/contract-id.js

@@ -0,0 +1,49 @@
+// Contract row identity (schema 3.0.0) and the legacy-id migration map —
+// M-ADR 0203 §4.4, the cut's acid test.
+//
+// From 3.0.0 a contract id carries its KIND component: `{domain}-{stem}-{kind}`
+// (kind ∈ rest | graphql | rpc | event | authz). The kindless 2.x form made one
+// measured collision class unrepresentable: a service published as two contract
+// families (`calendar-service.yaml` + `calendar_service.proto`) minted one id,
+// costing a live estate one row and two edges permanently, and mislabelling
+// legitimate shared-contract citation as divergence.
+//
+// The map is mechanical in both directions: new id = `${old id}-${kind}`, from
+// two columns every committed catalogue carries (`id`, `kind`). It ships via
+// `sdd-cli catalogue migration-map`; the alias-file re-key (M-ADR 0147 targets
+// are authored copies of tool-minted ids — regenerable, not drift, the same
+// rule as external_system_exemption) consults the in-build form of it.
+/** The 3.0.0 contract id: the kindless slug with its kind appended. */
+export function contractIdWithKind(kindlessSlug, kind) {
+    return kindlessSlug === "" ? "" : `${kindlessSlug}-${kind}`;
+}
+/**
+ * legacy (2.x, kindless) id → the 3.0.0 kind-suffixed ids it maps to, from
+ * built rows. More than one target means the id was a measured collision
+ * under 2.x (two families sharing one kindless slug) — the consumer decides
+ * which family is meant, loudly, never by guess.
+ */
+export function buildLegacyContractIdMap(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        const id = String(row["id"] ?? "");
+        const kind = String(row["kind"] ?? "");
+        if (id === "" || kind === "" || !id.endsWith(`-${kind}`))
+            continue;
+        const legacy = id.slice(0, -(kind.length + 1));
+        if (legacy === "")
+            continue;
+        const ids = map.get(legacy);
+        if (ids) {
+            if (!ids.includes(id))
+                ids.push(id);
+        }
+        else {
+            map.set(legacy, [id]);
+        }
+    }
+    for (const ids of map.values())
+        ids.sort((a, b) => a.localeCompare(b));
+    return map;
+}
+//# sourceMappingURL=contract-id.js.map

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

@@ -0,0 +1,603 @@
+/**
+ * Coverage predicates as SQL — M-ADR 0205 §4.4 (engine-evolution Phase A3).
+ *
+ * Declarative re-expressions of the participation-constraint predicates —
+ * the four catalogue-classics:
+ *
+ *   - repo_capability   (M-ADR 0188): every catalogued repository resolves
+ *     to a capability or declares an exemption; orphans classified by
+ *     whether the capability_service ⋈ services.primary_repo_id derivation
+ *     COULD have fired (shape a / claimed-but-unresolved / shape b).
+ *   - service_capability (M-ADR 0133 §4.2b): every catalogued service is
+ *     claimed or exempt; tier is explicit and asymmetric per M-ADR 0196
+ *     §4.3 (`orphaned` is aggregate-only; member tier reports
+ *     `unresolved-locally`, cause-agnostic); the Path-X leverage axis is
+ *     reported separately and only when repo_capability.csv exists.
+ *   - event_coverage    (WS3): every catalogued event is attributed to a
+ *     runtime — service_event edge or resolving publisher column — with
+ *     the contract-twin alternative route, the column-vs-edge disagreement
+ *     controls, and the chain-readout/consumer-enumerability metric lines
+ *     that are never verdicts.
+ *   - contract_coverage (WS2): every catalogued contract is reachable —
+ *     capability_contract or service_contract — with the three computed
+ *     exclusions (deprecated / provider-surface / not-an-interface, the
+ *     last a positive READ of the spec file), the covered-as-event
+ *     alternative route, and the M-ADR 0202 availability-manifest info
+ *     surface. File and YAML ingestion stay host-side; set logic is SQL.
+ *
+ * The shell scripts in sdd-method's orchestration/scripts/ remain the
+ * REFERENCE implementations until A4 cutover: any semantic change lands
+ * there first and here second, and the dual-run driver compares the two
+ * as structured findings — (kind, subject, classification, leverage) plus
+ * every metric integer — never as prose.
+ *
+ * The relations live in SQL; the classification branching mirrors the
+ * reference implementations statement-for-statement, including their
+ * duplicate-row semantics (a duplicated id is counted and reported per
+ * ROW, never deduplicated away).
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+const REPO_FLAGS_SQL = `
+SELECT
+  r."id" AS repo_id,
+  EXISTS (SELECT 1 FROM "repo_capability" c
+          WHERE c."repo_id" = r."id") AS has_cap,
+  EXISTS (SELECT 1 FROM "repo_capability_exemption" e
+          WHERE e."repo_id" = r."id") AS has_exempt,
+  EXISTS (SELECT 1 FROM "services" s
+          WHERE s."primary_repo_id" = r."id"
+            AND s."id" IS NOT NULL AND s."id" <> '') AS has_svc,
+  EXISTS (SELECT 1 FROM "services" s
+          WHERE s."primary_repo_id" = r."id"
+            AND s."id" IS NOT NULL AND s."id" <> ''
+            AND NOT EXISTS (SELECT 1 FROM "capability_service" cs
+                            WHERE cs."service_id" = s."id")) AS has_unclaimed_svc,
+  (SELECT e2."reason" FROM "repo_capability_exemption" e2
+   WHERE e2."repo_id" = r."id"
+     AND e2.rowid = (SELECT MAX(e3.rowid) FROM "repo_capability_exemption" e3
+                     WHERE e3."repo_id" = r."id")) AS exempt_reason,
+  (SELECT string_agg(s."id", chr(31) ORDER BY s."id") FROM "services" s
+   WHERE s."primary_repo_id" = r."id"
+     AND s."id" IS NOT NULL AND s."id" <> ''
+     AND NOT EXISTS (SELECT 1 FROM "capability_service" cs
+                     WHERE cs."service_id" = s."id")) AS unclaimed_ids
+FROM "repositories" r
+WHERE r."id" IS NOT NULL AND r."id" <> ''
+ORDER BY repo_id;`;
+export async function runRepoCapabilityCoverage(session) {
+    const reader = await session.conn.runAndReadAll(REPO_FLAGS_SQL);
+    const rows = reader.getRows().map((r) => ({
+        repoId: String(r[0]),
+        hasCap: r[1] === true,
+        hasExempt: r[2] === true,
+        hasSvc: r[3] === true,
+        hasUnclaimedSvc: r[4] === true,
+        exemptReason: r[5] === null || r[5] === undefined ? "" : String(r[5]),
+        unclaimedIds: r[6] === null || r[6] === undefined
+            ? []
+            : String(r[6]).split("\x1f"),
+    }));
+    const findings = [];
+    let byCapability = 0;
+    let byExemption = 0;
+    let conflicting = 0;
+    let unresolved = 0;
+    let shapeA = 0;
+    let shapeB = 0;
+    for (const row of rows) {
+        if (row.hasCap && row.hasExempt) {
+            conflicting++;
+            findings.push({
+                predicate: "repo_capability",
+                kind: "divergence",
+                subjectId: row.repoId,
+                classification: "conflict",
+                exemptionReason: row.exemptReason,
+            });
+        }
+        else if (row.hasCap) {
+            byCapability++;
+        }
+        else if (row.hasExempt) {
+            byExemption++;
+        }
+        else {
+            unresolved++;
+            if (row.hasUnclaimedSvc) {
+                shapeA++;
+                findings.push({
+                    predicate: "repo_capability",
+                    kind: "orphan",
+                    subjectId: row.repoId,
+                    classification: "shape_a",
+                    unclaimedServices: row.unclaimedIds.slice(0, 3),
+                    unclaimedCount: row.unclaimedIds.length,
+                });
+            }
+            else if (row.hasSvc) {
+                findings.push({
+                    predicate: "repo_capability",
+                    kind: "orphan",
+                    subjectId: row.repoId,
+                    classification: "claimed_unresolved",
+                });
+            }
+            else {
+                shapeB++;
+                findings.push({
+                    predicate: "repo_capability",
+                    kind: "orphan",
+                    subjectId: row.repoId,
+                    classification: "shape_b",
+                });
+            }
+        }
+    }
+    return {
+        findings,
+        metrics: {
+            total: rows.length,
+            byCapability,
+            byExemption,
+            conflicting,
+            unresolved,
+            shapeA,
+            shapeB,
+            other: unresolved - shapeA - shapeB,
+        },
+    };
+}
+/** Statement-for-statement mirror of the reference classify(). */
+function classify(hasCap, hasExempt) {
+    if (hasCap && hasExempt)
+        return "conflict";
+    if (hasCap)
+        return "claimed";
+    if (hasExempt)
+        return "exempt";
+    return "unresolved";
+}
+const SERVICE_FLAGS_SQL = `
+SELECT
+  s."id" AS service_id,
+  COALESCE(s."primary_repo_id", '') AS primary_repo,
+  EXISTS (SELECT 1 FROM "capability_service" cs
+          WHERE cs."service_id" = s."id") AS has_cap,
+  EXISTS (SELECT 1 FROM "service_capability_exemption" e
+          WHERE e."service_id" = s."id") AS has_exempt,
+  EXISTS (SELECT 1 FROM "repo_capability" rc
+          WHERE rc."repo_id" = s."primary_repo_id"
+            AND rc."repo_id" IS NOT NULL AND rc."repo_id" <> '') AS repo_resolves,
+  (SELECT e2."reason" FROM "service_capability_exemption" e2
+   WHERE e2."service_id" = s."id"
+     AND e2.rowid = (SELECT MAX(e3.rowid) FROM "service_capability_exemption" e3
+                     WHERE e3."service_id" = s."id")) AS exempt_reason
+FROM "services" s
+WHERE s."id" IS NOT NULL AND s."id" <> ''
+ORDER BY service_id, primary_repo;`;
+export async function runServiceCapabilityCoverage(session, options) {
+    // Known-bad probe, carried over from the reference implementation
+    // (WS11's third requirement): a synthetic claimed service must classify
+    // as claimed BEFORE any real data is reported — a run whose
+    // classification never executed must not be able to report a healthy
+    // estate.
+    if (classify(true, false) !== "claimed") {
+        throw new Error("coverage-predicates: known-bad probe failed — a synthetic claimed service did not classify as claimed; refusing to report");
+    }
+    const reader = await session.conn.runAndReadAll(SERVICE_FLAGS_SQL);
+    const findings = [];
+    let claimed = 0;
+    let exempt = 0;
+    let conflicting = 0;
+    let unresolved = 0;
+    let leverageYes = 0;
+    let leverageNo = 0;
+    let leverageNa = 0;
+    let total = 0;
+    for (const r of reader.getRows()) {
+        total++;
+        const serviceId = String(r[0]);
+        const primaryRepo = String(r[1] ?? "");
+        const verdict = classify(r[2] === true, r[3] === true);
+        if (verdict === "conflict") {
+            conflicting++;
+            findings.push({
+                predicate: "service_capability",
+                kind: "divergence",
+                subjectId: serviceId,
+                classification: "conflict",
+                exemptionReason: r[5] === null || r[5] === undefined ? "" : String(r[5]),
+            });
+        }
+        else if (verdict === "claimed") {
+            claimed++;
+        }
+        else if (verdict === "exempt") {
+            exempt++;
+        }
+        else {
+            unresolved++;
+            let leverage;
+            if (options.repoCapabilityAvailable) {
+                if (primaryRepo === "") {
+                    leverageNa++;
+                    leverage = "na";
+                }
+                else if (r[4] !== true) {
+                    leverageYes++;
+                    leverage = "yes";
+                }
+                else {
+                    leverageNo++;
+                    leverage = "no";
+                }
+            }
+            findings.push({
+                predicate: "service_capability",
+                kind: options.tier === "aggregate" ? "orphan" : "coverage",
+                subjectId: serviceId,
+                classification: options.tier === "aggregate" ? "orphaned" : "unresolved-locally",
+                ...(leverage !== undefined ? { leverage } : {}),
+                primaryRepo,
+            });
+        }
+    }
+    return {
+        findings,
+        metrics: {
+            total,
+            claimed,
+            exempt,
+            conflicting,
+            unresolved,
+            ...(options.repoCapabilityAvailable && unresolved > 0
+                ? { leverage: { yes: leverageYes, no: leverageNo, na: leverageNa } }
+                : {}),
+        },
+    };
+}
+/** Statement-for-statement mirror of the reference classify(). */
+function classifyEvent(hasEdge, pub, pubResolves, twinCovered) {
+    if (hasEdge)
+        return "covered";
+    if (pub !== "" && pubResolves)
+        return "covered";
+    if (twinCovered)
+        return "covered-as-contract";
+    return "unresolved";
+}
+const EVENT_FLAGS_SQL = `
+WITH ev AS (
+  SELECT e."id" AS id,
+         TRIM(COALESCE(e."publisher_service_id", '')) AS pub,
+         REPLACE(COALESCE(e."schema_path", ''), chr(92), '/') AS sp
+  FROM "events" e
+  WHERE e."id" IS NOT NULL AND e."id" <> ''
+    AND e.rowid = (SELECT MAX(e2.rowid) FROM "events" e2 WHERE e2."id" = e."id")
+),
+covered_twin_bases AS (
+  SELECT DISTINCT regexp_extract(REPLACE(c."spec_path", chr(92), '/'), '[^/]*$') AS base
+  FROM "contracts" c
+  WHERE COALESCE(c."kind", '') = 'event'
+    AND COALESCE(c."spec_path", '') <> ''
+    AND (EXISTS (SELECT 1 FROM "capability_contract" cc WHERE cc."contract_id" = c."id")
+      OR EXISTS (SELECT 1 FROM "service_contract" sc WHERE sc."contract_id" = c."id"))
+)
+SELECT ev.id, ev.pub,
+  EXISTS (SELECT 1 FROM "service_event" se WHERE se."event_id" = ev.id) AS has_edge,
+  EXISTS (SELECT 1 FROM "service_event" se WHERE se."event_id" = ev.id
+          AND COALESCE(se."role", '') IN ('publishes', 'produces')) AS has_pub_edge,
+  EXISTS (SELECT 1 FROM "services" s WHERE s."id" = ev.pub) AS pub_resolves,
+  (ev.sp <> '' AND EXISTS (SELECT 1 FROM covered_twin_bases b
+      WHERE b.base = regexp_extract(ev.sp, '[^/]*$'))) AS twin_covered,
+  (ev.pub <> '' AND EXISTS (SELECT 1 FROM "capability_service" cs
+      WHERE cs."service_id" = ev.pub)) AS pub_cap_claimed,
+  EXISTS (SELECT 1 FROM "service_event" se
+          JOIN "capability_service" cs ON cs."service_id" = se."service_id"
+          WHERE se."event_id" = ev.id
+            AND COALESCE(se."service_id", '') <> '') AS edge_cap_claimed,
+  EXISTS (SELECT 1 FROM "service_event" se WHERE se."event_id" = ev.id
+          AND COALESCE(se."role", '') = 'consumes') AS has_consume_edge
+FROM ev
+ORDER BY ev.id;`;
+export async function runEventCoverage(session, options) {
+    // Classifier probe (M-ADR 0199 §4.6): known-good and known-bad synthetic
+    // rows through the real classifier, both directions, before any real data.
+    if (classifyEvent(false, "svc", true, false) !== "covered" ||
+        classifyEvent(false, "", false, false) !== "unresolved") {
+        throw new Error("coverage-predicates: event classifier probe misclassified a synthetic row — no verdict is trustworthy");
+    }
+    const reader = await session.conn.runAndReadAll(EVENT_FLAGS_SQL);
+    const rows = reader.getRows();
+    if (rows.length === 0) {
+        return { na: true, findings: [] };
+    }
+    const findings = [];
+    const colUnresolving = [];
+    const colNoEdge = [];
+    const edgeNoCol = [];
+    let covered = 0;
+    let viaContract = 0;
+    let unresolved = 0;
+    let capReach = 0;
+    let consumerEnum = 0;
+    for (const r of rows) {
+        const id = String(r[0]);
+        const pub = String(r[1] ?? "");
+        const hasEdge = r[2] === true;
+        const hasPubEdge = r[3] === true;
+        const pubResolves = r[4] === true;
+        const twinCovered = r[5] === true;
+        const pubCapClaimed = r[6] === true;
+        const edgeCapClaimed = r[7] === true;
+        const hasConsumeEdge = r[8] === true;
+        // Column-vs-edge disagreement controls — the two attribution
+        // representations checked against each other every run.
+        if (pub !== "" && !pubResolves)
+            colUnresolving.push({ eventId: id, publisher: pub });
+        if (pub !== "" && pubResolves && !hasPubEdge)
+            colNoEdge.push(id);
+        if (hasPubEdge && pub === "")
+            edgeNoCol.push(id);
+        if (pubCapClaimed || edgeCapClaimed)
+            capReach++;
+        if (hasConsumeEdge)
+            consumerEnum++;
+        const verdict = classifyEvent(hasEdge, pub, pubResolves, twinCovered);
+        if (verdict === "covered")
+            covered++;
+        else if (verdict === "covered-as-contract")
+            viaContract++;
+        else {
+            unresolved++;
+            findings.push({
+                predicate: "event_coverage",
+                kind: options.tier === "aggregate" ? "orphan" : "report",
+                subjectId: id,
+                classification: options.tier === "aggregate" ? "orphaned" : "unresolved-locally",
+            });
+        }
+    }
+    return {
+        na: false,
+        findings,
+        metrics: {
+            total: rows.length,
+            covered,
+            viaContract,
+            unresolved,
+            capReach,
+            consumerEnum,
+        },
+        controls: { colUnresolving, colNoEdge, edgeNoCol },
+    };
+}
+/** Statement-for-statement mirror of the reference classify(). */
+function classifyContract(reachable, excluded, coveredAsEvent) {
+    if (excluded && reachable)
+        return "conflict";
+    if (reachable)
+        return "covered";
+    if (coveredAsEvent)
+        return "covered-as-event";
+    if (excluded)
+        return "excluded";
+    return "unresolved";
+}
+/**
+ * A positive property of the artefact: an OpenAPI document with no
+ * `paths`. Mirrors the reference's has_no_operations, including every
+ * refusal path (non-yaml extension, unreachable file, unparseable
+ * content, non-mapping document → False, never a guess).
+ */
+function hasNoOperations(sddRoot, specPath) {
+    if (!specPath || !(specPath.endsWith(".yaml") || specPath.endsWith(".yml"))) {
+        return false;
+    }
+    const full = join(sddRoot, specPath);
+    if (!existsSync(full))
+        return false;
+    let doc;
+    try {
+        doc = parseYaml(readFileSync(full, "utf-8"));
+    }
+    catch {
+        return false;
+    }
+    if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+        return false;
+    }
+    const d = doc;
+    if (!("openapi" in d) && !("swagger" in d) && !("paths" in d))
+        return true;
+    const paths = d["paths"];
+    if (!paths || typeof paths !== "object")
+        return true;
+    return Object.keys(paths).length === 0;
+}
+const CONTRACT_FLAGS_SQL = `
+WITH ct AS (
+  SELECT c."id" AS id,
+         COALESCE(c."status", '') AS status,
+         COALESCE(c."evidence_class", '') AS evidence_class,
+         COALESCE(c."kind", '') AS kind,
+         REPLACE(COALESCE(c."spec_path", ''), chr(92), '/') AS sp
+  FROM "contracts" c
+  WHERE c."id" IS NOT NULL AND c."id" <> ''
+    AND c.rowid = (SELECT MAX(c2.rowid) FROM "contracts" c2 WHERE c2."id" = c."id")
+),
+events_with_edges AS (
+  SELECT DISTINCT event_id FROM (
+    SELECT "event_id" FROM "service_event"
+    UNION ALL SELECT "event_id" FROM "capability_event"
+    UNION ALL SELECT "event_id" FROM "feature_event"
+  ) u
+  WHERE COALESCE(event_id, '') <> ''
+),
+twin_bases AS (
+  SELECT DISTINCT regexp_extract(REPLACE(e."schema_path", chr(92), '/'), '[^/]*$') AS base
+  FROM "events" e
+  WHERE COALESCE(e."schema_path", '') <> ''
+    AND COALESCE(e."id", '') <> ''
+    AND e."id" IN (SELECT event_id FROM events_with_edges)
+)
+SELECT ct.id, ct.status, ct.evidence_class, ct.kind, ct.sp,
+  EXISTS (SELECT 1 FROM "capability_contract" cc
+          WHERE cc."contract_id" = ct.id) AS owned,
+  EXISTS (SELECT 1 FROM "service_contract" sc
+          WHERE sc."contract_id" = ct.id) AS attributed,
+  (ct.sp <> '' AND EXISTS (SELECT 1 FROM twin_bases b
+      WHERE b.base = regexp_extract(ct.sp, '[^/]*$'))) AS twin_edge
+FROM ct
+ORDER BY ct.id;`;
+const CONSUMERS_NAMED_SQL = `
+SELECT COUNT(DISTINCT sc."contract_id")
+FROM "service_contract" sc
+WHERE COALESCE(sc."contract_id", '') <> ''
+  AND COALESCE(sc."role", '') = 'consumes';`;
+const RAW_SPEC_PATHS_SQL = `
+SELECT DISTINCT COALESCE(c."spec_path", '') FROM "contracts" c;`;
+export async function runContractCoverage(session, options) {
+    // Known-good / known-bad probe (M-ADR 0199 §4.6), both directions,
+    // before any real data — mirror of the reference's five-way probe.
+    const probe = {
+        covered: classifyContract(true, false, false),
+        orphan: classifyContract(false, false, false),
+        excluded: classifyContract(false, true, false),
+        event: classifyContract(false, false, true),
+        conflict: classifyContract(true, true, false),
+    };
+    if (probe["covered"] !== "covered" ||
+        probe["orphan"] !== "unresolved" ||
+        probe["excluded"] !== "excluded" ||
+        probe["event"] !== "covered-as-event" ||
+        probe["conflict"] !== "conflict") {
+        throw new Error("coverage-predicates: contract classifier probe misclassified a synthetic row — no verdict is trustworthy");
+    }
+    const reader = await session.conn.runAndReadAll(CONTRACT_FLAGS_SQL);
+    const rows = reader.getRows();
+    if (rows.length === 0) {
+        return { na: true, findings: [] };
+    }
+    // Availability manifest (M-ADR 0202): informational, never
+    // verdict-changing; unreadable → a warning, mirror of the reference's
+    // try/except. Row paths are the RAW spec_path values, un-normalised.
+    let availability;
+    let availabilityWarning;
+    try {
+        const manifestPath = join(options.sddRoot, ".sdd", "contract-availability.yaml");
+        if (existsSync(manifestPath)) {
+            const text = readFileSync(manifestPath, "utf-8");
+            const attestedPaths = [...text.matchAll(/^\s*- path: "([^"]+)"/gm)].map((m) => m[1]);
+            const rawReader = await session.conn.runAndReadAll(RAW_SPEC_PATHS_SQL);
+            const rowPaths = new Set(rawReader.getRows().map((r) => String(r[0] ?? "")));
+            availability = {
+                attested: attestedPaths.length,
+                unmodelled: attestedPaths.filter((p) => !rowPaths.has(p)),
+            };
+        }
+    }
+    catch (e) {
+        availabilityWarning = String(e instanceof Error ? e.message : e);
+    }
+    const findings = [];
+    const byExclusion = {};
+    let covered = 0;
+    let viaEvent = 0;
+    let excludedCount = 0;
+    let conflicting = 0;
+    let unresolved = 0;
+    let ownedOnly = 0;
+    let attrOnly = 0;
+    let both = 0;
+    for (const r of rows) {
+        const id = String(r[0]);
+        const status = String(r[1] ?? "");
+        const evidenceClass = String(r[2] ?? "");
+        const kind = String(r[3] ?? "");
+        const sp = String(r[4] ?? "");
+        const owned = r[5] === true;
+        const attributed = r[6] === true;
+        const twinEdge = r[7] === true;
+        if (owned && !attributed)
+            ownedOnly++;
+        else if (attributed && !owned)
+            attrOnly++;
+        else if (owned && attributed)
+            both++;
+        // The three exclusions + the one alternative route, in the
+        // reference's order (first match wins; a deprecated event-kind
+        // contract is excluded, never covered-as-event).
+        let excluded = false;
+        let exclusionKey = "";
+        let coveredAsEvent = false;
+        if (status === "deprecated") {
+            excluded = true;
+            exclusionKey = "deprecated";
+        }
+        else if (evidenceClass === "vendor-doc") {
+            excluded = true;
+            exclusionKey = "provider-surface";
+        }
+        else if (hasNoOperations(options.sddRoot, sp)) {
+            excluded = true;
+            exclusionKey = "not-an-interface";
+        }
+        else if (kind === "event" && twinEdge) {
+            coveredAsEvent = true;
+        }
+        const verdict = classifyContract(owned || attributed, excluded, coveredAsEvent);
+        if (verdict === "conflict") {
+            conflicting++;
+            findings.push({
+                predicate: "contract_coverage",
+                kind: "divergence",
+                subjectId: id,
+                classification: exclusionKey,
+            });
+        }
+        else if (verdict === "covered") {
+            covered++;
+        }
+        else if (verdict === "covered-as-event") {
+            viaEvent++;
+        }
+        else if (verdict === "excluded") {
+            excludedCount++;
+            byExclusion[exclusionKey] = (byExclusion[exclusionKey] ?? 0) + 1;
+        }
+        else {
+            unresolved++;
+            findings.push({
+                predicate: "contract_coverage",
+                kind: options.tier === "aggregate" ? "orphan" : "coverage",
+                subjectId: id,
+                classification: options.tier === "aggregate" ? "orphaned" : "unresolved-locally",
+            });
+        }
+    }
+    const consumersReader = await session.conn.runAndReadAll(CONSUMERS_NAMED_SQL);
+    const consumersNamed = Number(consumersReader.getRows()[0][0]);
+    return {
+        na: false,
+        findings,
+        metrics: {
+            total: rows.length,
+            covered,
+            viaEvent,
+            excluded: excludedCount,
+            conflicting,
+            unresolved,
+            byExclusion,
+            consumersNamed,
+            ownedOnly,
+            attrOnly,
+            both,
+        },
+        ...(availability !== undefined ? { availability } : {}),
+        ...(availabilityWarning !== undefined ? { availabilityWarning } : {}),
+    };
+}
+//# sourceMappingURL=coverage-predicates.js.map