kibi-cli 1.0.1 → 2.1.0

package/dist/public/impact/full-kb-quality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAUjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAoUF,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAkCvC"}
+{"version":3,"file":"full-kb-quality.d.ts","sourceRoot":"","sources":["../../../src/public/impact/full-kb-quality.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAatC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAWjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,KAAK,+BAA+B,GAAG;IACrC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,CAAC;IAC7D,QAAQ,CAAC,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAmgBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0D7B;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,OAAO,GAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAM/C;AA2ID,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAkCvC"}

package/dist/public/impact/full-kb-quality.js

@@ -1,30 +1,17 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
+import { normalizeEntityId, parseAtomList, parseEntityFromList, parseListOfLists, parseTriples, } from "../../prolog/codec.js";
 import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../operations/prolog-json.js";
+import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../proof-receipt.js";
+import relationshipSchema from "../schemas/relationship.js";
 import { analyzeTelemetryAcceptance, createTelemetryAcceptanceDiagnostics, parseTelemetryUsageLog, } from "../telemetry-acceptance.js";
-import { VERIFICATION_RECEIPT_MAX_AGE_SECONDS } from "../verification-receipt.js";
 import { createCoverageDepthQualityDiagnostics } from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
-const RELATIONSHIP_TYPES = [
-    "depends_on",
-    "executable_for",
-    "specified_by",
-    "verified_by",
-    "validates",
-    "implements",
-    "covered_by",
-    "constrained_by",
-    "constrains",
-    "requires_property",
-    "requires_predicate",
-    "guards",
-    "publishes",
-    "consumes",
-    "supersedes",
-    "relates_to",
-];
+const RELATIONSHIP_TYPES = relationshipSchema.properties.type.enum;
+const ENTITY_BATCH_SIZE = 32;
+const PROLOG_OUTPUT_CAPACITY_MARKER = "Query exceeded bounded Prolog output capacity (ENOBUFS)";
+const ENTITY_IDS_QUERY = "findall(Id, kb_entity(Id, _, _), Ids)";
 function stringField(entity, key) {
     const value = entity[key];
     return typeof value === "string" ? value : "";
@@ -43,6 +30,16 @@ function optionalStringArrayField(entity, key) {
         return undefined;
     return value.map((item) => String(item));
 }
+function optionalBooleanField(entity, key) {
+    const value = entity[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function optionalObjectField(entity, key) {
+    const value = entity[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 function toExtractedEntity(entity) {
     const extracted = {
         id: stringField(entity, "id"),
@@ -74,6 +71,27 @@ function toExtractedEntity(entity) {
     const logicClaims = optionalStringArrayField(entity, "logic_claims");
     if (logicClaims !== undefined)
         extracted.logic_claims = logicClaims;
+    const semanticClauses = optionalStringArrayField(entity, "semantic_clauses");
+    if (semanticClauses !== undefined)
+        extracted.semantic_clauses = semanticClauses;
+    const semanticInventoryVersion = optionalStringField(entity, "semantic_inventory_version");
+    if (semanticInventoryVersion === "kibi.semantic-inventory.v1") {
+        extracted.semantic_inventory_version = semanticInventoryVersion;
+    }
+    const semanticSourceField = optionalStringField(entity, "semantic_source_field");
+    if (semanticSourceField === "semantic_text" ||
+        semanticSourceField === "text_ref" ||
+        semanticSourceField === "title") {
+        extracted.semantic_source_field = semanticSourceField;
+    }
+    const semanticSourceHash = optionalStringField(entity, "semantic_source_hash");
+    if (semanticSourceHash !== undefined) {
+        extracted.semantic_source_hash = semanticSourceHash;
+    }
+    const semanticInventory = entity.semantic_inventory;
+    if (Array.isArray(semanticInventory)) {
+        extracted.semantic_inventory = semanticInventory;
+    }
     const granularityReason = optionalStringField(entity, "granularity_reason");
     if (granularityReason !== undefined) {
         extracted.granularity_reason = granularityReason;
@@ -90,6 +108,23 @@ function toExtractedEntity(entity) {
         verificationScope === "end_to_end") {
         extracted.verification_scope = verificationScope;
     }
+    const verificationPerspective = optionalStringField(entity, "verification_perspective");
+    if (verificationPerspective === "internal" ||
+        verificationPerspective === "consumer") {
+        extracted.verification_perspective = verificationPerspective;
+    }
+    const proofContract = optionalObjectField(entity, "proof_contract");
+    if (proofContract !== undefined) {
+        extracted.proof_contract = proofContract;
+    }
+    const proofBindings = entity.proof_bindings;
+    if (Array.isArray(proofBindings)) {
+        extracted.proof_bindings = proofBindings;
+    }
+    const proofReceipts = entity.proof_receipts;
+    if (Array.isArray(proofReceipts)) {
+        extracted.proof_receipts = proofReceipts;
+    }
     const sourceLine = optionalNumberField(entity, "sourceLine");
     if (sourceLine !== undefined)
         extracted.sourceLine = sourceLine;
@@ -108,25 +143,80 @@ function toExtractedEntity(entity) {
         factKind === "observation" ||
         factKind === "meta" ||
         factKind === "predicate_schema" ||
-        factKind === "predicate") {
+        factKind === "predicate" ||
+        factKind === "rule_schema" ||
+        factKind === "rule") {
         extracted.fact_kind = factKind;
     }
-    const claimKey = optionalStringField(entity, "claim_key");
-    if (claimKey !== undefined)
-        extracted.claim_key = claimKey;
-    const claimText = optionalStringField(entity, "claim_text");
-    if (claimText !== undefined)
-        extracted.claim_text = claimText;
-    const predicateName = optionalStringField(entity, "predicate_name");
-    if (predicateName !== undefined)
-        extracted.predicate_name = predicateName;
-    const predicateNamespace = optionalStringField(entity, "predicate_namespace");
-    if (predicateNamespace !== undefined) {
-        extracted.predicate_namespace = predicateNamespace;
+    for (const field of [
+        "subject_key",
+        "property_key",
+        "value_string",
+        "unit",
+        "scope",
+        "valid_from",
+        "valid_to",
+        "canonical_key",
+        "claim_key",
+        "claim_text",
+        "predicate_name",
+        "predicate_namespace",
+        "rule_hash",
+        "rule_schema_id",
+        "rule_name",
+        "semantic_key",
+    ]) {
+        const value = optionalStringField(entity, field);
+        if (value !== undefined)
+            extracted[field] = value;
     }
+    const operator = optionalStringField(entity, "operator");
+    if (operator === "eq" ||
+        operator === "neq" ||
+        operator === "lt" ||
+        operator === "lte" ||
+        operator === "gt" ||
+        operator === "gte") {
+        extracted.operator = operator;
+    }
+    const valueType = optionalStringField(entity, "value_type");
+    if (valueType === "string" ||
+        valueType === "int" ||
+        valueType === "number" ||
+        valueType === "bool") {
+        extracted.value_type = valueType;
+    }
+    const polarity = optionalStringField(entity, "polarity");
+    if (polarity === "require" ||
+        polarity === "forbid" ||
+        polarity === "assert" ||
+        polarity === "deny") {
+        extracted.polarity = polarity;
+    }
+    const valueInt = optionalNumberField(entity, "value_int");
+    if (valueInt !== undefined)
+        extracted.value_int = valueInt;
+    const valueNumber = optionalNumberField(entity, "value_number");
+    if (valueNumber !== undefined)
+        extracted.value_number = valueNumber;
     const predicateArity = optionalNumberField(entity, "predicate_arity");
     if (predicateArity !== undefined)
         extracted.predicate_arity = predicateArity;
+    const claimSpanStart = optionalNumberField(entity, "claim_span_start");
+    if (claimSpanStart !== undefined)
+        extracted.claim_span_start = claimSpanStart;
+    const claimSpanEnd = optionalNumberField(entity, "claim_span_end");
+    if (claimSpanEnd !== undefined)
+        extracted.claim_span_end = claimSpanEnd;
+    const valueBool = optionalBooleanField(entity, "value_bool");
+    if (valueBool !== undefined)
+        extracted.value_bool = valueBool;
+    const closedWorld = optionalBooleanField(entity, "closed_world");
+    if (closedWorld !== undefined)
+        extracted.closed_world = closedWorld;
+    const ruleIr = optionalObjectField(entity, "rule_ir");
+    if (ruleIr !== undefined)
+        extracted.rule_ir = ruleIr;
     for (const field of [
         "argument_names",
         "argument_types",
@@ -145,18 +235,200 @@ function sourceFileFor(entity) {
     return (optionalStringField(entity, "sourceFile") ??
         optionalStringField(entity, "source_file"));
 }
-async function loadKbExtractionResults(prolog) {
-    const entityResult = await prolog.query("findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)");
-    const entities = entityResult.bindings.Results
-        ? parseListOfLists(entityResult.bindings.Results).map(parseEntityFromList)
-        : [];
+class BoundedEntityProjectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BoundedEntityProjectionError";
+    }
+}
+function isOutputCapacityError(error) {
+    return error?.includes(PROLOG_OUTPUT_CAPACITY_MARKER) === true;
+}
+function parseAuthoritativeEntityIds(raw) {
+    const trimmed = raw.trim();
+    if (trimmed !== "[]" &&
+        (!trimmed.startsWith("[") || !trimmed.endsWith("]"))) {
+        throw new Error("Full KB entity ID enumeration returned malformed data");
+    }
+    const ids = parseAtomList(trimmed);
+    if (ids.some((id) => id.length === 0)) {
+        throw new Error("Full KB entity ID enumeration returned an empty ID");
+    }
+    return ids;
+}
+function validateEntityBatch(requestedIds, entities) {
+    const requested = new Set();
+    for (const id of requestedIds) {
+        const normalizedId = normalizeEntityId(id);
+        if (normalizedId.length === 0 || requested.has(normalizedId)) {
+            throw new Error("Full KB bounded entity projection returned duplicate or empty requested IDs");
+        }
+        requested.add(normalizedId);
+    }
+    const returned = new Map();
+    for (const entity of entities) {
+        const id = stringField(entity, "id");
+        const type = stringField(entity, "type");
+        const normalizedId = normalizeEntityId(id);
+        if (normalizedId.length === 0 || type.length === 0) {
+            throw new Error("Full KB bounded entity projection returned a malformed entity row");
+        }
+        if (!requested.has(normalizedId) || returned.has(normalizedId)) {
+            throw new Error(`Full KB bounded entity projection returned an unexpected entity ID: ${normalizedId}`);
+        }
+        returned.set(normalizedId, entity);
+    }
+    const missing = [...requested.keys()].filter((id) => !returned.has(id));
+    if (missing.length > 0) {
+        throw new Error(`Full KB bounded entity projection returned an incomplete page; missing ${missing.join(", ")}`);
+    }
+    return [...requested.keys()].map((id) => returned.get(id));
+}
+function validateIndexedEntityPage(entities, seenIds) {
+    const pageIds = new Set();
+    for (const entity of entities) {
+        const id = normalizeEntityId(stringField(entity, "id"));
+        const type = stringField(entity, "type");
+        if (id.length === 0 || type.length === 0) {
+            throw new Error("Full KB paginated entity projection returned a malformed entity row");
+        }
+        if (pageIds.has(id) || seenIds.has(id)) {
+            throw new Error(`Full KB paginated entity projection returned duplicate entity ID: ${id}`);
+        }
+        pageIds.add(id);
+    }
+    return [...entities];
+}
+function isOutputCapacityException(error) {
+    return isOutputCapacityError(error instanceof Error ? error.message : String(error));
+}
+async function loadIndexedEntityProjection(queryEntities) {
+    const entities = [];
+    const seenIds = new Set();
+    let offset = 0;
+    let pageSize = ENTITY_BATCH_SIZE;
+    let totalCount;
+    while (totalCount === undefined || offset < totalCount) {
+        let page;
+        try {
+            page = await queryEntities({ limit: pageSize, offset });
+        }
+        catch (error) {
+            if (!isOutputCapacityException(error) || pageSize === 1) {
+                throw error;
+            }
+            pageSize = Math.ceil(pageSize / 2);
+            continue;
+        }
+        if (!Number.isInteger(page.count) ||
+            page.count < 0 ||
+            (totalCount !== undefined && page.count !== totalCount)) {
+            throw new Error("Full KB paginated entity projection returned an inconsistent count");
+        }
+        totalCount ??= page.count;
+        if (page.entities.length > pageSize) {
+            throw new Error("Full KB paginated entity projection returned an oversized page");
+        }
+        const pageEntities = validateIndexedEntityPage(page.entities, seenIds);
+        if (offset + pageEntities.length > totalCount) {
+            throw new Error("Full KB paginated entity projection returned more rows than its count");
+        }
+        if (pageEntities.length === 0 && offset < totalCount) {
+            throw new Error("Full KB paginated entity projection returned an incomplete page");
+        }
+        for (const entity of pageEntities) {
+            seenIds.add(normalizeEntityId(stringField(entity, "id")));
+        }
+        entities.push(...pageEntities);
+        offset += pageEntities.length;
+        if (offset < totalCount && pageEntities.length < pageSize) {
+            throw new Error("Full KB paginated entity projection returned an incomplete page");
+        }
+    }
+    if (entities.length !== totalCount) {
+        throw new Error("Full KB paginated entity projection returned an incomplete result");
+    }
+    return entities;
+}
+async function loadEntityBatch(prolog, ids) {
+    const idTerms = ids.map((id) => toPrologAtom(id)).join(",");
+    const result = await prolog.query(`findall([Id,Type,Props], (member(Id, [${idTerms}]), kb_entity(Id, Type, Props)), Results)`);
+    if (!result.success) {
+        const message = result.error ?? "Unknown error";
+        if (isOutputCapacityError(result.error)) {
+            throw new BoundedEntityProjectionError(message);
+        }
+        throw new Error(`Full KB bounded entity projection query failed: ${message}`);
+    }
+    const rawRows = result.bindings.Results;
+    if (rawRows === undefined) {
+        throw new Error("Full KB bounded entity projection query returned no Results binding");
+    }
+    return validateEntityBatch(ids, parseListOfLists(rawRows).map(parseEntityFromList));
+}
+async function loadEntityBatchAdaptively(prolog, ids) {
+    try {
+        return await loadEntityBatch(prolog, ids);
+    }
+    catch (error) {
+        if (!(error instanceof BoundedEntityProjectionError))
+            throw error;
+        if (ids.length === 1) {
+            throw new Error(`Full KB entity projection failed for ${ids[0]}: ${error.message}`);
+        }
+        const midpoint = Math.ceil(ids.length / 2);
+        const left = await loadEntityBatchAdaptively(prolog, ids.slice(0, midpoint));
+        const right = await loadEntityBatchAdaptively(prolog, ids.slice(midpoint));
+        return [...left, ...right];
+    }
+}
+async function loadBoundedEntityProjection(prolog) {
+    const idsResult = await prolog.query(ENTITY_IDS_QUERY);
+    if (!idsResult.success) {
+        throw new Error(`Full KB entity ID enumeration query failed: ${idsResult.error ?? "Unknown error"}`);
+    }
+    const rawIds = idsResult.bindings.Ids;
+    if (rawIds === undefined) {
+        throw new Error("Full KB entity ID enumeration query returned no Ids binding");
+    }
+    const ids = parseAuthoritativeEntityIds(rawIds);
+    const entities = [];
+    for (let offset = 0; offset < ids.length; offset += ENTITY_BATCH_SIZE) {
+        entities.push(...(await loadEntityBatchAdaptively(prolog, ids.slice(offset, offset + ENTITY_BATCH_SIZE))));
+    }
+    return entities;
+}
+export async function loadKbExtractionResults(prolog) {
+    let entities;
+    if (prolog.queryEntities !== undefined) {
+        entities = await loadIndexedEntityProjection(prolog.queryEntities.bind(prolog));
+    }
+    else {
+        const entityResult = await prolog.query("findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)");
+        if (entityResult.success) {
+            entities = entityResult.bindings.Results
+                ? parseListOfLists(entityResult.bindings.Results).map(parseEntityFromList)
+                : [];
+        }
+        else if (isOutputCapacityError(entityResult.error)) {
+            entities = await loadBoundedEntityProjection(prolog);
+        }
+        else {
+            throw new Error(`Full KB entity projection query failed: ${entityResult.error ?? "Unknown error"}`);
+        }
+    }
     const relationships = new Map();
     for (const relationshipType of RELATIONSHIP_TYPES) {
         const relResult = await prolog.query(`findall([From,To,'${relationshipType}'], kb_relationship(${relationshipType}, From, To), Rels)`);
+        if (!relResult.success) {
+            throw new Error(`Full KB relationship projection query failed for ${relationshipType}: ${relResult.error ?? "Unknown error"}`);
+        }
         const rows = relResult.bindings.Rels
             ? parseTriples(relResult.bindings.Rels)
             : [];
-        for (const [from, to, type] of rows) {
+        for (const [rawFrom, rawTo, type] of rows) {
+            const from = normalizeEntityId(rawFrom);
+            const to = normalizeEntityId(rawTo);
             const current = relationships.get(from) ?? [];
             current.push({ from, to, type });
             relationships.set(from, current);
@@ -174,30 +446,29 @@ async function loadKbExtractionResults(prolog) {
         return result;
     });
 }
-function stringArrayField(value) {
-    return Array.isArray(value) ? value.map(String) : undefined;
-}
-function proofStage(row) {
-    const stages = row.proofStages;
-    if (!stages || typeof stages !== "object" || Array.isArray(stages)) {
-        return undefined;
-    }
-    const passingE2e = stages.passingE2e;
+export function passingE2eStage(passingE2e) {
     return passingE2e &&
         typeof passingE2e === "object" &&
         !Array.isArray(passingE2e)
         ? passingE2e
         : undefined;
 }
-async function loadCoverageProofEvidence(prolog, requirementCount, verificationSnapshot, checkedAt) {
-    if (verificationSnapshot === undefined ||
+function stringArrayField(value) {
+    return Array.isArray(value) ? value.map(String) : undefined;
+}
+async function loadCoverageProofEvidence(prolog, requirementCount, proofSnapshot, checkedAt) {
+    if (proofSnapshot === undefined ||
         checkedAt === undefined ||
         requirementCount === 0) {
         return new Map();
     }
     let payload;
     try {
-        payload = await runOperationJsonQuery(prolog, "discovery.pl", `discovery:coverage_report_json('req', ${toPrologList([])}, true, true, ${requirementCount}, 0, ${toPrologAtom(verificationSnapshot)}, ${toPrologAtom(checkedAt)}, ${VERIFICATION_RECEIPT_MAX_AGE_SECONDS}, JsonString)`, "Quality diagnostic coverage evidence");
+        // W1 push-down: the slim evidence projection returns only the fields the
+        // quality diagnostics consume, keeping the response far below the output
+        // capacity limit on large KBs (the full coverage report rows were the
+        // original ENOBUFS offender).
+        payload = await runOperationJsonQuery(prolog, "discovery.pl", `discovery:coverage_evidence_json(${toPrologList([])}, ${toPrologAtom(proofSnapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`, "Quality diagnostic coverage evidence");
     }
     catch {
         // Quality diagnostics must fail closed when the optional proof readback is
@@ -209,23 +480,17 @@ async function loadCoverageProofEvidence(prolog, requirementCount, verificationS
         const id = typeof row.id === "string" ? row.id : undefined;
         if (id === undefined)
             continue;
-        const passingE2e = proofStage(row);
-        const proofGaps = stringArrayField(row.proofGaps);
-        const passingE2eTests = stringArrayField(passingE2e?.tests);
+        const passingE2eTests = stringArrayField(row.passingE2eTests) ?? [];
         evidence.set(id, {
             ...(typeof row.proofStatus === "string"
                 ? { proofStatus: row.proofStatus }
                 : {}),
-            ...(typeof passingE2e?.status === "string"
-                ? { passingE2eStatus: passingE2e.status }
+            ...(typeof row.passingE2eStatus === "string"
+                ? { passingE2eStatus: row.passingE2eStatus }
                 : {}),
-            ...(passingE2eTests !== undefined ? { passingE2eTests } : {}),
-            ...(proofGaps !== undefined
-                ? {
-                    receiptGapCodes: proofGaps.filter((gap) => gap.includes("verification_receipt") ||
-                        gap.includes("verification_contract") ||
-                        gap.includes("verification_snapshot")),
-                }
+            passingE2eTests,
+            ...(Array.isArray(row.receiptGapCodes)
+                ? { receiptGapCodes: row.receiptGapCodes.map(String) }
                 : {}),
         });
     }
@@ -283,7 +548,7 @@ export async function collectFullKbQualityDiagnostics(options) {
         loadKbExtractionResults(options.prolog),
         collectTelemetryDiagnostics(options.workspaceRoot, options.now ?? new Date()),
     ]);
-    const proofEvidence = await loadCoverageProofEvidence(options.prolog, manifestResults.filter((result) => result.entity.type === "req").length, options.verificationSnapshot, options.checkedAt);
+    const proofEvidence = await loadCoverageProofEvidence(options.prolog, manifestResults.filter((result) => result.entity.type === "req").length, options.proofSnapshot, options.checkedAt);
     const coverageDepthDiagnostics = createCoverageDepthQualityDiagnostics(manifestResults, proofEvidence);
     const diagnostics = [
         ...telemetryDiagnostics,