kibi-cli 2.31.1 → 2.32.0

package/dist/public/impact/coverage-depth-quality.js

@@ -1,3 +1,4 @@
+import { COARSE_GRANULARITY_REASONS } from "../symbol-granularity.generated.js";
 function entitiesById(manifestResults) {
     return new Map(manifestResults.map((result) => [result.entity.id, result.entity]));
 }
@@ -223,3 +224,61 @@ export function createCoverageDepthQualityDiagnostics(manifestResults, proofByRe
     })
         .toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
 }
+const COARSE_REASONS = new Set(COARSE_GRANULARITY_REASONS);
+/**
+ * Requirements whose every implementing production symbol is a whole-file
+ * anchor (a coarse granularity_reason). Coverage then only says some test
+ * touches the file, so `tested` evidence is cheap; narrower behavioral
+ * symbols would tie it to the code that implements the claim.
+ */
+// implements REQ-audit-quality-diagnostics-v1
+export function createCoarseAnchorQualityDiagnostics(manifestResults) {
+    const superseded = supersededRequirementIds(manifestResults);
+    const anchorsByRequirement = new Map();
+    for (const result of manifestResults) {
+        if (result.entity.type !== "symbol")
+            continue;
+        // Executable test code is not a production symbol.
+        if (result.relationships.some((rel) => rel.type === "executable_for"))
+            continue;
+        for (const relationship of result.relationships) {
+            if (relationship.type !== "implements")
+                continue;
+            const list = anchorsByRequirement.get(relationship.to) ?? [];
+            list.push(result.entity);
+            anchorsByRequirement.set(relationship.to, list);
+        }
+    }
+    return manifestResults
+        .filter((result) => result.entity.type === "req" &&
+        isReviewableRequirement(result.entity, superseded))
+        .flatMap((result) => {
+        const symbols = uniqueEntities(anchorsByRequirement.get(result.entity.id) ?? []);
+        if (symbols.length === 0 ||
+            !symbols.every((symbol) => COARSE_REASONS.has(symbol.granularity_reason ?? "")))
+            return [];
+        const requirement = result.entity;
+        return [
+            {
+                id: "coarse_anchor_only_review",
+                severity: "review",
+                blocking: false,
+                category: "coverage",
+                entityId: requirement.id,
+                source: requirement.source,
+                files: [requirement.source],
+                message: `Requirement ${requirement.id} (${requirement.title}) is implemented only by whole-file anchors, so its coverage says a test touches those files, not the code behind the claim.`,
+                suggestion: "Link the functions, methods or types that implement the requirement with implements (and covered_by to their tests); keep the file anchor only for genuinely module-level behavior.",
+                evidence: {
+                    requirementId: requirement.id,
+                    title: requirement.title,
+                    symbols: symbols.map((symbol) => ({
+                        id: symbol.id,
+                        granularityReason: symbol.granularity_reason ?? "",
+                    })),
+                },
+            },
+        ];
+    })
+        .toSorted((left, right) => (left.entityId ?? "").localeCompare(right.entityId ?? ""));
+}

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":"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;AAogBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;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"}
+{"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;AAcjE,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;AAqgBF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,CAAC,GAClD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8C7B;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,CAmCvC"}

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

@@ -5,7 +5,7 @@ import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../operation
 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 { createCoarseAnchorQualityDiagnostics, createCoverageDepthQualityDiagnostics, } from "./coverage-depth-quality.js";
 import { createRequirementQualityDiagnostics } from "./requirement-quality.js";
 import { createSymbolQualityDiagnostics } from "./symbol-quality.js";
 const RELATIONSHIP_TYPES = relationshipSchema.properties.type.enum;
@@ -225,6 +225,7 @@ function toExtractedEntity(entity) {
         "aliases",
         "examples",
         "predicate_args",
+        "value_set",
     ]) {
         const values = optionalStringArrayField(entity, field);
         if (values !== undefined)
@@ -552,6 +553,7 @@ export async function collectFullKbQualityDiagnostics(options) {
                 : {}),
         }),
         ...coverageDepthDiagnostics,
