kibi-cli 0.19.0 → 2.0.0

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

@@ -1,28 +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 { 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 : "";
@@ -41,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"),
@@ -72,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;
@@ -88,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;
@@ -106,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",
@@ -143,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);
@@ -172,6 +446,56 @@ async function loadKbExtractionResults(prolog) {
         return result;
     });
 }
+export function passingE2eStage(passingE2e) {
+    return passingE2e &&
+        typeof passingE2e === "object" &&
+        !Array.isArray(passingE2e)
+        ? passingE2e
+        : 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 {
+        // 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
+        // unavailable; a failed advisory query must not make kb_check fail.
+        return new Map();
+    }
+    const evidence = new Map();
+    for (const row of payload.rows ?? []) {
+        const id = typeof row.id === "string" ? row.id : undefined;
+        if (id === undefined)
+            continue;
+        const passingE2eTests = stringArrayField(row.passingE2eTests) ?? [];
+        evidence.set(id, {
+            ...(typeof row.proofStatus === "string"
+                ? { proofStatus: row.proofStatus }
+                : {}),
+            ...(typeof row.passingE2eStatus === "string"
+                ? { passingE2eStatus: row.passingE2eStatus }
+                : {}),
+            passingE2eTests,
+            ...(Array.isArray(row.receiptGapCodes)
+                ? { receiptGapCodes: row.receiptGapCodes.map(String) }
+                : {}),
+        });
+    }
+    return evidence;
+}
 function capDiagnostics(diagnostics, maxDiagnostics) {
     return maxDiagnostics !== undefined && maxDiagnostics >= 0
         ? diagnostics.slice(0, maxDiagnostics)
@@ -224,7 +548,8 @@ export async function collectFullKbQualityDiagnostics(options) {
         loadKbExtractionResults(options.prolog),
         collectTelemetryDiagnostics(options.workspaceRoot, options.now ?? new Date()),
     ]);
-    const coverageDepthDiagnostics = createCoverageDepthQualityDiagnostics(manifestResults);
+    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,
         ...createRequirementQualityDiagnostics({

package/dist/public/impact/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/public/impact/manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAc3E,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,SAAS,gBAAgB,EAAE,CAoB7B;AAED,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,SAAS,gBAAgB,EAAE,GAC3C,cAAc,CAYhB"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../src/public/impact/manifest.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAc3E,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,SAAS,gBAAgB,EAAE,CAkB7B;AAED,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,SAAS,gBAAgB,EAAE,GAC3C,cAAc,CAYhB"}

package/dist/public/impact/manifest.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { extractFromManifest } from "../../extractors/manifest.js";
-import { loadConfig } from "../../utils/config.js";
+import { CANONICAL_ENTITY_PATHS } from "../../utils/kb-paths.js";
 import { isTraceabilityRelationshipType } from "../symbol-granularity.js";
 import { normalizeSourceFile } from "./source-changes.js";
 function toTraceabilityRelationships(relationships) {
@@ -10,10 +10,7 @@ function toTraceabilityRelationships(relationships) {
         .map((relationship) => ({ type: relationship.type, to: relationship.to }));
 }
 export function readImpactManifestResults(workspaceRoot) {
-    const config = loadConfig(workspaceRoot);
-    const symbolsPath = config.paths.symbols;
-    if (!symbolsPath)
-        return [];
+    const symbolsPath = CANONICAL_ENTITY_PATHS.symbols;
     const absolutePath = path.isAbsolute(symbolsPath)
         ? symbolsPath
         : path.resolve(workspaceRoot, symbolsPath);

package/dist/public/operational-artifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operational-artifacts.d.ts","sourceRoot":"","sources":["../../src/public/operational-artifacts.ts"],"names":[],"mappings":"AAAA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAKnE"}
+{"version":3,"file":"operational-artifacts.d.ts","sourceRoot":"","sources":["../../src/public/operational-artifacts.ts"],"names":[],"mappings":"AAAA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAanE"}

package/dist/public/operational-artifacts.js

@@ -1,5 +1,11 @@
 export function isOperationalArtifactPath(pathLike) {
     // implements REQ-001
     const normalized = pathLike.replaceAll("\\", "/");
-    return /(^|\/)\.sisyphus\//.test(normalized);
+    // Recovery journals and pending-source receipts are runtime-owned
+    // operational state.  They must remain visible to Kibi's recovery/status
+    // services, but they are not authored evidence and must not make a Git
+    // verification snapshot dirty or enter source compilation as arbitrary
+    // untracked files.
+    return (/(^|\/)\.sisyphus\//.test(normalized) ||
+        /(^|\/)\.kb\/recovery(?:\/|$)/.test(normalized));
 }