+        ...createCoarseAnchorQualityDiagnostics(manifestResults),
         ...createSymbolQualityDiagnostics({
             manifestResults,
             symbolsByFile: new Map(),

package/dist/public/operations/catalog.d.ts

@@ -1147,6 +1147,11 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly enum: readonly ["firm", "default", "exploratory"];
                         readonly description: "req/adr only. firm = a human stated it as a rule (needs origin.ref to their words); its title, meaning or firmness changes only with new human words (a new origin.ref) or by supersede. default = delegated or agent choice; exploratory = flagged guess. Absent = default if an agent wrote it, else firm.";
                     };
+                    readonly required_evidence: {
+                        readonly type: "string";
+                        readonly enum: readonly ["proved", "tested", "asserted", "unverified"];
+                        readonly description: "Requirement-only. Weakest evidence level it accepts; the evidence-floor rule fails below it. Absent = tested if firm, else unverified.";
+                    };
                     readonly rationale: {
                         readonly type: "string";
                         readonly minLength: 1;
@@ -1226,7 +1231,87 @@ export declare const OPERATION_CATALOG: readonly [{
                             };
                             readonly success_policy: {
                                 readonly type: "string";
-                                readonly enum: readonly ["all_required_first_attempt"];
+                                readonly enum: readonly ["all_required_first_attempt", "own_results_first_attempt"];
+                            };
+                            readonly kind: {
+                                readonly type: "string";
+                                readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
+                                readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic and smt must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved.";
+                            };
+                            readonly domain_source: {
+                                readonly type: "object";
+                                readonly description: "exhaustive and typecheck: the symbol that defines the finite domain. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
+                                readonly required: readonly ["symbol_id"];
+                                readonly properties: {
+                                    readonly symbol_id: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly export: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                        readonly description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.";
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                            readonly witness: {
+                                readonly type: "object";
+                                readonly description: "typecheck: the repository-relative witness file Kibi compiles (an exhaustive switch ending in never, or a mapped type over the domain).";
+                                readonly required: readonly ["path"];
+                                readonly properties: {
+                                    readonly path: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                            readonly proves: {
+                                readonly type: "array";
+                                readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt); a claim with no such derivation is only attested and never counts as proved.";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly pattern: "^CLAIM-";
+                                };
+                                readonly uniqueItems: true;
+                            };
+                            readonly value_source: {
+                                readonly type: "array";
+                                readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base.";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["symbol_id"];
+                                    readonly properties: {
+                                        readonly symbol_id: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                        readonly export: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                    };
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                            readonly constraint_source: {
+                                readonly type: "object";
+                                readonly description: "arithmetic and smt: the typed numeric property_value facts the certificate's assumptions come from. Kibi checks the assumptions (or the query's assertions) are exactly these facts' constraints, so the proof is about the knowledge base, not numbers the test chose.";
+                                readonly required: readonly ["fact_ids"];
+                                readonly properties: {
+                                    readonly fact_ids: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                    };
+                                };
+                                readonly additionalProperties: false;
                             };
                         };
                         readonly additionalProperties: false;
@@ -1274,12 +1359,12 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly maxItems: 50;
                         readonly items: {
                             readonly type: "object";
-                            readonly description: "Kibi-derived kibi.proof-receipt.v1. Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.";
+                            readonly description: "Kibi-derived kibi.proof-receipt.v2 (kibi.proof-receipt.v1 entries are still read). Receipts are never caller-authored; kb_ingest_proof derives them from kibi.proof-run.v1 artifacts.";
                             readonly required: readonly ["version", "receipt_id", "test_id", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "contract_hash", "fingerprint", "fingerprint_components", "integration_id", "producer", "command_argv", "run_outcome", "proof_results"];
                             readonly properties: {
                                 readonly version: {
                                     readonly type: "string";
-                                    readonly const: "kibi.proof-receipt.v1";
+                                    readonly enum: readonly ["kibi.proof-receipt.v1", "kibi.proof-receipt.v2"];
                                 };
                                 readonly receipt_id: {
                                     readonly type: "string";
@@ -1461,6 +1546,63 @@ export declare const OPERATION_CATALOG: readonly [{
                                         readonly additionalProperties: false;
                                     };
                                 };
+                                readonly kind: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
+                                };
+                                readonly evidence_level: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["proved", "tested"];
+                                };
+                                readonly certificate: {
+                                    readonly type: "object";
+                                };
+                                readonly certificate_digest: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-f0-9]{64}$";
+                                };
+                                readonly certificate_rejection: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly claim_bindings: {
+                                    readonly type: "array";
+                                    readonly description: "Certificate kinds: how the certificate binds to each claim its contract names in proves, judged at ingest. derived means Kibi derived the certificate's obligation from the claim's grounding fact and the certificate satisfies it; attested means no derivation exists and the author vouches for it (never proved); rejected names why.";
+                                    readonly items: {
+                                        readonly type: "object";
+                                        readonly required: readonly ["claim_key", "binding"];
+                                        readonly properties: {
+                                            readonly claim_key: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly requirement_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly fact_id: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                            readonly binding: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["derived", "attested", "rejected"];
+                                            };
+                                            readonly scope: {
+                                                readonly type: "string";
+                                                readonly enum: readonly ["code", "intent"];
+                                            };
+                                            readonly obligation: {
+                                                readonly type: "object";
+                                            };
+                                            readonly reason: {
+                                                readonly type: "string";
+                                                readonly minLength: 1;
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    };
+                                };
                                 readonly gaps: {
                                     readonly type: "array";
                                     readonly items: {
@@ -1508,8 +1650,8 @@ export declare const OPERATION_CATALOG: readonly [{
                     };
                     readonly value_type: {
                         readonly type: "string";
-                        readonly enum: readonly ["string", "int", "number", "bool"];
-                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, or value_bool; do not use generic value.";
+                        readonly enum: readonly ["string", "int", "number", "bool", "set"];
+                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, value_bool, or value_set (set: an exact list of allowed values, operator eq or neq); do not use generic value.";
                     };
                     readonly value_string: {
                         readonly type: "string";
@@ -1527,6 +1669,16 @@ export declare const OPERATION_CATALOG: readonly [{
                         readonly type: "boolean";
                         readonly description: "Optional boolean value for property_value facts.";
                     };
+                    readonly value_set: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly description: "Optional exact set of values for property_value facts with value_type set, such as the members a domain must have.";
+                    };
                     readonly unit: {
                         readonly type: "string";
                         readonly description: "Optional unit for numeric property_value facts.";
@@ -1859,7 +2011,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, symbol-granularity, no-dangling-refs, source-relationship-parity, branch-store-not-compiled, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, related-requirement-unmodeled, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance, entity-context-missing, entity-context-acknowledged, decision-firm-unreferenced, decision-firm-superseded, decision-firm-edited, supersedes-reason-missing, supersedes-reason-acknowledged, policy-ownership, policy-markers, kb-consistency, kb-consistency-unresolved, evidence-floor, proof-contract-claims. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -2472,6 +2624,15 @@ export declare const OPERATION_CATALOG: readonly [{
                             readonly minLength: 1;
                         };
                     };
+                    readonly certificates: {
+                        readonly type: "array";
+                        readonly description: "kibi.code-certificate.v1 objects the run left for certificate-kind contracts, one per test. Kibi re-checks each before a receipt counts as proved.";
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["version", "kind", "test_id"];
+                        };
+                    };
                 };
                 readonly additionalProperties: false;
             };

package/dist/public/operations/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBe,CAAC;AAyF9C,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,GAClB,qBAAqB,CA+BvB;AAQD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,qBAAqB,GAAG,SAAS,EACvC,IAAI,EAAE,aAAa,GAClB,qBAAqB,CAKvB;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,qBAAqB,CAElE;AAGD,wBAAgB,SAAS,IAAI,SAAS,qBAAqB,EAAE,CAE5D"}

package/dist/public/operations/check-executor.d.ts

@@ -11,6 +11,8 @@ export type CheckInput = {
     readonly includeWorkingTreeDiff?: boolean;
     readonly includeImpactDiagnostics?: boolean;
     readonly maxDiagnostics?: number;
+    /** evidence-floor judges receipts as they are and needs a clean snapshot. */
+    readonly freshEvidence?: boolean;
 };
 export type CheckPayload = CheckStructuredContent;
 export type { CheckDiagnostic, CheckEvaluated, CheckStructuredContent };

package/dist/public/operations/check-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAIL,iBAAiB,EAGjB,iBAAiB,EAGlB,MAAM,oBAAoB,CAAC;AAY5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAOvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,sBAAsB,EAAE,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;IACjE;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAoFF;;;;;GAKG;AAEH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,MAAM,GACpB,SAAS,GAAG,IAAI,CAgClB;AAGD,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA+PxC"}
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAIL,iBAAiB,EAGjB,iBAAiB,EAGlB,MAAM,oBAAoB,CAAC;AAc5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AAOvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,sBAAsB,EAAE,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;IACjE;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAoFF;;;;;GAKG;AAEH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,MAAM,GACpB,SAAS,GAAG,IAAI,CAgClB;AAGD,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAwQxC"}

package/dist/public/operations/check-executor.js

@@ -8,9 +8,11 @@ import { collectCheckPolicyViolations } from "./check-policy-rules.js";
 import { collectDecisionFirmnessViolations } from "./decision-firmness.js";
 import { executeStatus } from "./discovery-executors.js";
 import { collectEntityContextViolations } from "./entity-context.js";
+import { collectEvidenceFloorViolations } from "./evidence-floor.js";
 import { buildActionsFromCheck, buildMigrationPlan, mergeMigrationPlans, } from "./migration-plan.js";
 import { collectOriginReviewViolations } from "./origin-review.js";
 import { collectPredicateSchemaConformanceViolations } from "./predicate-schema-conformance.js";
+import { collectProofContractClaimViolations } from "./proof-contract-claims.js";
 import { SOURCE_PATH_DANGLING_RULE, collectSourcePathDanglingViolations, } from "./source-path-dangling.js";
 import { collectSourceRelationshipParityViolations } from "./source-relationship-parity.js";
 import { collectSymbolGranularityViolations } from "./symbol-granularity-check.js";
@@ -242,6 +244,8 @@ export async function executeCheck(args, context, options = {}) {
         const entityContextFindings = collectEntityContextViolations(rulesAllowlist, workspaceRoot);
         const decisionFirmnessFindings = collectDecisionFirmnessViolations(rulesAllowlist, workspaceRoot);
         const checkPolicyFindings = await collectCheckPolicyViolations(prolog, rulesAllowlist, workspaceRoot);
+        const evidenceFloorFindings = await collectEvidenceFloorViolations(context, rulesAllowlist, { freshEvidence: args.freshEvidence === true });
+        const proofContractClaimFindings = await collectProofContractClaimViolations(context, rulesAllowlist);
         const partitioned = partitionCheckFindings([
             ...aggregatedFindings,
             ...queryPlanViolations,
@@ -253,6 +257,8 @@ export async function executeCheck(args, context, options = {}) {
             ...entityContextFindings,
             ...decisionFirmnessFindings,
             ...checkPolicyFindings,
+            ...evidenceFloorFindings,
+            ...proofContractClaimFindings,
         ]);
         const violations = partitioned.violations;
         const evaluated = await describeEvaluation(prolog, rulesAllowlist);

package/dist/public/operations/evidence-floor.d.ts

@@ -0,0 +1,48 @@
+import type { Violation } from "../../utils/rule-registry.js";
+import type { OperationContext } from "./runtime-types.js";
+import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
+/**
+ * The schema version from which a current requirement's evidence level must
+ * reach its floor; older KBs get the floor with their schema upgrade, whose
+ * migration records the floor of firm requirements without a proof path.
+ */
+export declare const EVIDENCE_FLOOR_SCHEMA_VERSION = 11;
+/** A current requirement's evidence level must reach its floor. */
+export declare const EVIDENCE_FLOOR_RULE = "evidence-floor";
+export type EvidenceFloorRow = Readonly<{
+    id: string;
+    evidenceLevel: string;
+    requiredEvidence: string;
+    requiredEvidenceSource: string;
+    status: "below" | "pending_reproof";
+    proofStatus: string;
+    proofGaps: readonly string[];
+    /** The tests and symbols behind the gaps; empty lists are left out. */
+    gapDetails?: Readonly<Record<string, readonly string[]>>;
+}>;
+export type EvidenceFloorOptions = Readonly<{
+    /**
+     * Judge receipts as they are: stale receipts no longer count as pending
+     * re-proof, and the proof snapshot must be clean. CI uses it right after
+     * `kibi prove --all`.
+     */
+    freshEvidence?: boolean;
+}>;
+/** The entities behind the gaps, for a person reading kibi check's text. */
+export declare function gapDetailLines(row: EvidenceFloorRow): string[];
+/** One finding per current requirement whose evidence is below its floor. */
+export declare function evidenceFloorViolations(rows: readonly EvidenceFloorRow[], options?: EvidenceFloorOptions): Violation[];
+/**
+ * Every current requirement whose evidence is below its floor (status below
+ * or pending_reproof), judged on the attached store with the same
+ * per-contract receipt binding kb_coverage uses. Unlike the check rule this
+ * ignores the schema version, so a migration can read the floor the ladder
+ * will apply before it records the new schema.
+ */
+export declare function readEvidenceFloorRows(context: OperationContext, snapshotEvidence?: Awaited<ReturnType<typeof readWorkspaceSnapshot>>): Promise<readonly EvidenceFloorRow[]>;
+/**
+ * Evaluate the evidence-floor rule against the attached store, with the same
+ * per-contract receipt binding kb_coverage uses.
+ */
+export declare function collectEvidenceFloorViolations(context: OperationContext, rules: ReadonlySet<string>, options?: EvidenceFloorOptions): Promise<Violation[]>;
+//# sourceMappingURL=evidence-floor.d.ts.map

package/dist/public/operations/evidence-floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-floor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/evidence-floor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;GAIG;AAEH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD,mEAAmE;AAEnE,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAGpD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,uEAAuE;IACvE,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CAC1D,CAAC,CAAC;AAOH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,CAAC;AAqBH,4EAA4E;AAE5E,wBAAgB,cAAc,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAQ9D;AAeD,6EAA6E;AAE7E,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,OAAO,GAAE,oBAAyB,GACjC,SAAS,EAAE,CAqBb;AAED;;;;;;GAMG;AAEH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,EACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,GACnE,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAgBtC;AAED;;;GAGG;AAEH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CA4BtB"}

package/dist/public/operations/evidence-floor.js

@@ -0,0 +1,143 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { readKbManifest } from "../../utils/kb-manifest.js";
+import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../proof-receipt.js";
+import { runOperationJsonQuery, toPrologAtom } from "./prolog-json.js";
+import { readWorkspaceSnapshot } from "./workspace-snapshot.js";
+/**
+ * The schema version from which a current requirement's evidence level must
+ * reach its floor; older KBs get the floor with their schema upgrade, whose
+ * migration records the floor of firm requirements without a proof path.
+ */
+// implements REQ-kibi-evidence-floors
+export const EVIDENCE_FLOOR_SCHEMA_VERSION = 11;
+/** A current requirement's evidence level must reach its floor. */
+// implements REQ-kibi-evidence-floors
+export const EVIDENCE_FLOOR_RULE = "evidence-floor";
+function floorSource(row) {
+    return row.requiredEvidenceSource === "explicit"
+        ? "its required_evidence"
+        : row.requiredEvidence === "tested"
+            ? "the floor of a firm requirement"
+            : "its floor";
+}
+const GAP_DETAIL_LABELS = {
+    failedReceiptTests: "failing receipts",
+    missingReceiptTests: "no receipt",
+    staleReceiptTests: "stale receipts",
+    invalidReceiptTests: "invalid receipts",
+    contractMismatchReceiptTests: "receipts for an older contract",
+    uncoveredSymbols: "production symbols without qualifying coverage",
+    missingCoordinateSymbols: "symbols without source coordinates",
+    unprovedClaims: "claims no certificate derives",
+};
+/** The entities behind the gaps, for a person reading kibi check's text. */
+// implements REQ-kibi-evidence-floors
+export function gapDetailLines(row) {
+    return Object.entries(row.gapDetails ?? {}).flatMap(([key, ids]) => ids.length === 0
+        ? []
+        : [
+            `${GAP_DETAIL_LABELS[key] ?? key}: ${ids.slice(0, 8).join(", ")}${ids.length > 8 ? ` (+${ids.length - 8} more)` : ""}`,
+        ]);
+}
+function suggestionFor(row) {
+    if (row.status === "pending_reproof")
+        return `Run kibi prove for the tests behind ${row.id} so its receipts match the current code, then rerun kibi check --fresh-evidence.`;
+    switch (row.requiredEvidence) {
+        case "proved":
+            return `Prove every applicable claim of ${row.id}${(row.gapDetails?.unprovedClaims ?? []).length > 0 ? ` (unproved: ${(row.gapDetails?.unprovedClaims ?? []).join(", ")})` : ""}: model each as a set fact (prove it with exhaustive or typecheck) or a numeric fact (arithmetic or smt), name it in a certificate test's proof_contract.proves, and run kibi prove; kibi proof explain ${row.id} shows each claim's bindings. A claim with no such fact can only be attested, so lower required_evidence to tested with the reason in the requirement if that is enough.`;
+        case "tested":
+            return `Link ${row.id} to a scenario with an end-to-end test that has a proof contract, run kibi prove, and fix its proof gaps (${row.proofGaps.join(", ") || "none listed"}${gapDetailLines(row).length > 0 ? `; ${gapDetailLines(row).join("; ")}` : ""}); kibi proof explain ${row.id} shows each one. Or lower required_evidence if a person decides it does not need tests.`;
+        default:
+            return `Have a person approve ${row.id} (origin.approved_by) or state it as firm with origin.ref to their words, or lower required_evidence.`;
+    }
+}
+/** One finding per current requirement whose evidence is below its floor. */
+// implements REQ-kibi-evidence-floors
+export function evidenceFloorViolations(rows, options = {}) {
+    return rows
+        .filter((row) => options.freshEvidence === true || row.status === "below")
+        .map((row) => ({
+        rule: EVIDENCE_FLOOR_RULE,
+        entityId: row.id,
+        description: row.status === "pending_reproof"
+            ? `${row.id} is ${row.evidenceLevel} but needs ${row.requiredEvidence} (${floorSource(row)}); its receipts are older than the code`
+            : `${row.id} is ${row.evidenceLevel} but needs ${row.requiredEvidence} (${floorSource(row)})`,
+        suggestion: suggestionFor(row),
+        evidence: {
+            evidenceLevel: row.evidenceLevel,
+            requiredEvidence: row.requiredEvidence,
+            requiredEvidenceSource: row.requiredEvidenceSource,
+            status: row.status,
+            proofStatus: row.proofStatus,
+            proofGaps: row.proofGaps,
+            ...(row.gapDetails === undefined ? {} : { gapDetails: row.gapDetails }),
+        },
+    }));
+}
+/**
+ * Every current requirement whose evidence is below its floor (status below
+ * or pending_reproof), judged on the attached store with the same
+ * per-contract receipt binding kb_coverage uses. Unlike the check rule this
+ * ignores the schema version, so a migration can read the floor the ladder
+ * will apply before it records the new schema.
+ */
+// implements REQ-kibi-evidence-floors
+export async function readEvidenceFloorRows(context, snapshotEvidence) {
+    const prolog = context.prolog ?? (await context.ensureProlog?.());
+    if (prolog === undefined)
+        return [];
+    const evidence = snapshotEvidence ?? (await readWorkspaceSnapshot(context));
+    const snapshot = evidence.available ? evidence.snapshot.hash : "unknown";
+    const { perContractTestBindings } = await import("./specs/reporting.js");
+    const bindings = await perContractTestBindings({ ...context, prolog });
+    const checkedAt = context.clock().toISOString();
+    const goal = `discovery:evidence_floor_json(${bindings === null ? "strict_snapshot, _{}" : `per_contract, ${bindings}`}, ${toPrologAtom(snapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`;
+    const payload = await runOperationJsonQuery(prolog, "discovery.pl", goal, "Evidence floor evaluation");
+    return payload.rows ?? [];
+}
+/**
+ * Evaluate the evidence-floor rule against the attached store, with the same
+ * per-contract receipt binding kb_coverage uses.
+ */
+// implements REQ-kibi-evidence-floors
+export async function collectEvidenceFloorViolations(context, rules, options = {}) {
+    if (!rules.has(EVIDENCE_FLOOR_RULE) || context.prolog === undefined)
+        return [];
+    // A store without a manifest predates schema 11 as much as an old one.
+    const schemaVersion = readKbManifest(context.workspaceRoot)?.schemaVersion;
+    if (schemaVersion === undefined ||
+        schemaVersion < EVIDENCE_FLOOR_SCHEMA_VERSION)
+        return [];
+    const snapshotEvidence = await readWorkspaceSnapshot(context);
+    const rows = await readEvidenceFloorRows(context, snapshotEvidence);
+    const violations = evidenceFloorViolations(rows, options);
+    if (options.freshEvidence === true) {
+        const clean = snapshotEvidence.available && snapshotEvidence.snapshot.dirty === false;
+        if (!clean)
+            violations.unshift({
+                rule: EVIDENCE_FLOOR_RULE,
+                entityId: "proof-snapshot",
+                description: snapshotEvidence.available
+                    ? "--fresh-evidence needs a clean proof snapshot, but the working tree has uncommitted changes"
+                    : `--fresh-evidence needs a proof snapshot, but none is available: ${snapshotEvidence.error}`,
+                suggestion: "Commit or stash working-tree changes (or run inside a Git checkout), run kibi prove, then rerun kibi check --fresh-evidence.",
+            });
+    }
+    return violations;
+}