kibi-cli 2.31.0 → 2.32.0

package/dist/public/proof-protocol.d.ts

@@ -1,14 +1,43 @@
 export declare const PROOF_RUN_VERSION: "kibi.proof-run.v1";
 export declare const PROOF_CONTRACT_VERSION: "kibi.proof-contract.v1";
-export declare const PROOF_RECEIPT_VERSION: "kibi.proof-receipt.v1";
+/**
+ * Receipts Kibi writes. v2 adds the contract's kind, the evidence level the
+ * receipt supports, and for certificate kinds the re-checked certificate.
+ */
+export declare const PROOF_RECEIPT_VERSION: "kibi.proof-receipt.v2";
+/** Receipts written before v2; still read, as e2e evidence at tested. */
+export declare const PROOF_RECEIPT_V1_VERSION: "kibi.proof-receipt.v1";
+export declare const PROOF_RECEIPT_VERSIONS: readonly ["kibi.proof-receipt.v1", "kibi.proof-receipt.v2"];
+/** The certificate a certificate-kind proof leaves for Kibi to re-check. */
+export declare const CODE_CERTIFICATE_VERSION: "kibi.code-certificate.v1";
 export declare const PROOF_INTEGRATION_VERSION: "kibi.proof-integration.v1";
 export declare const PROOF_RUN_OUTCOMES: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
 export declare const PROOF_RESULT_OUTCOMES: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
 export declare const PROOF_BINDING_KINDS: readonly ["native_case", "aggregate_run"];
 export declare const ATTEMPTS_STATUS: readonly ["complete", "unavailable"];
 export declare const RUN_FAILURE_PHASES: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
-export declare const SUCCESS_POLICIES: readonly ["all_required_first_attempt"];
+/**
+ * `all_required_first_attempt`: the whole run must pass and every obligation's
+ * own result must pass on its first attempt.
+ * `own_results_first_attempt`: a run whose only failures are other test cases
+ * (outcome `failed` in the execution phase) still proves an obligation whose
+ * own native-case result passed on its first attempt, so one unrelated
+ * failing case does not erase a suite's evidence. Aggregate-run obligations
+ * still need the whole run to pass.
+ */
+export declare const SUCCESS_POLICIES: readonly ["all_required_first_attempt", "own_results_first_attempt"];
+/**
+ * What a proof contract's checker establishes. Runner kinds (e2e, example,
+ * property) sample cases and support tested evidence; certificate kinds
+ * (exhaustive, typecheck, arithmetic, smt) cover every case and support
+ * proved evidence once Kibi re-checks the certificate the run left.
+ */
+export declare const PROOF_KINDS: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt"];
+export declare const CERTIFICATE_PROOF_KINDS: readonly ["exhaustive", "typecheck", "arithmetic", "smt"];
+export type ProofKind = (typeof PROOF_KINDS)[number];
+export declare function isCertificateProofKind(kind: unknown): boolean;
 export type { AttemptsStatus, ProducerProvenance, ProofAttempt, ProofAttempts, ProofBinding, ProofBindingKind, ProofContract, ProofEnvironment, ProofObligation, ProofResult, ProofResultOutcome, ProofRun, ProofRunArtifact, ProofRunOutcome, RunFailurePhase, SuccessPolicy, } from "./proof-protocol-types.js";
+import type { ProofContract } from "./proof-protocol-types.js";
 export declare const PROOF_RESULT_SCHEMA: {
     readonly type: "object";
     readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
@@ -266,6 +295,15 @@ export declare const PROOF_RUN_ARTIFACT_SCHEMA: {
                 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;
 };
@@ -304,7 +342,87 @@ export declare const PROOF_CONTRACT_SCHEMA: {
         };
         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;
@@ -350,5 +468,10 @@ export declare const PROOF_BINDINGS_SCHEMA: {
 export declare function proofResultErrors(value: unknown, label: string): string[];
 export declare function proofRunArtifactErrors(value: unknown): string[];
 export declare function proofContractErrors(value: unknown): string[];
+/**
+ * The optional contract fields beyond the v1 core, copied only when present
+ * so existing contracts keep their hash.
+ */
+export declare function optionalProofContractFields(contract: Record<string, unknown>): Pick<ProofContract, "kind" | "domain_source" | "witness" | "constraint_source" | "value_source" | "proves">;
 export declare function proofBindingsErrors(value: unknown): string[];
 //# sourceMappingURL=proof-protocol.d.ts.map

package/dist/public/proof-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proof-protocol.d.ts","sourceRoot":"","sources":["../../src/public/proof-protocol.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAE9D,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AAExE,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAC;AAEtE,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,iGAQrB,CAAC;AAEX,eAAO,MAAM,qBAAqB,iFAOxB,CAAC;AAEX,eAAO,MAAM,mBAAmB,2CAA4C,CAAC;AAE7E,eAAO,MAAM,eAAe,sCAAuC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,6EAMrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,yCAA0C,CAAC;AAExE,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,2BAA2B,CAAC;AAWnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DtB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE5B,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AA0GX,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAkG/D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAwD5D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA8C5D"}
+{"version":3,"file":"proof-protocol.d.ts","sourceRoot":"","sources":["../../src/public/proof-protocol.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAE9D,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AACxE;;;GAGG;AAEH,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAC;AACtE,yEAAyE;AAEzE,eAAO,MAAM,wBAAwB,EAAG,uBAAgC,CAAC;AAEzE,eAAO,MAAM,sBAAsB,6DAGzB,CAAC;AACX,4EAA4E;AAE5E,eAAO,MAAM,wBAAwB,EAAG,0BAAmC,CAAC;AAE5E,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,iGAQrB,CAAC;AAEX,eAAO,MAAM,qBAAqB,iFAOxB,CAAC;AAEX,eAAO,MAAM,mBAAmB,2CAA4C,CAAC;AAE7E,eAAO,MAAM,eAAe,sCAAuC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,6EAMrB,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,sEAGnB,CAAC;AAEX;;;;;GAKG;AAEH,eAAO,MAAM,WAAW,yFAQd,CAAC;AAGX,eAAO,MAAM,uBAAuB,2DAK1B,CAAC;AAGX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAGrD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAIV,aAAa,EAGd,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DtB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwE5B,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AA0GX,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoH/D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAyD5D;AAwGD;;;GAGG;AAEH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CACL,aAAa,EACX,MAAM,GACN,eAAe,GACf,SAAS,GACT,mBAAmB,GACnB,cAAc,GACd,QAAQ,CACX,CA2CA;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA8C5D"}

package/dist/public/proof-protocol.js

@@ -2,8 +2,23 @@
 export const PROOF_RUN_VERSION = "kibi.proof-run.v1";
 // implements REQ-kibi-verification-evidence-contract
 export const PROOF_CONTRACT_VERSION = "kibi.proof-contract.v1";
-// implements REQ-kibi-verification-evidence-contract
-export const PROOF_RECEIPT_VERSION = "kibi.proof-receipt.v1";
+/**
+ * Receipts Kibi writes. v2 adds the contract's kind, the evidence level the
+ * receipt supports, and for certificate kinds the re-checked certificate.
+ */
+// implements REQ-kibi-verification-evidence-contract, REQ-kibi-code-proof-kinds
+export const PROOF_RECEIPT_VERSION = "kibi.proof-receipt.v2";
+/** Receipts written before v2; still read, as e2e evidence at tested. */
+// implements REQ-kibi-code-proof-kinds
+export const PROOF_RECEIPT_V1_VERSION = "kibi.proof-receipt.v1";
+// implements REQ-kibi-code-proof-kinds
+export const PROOF_RECEIPT_VERSIONS = [
+    PROOF_RECEIPT_V1_VERSION,
+    PROOF_RECEIPT_VERSION,
+];
+/** The certificate a certificate-kind proof leaves for Kibi to re-check. */
+// implements REQ-kibi-code-proof-kinds
+export const CODE_CERTIFICATE_VERSION = "kibi.code-certificate.v1";
 // implements REQ-kibi-verification-evidence-contract
 export const PROOF_INTEGRATION_VERSION = "kibi.proof-integration.v1";
 export const PROOF_RUN_OUTCOMES = [
@@ -32,7 +47,46 @@ export const RUN_FAILURE_PHASES = [
     "teardown",
     "infrastructure",
 ];
-export const SUCCESS_POLICIES = ["all_required_first_attempt"];
+/**
+ * `all_required_first_attempt`: the whole run must pass and every obligation's
+ * own result must pass on its first attempt.
+ * `own_results_first_attempt`: a run whose only failures are other test cases
+ * (outcome `failed` in the execution phase) still proves an obligation whose
+ * own native-case result passed on its first attempt, so one unrelated
+ * failing case does not erase a suite's evidence. Aggregate-run obligations
+ * still need the whole run to pass.
+ */
+export const SUCCESS_POLICIES = [
+    "all_required_first_attempt",
+    "own_results_first_attempt",
+];
+/**
+ * What a proof contract's checker establishes. Runner kinds (e2e, example,
+ * property) sample cases and support tested evidence; certificate kinds
+ * (exhaustive, typecheck, arithmetic, smt) cover every case and support
+ * proved evidence once Kibi re-checks the certificate the run left.
+ */
+// implements REQ-kibi-code-proof-kinds
+export const PROOF_KINDS = [
+    "e2e",
+    "example",
+    "property",
+    "exhaustive",
+    "typecheck",
+    "arithmetic",
+    "smt",
+];
+// implements REQ-kibi-code-proof-kinds
+export const CERTIFICATE_PROOF_KINDS = [
+    "exhaustive",
+    "typecheck",
+    "arithmetic",
+    "smt",
+];
+// implements REQ-kibi-code-proof-kinds
+export function isCertificateProofKind(kind) {
+    return CERTIFICATE_PROOF_KINDS.includes(kind);
+}
 export const PROOF_RESULT_SCHEMA = {
     type: "object",
     description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.",
@@ -152,6 +206,12 @@ export const PROOF_RUN_ARTIFACT_SCHEMA = {
             type: "array",
             items: { type: "string", minLength: 1 },
         },
+        certificates: {
+            type: "array",
+            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.",
+            maxItems: 1000,
+            items: { type: "object", required: ["version", "kind", "test_id"] },
+        },
     },
     additionalProperties: false,
 };
@@ -177,6 +237,66 @@ export const PROOF_CONTRACT_SCHEMA = {
             },
         },
         success_policy: { type: "string", enum: [...SUCCESS_POLICIES] },
+        kind: {
+            type: "string",
+            enum: [...PROOF_KINDS],
+            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.",
+        },
+        domain_source: {
+            type: "object",
+            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.",
+            required: ["symbol_id"],
+            properties: {
+                symbol_id: { type: "string", minLength: 1 },
+                export: {
+                    type: "string",
+                    minLength: 1,
+                    description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.",
+                },
+            },
+            additionalProperties: false,
+        },
+        witness: {
+            type: "object",
+            description: "typecheck: the repository-relative witness file Kibi compiles (an exhaustive switch ending in never, or a mapped type over the domain).",
+            required: ["path"],
+            properties: { path: { type: "string", minLength: 1 } },
+            additionalProperties: false,
+        },
+        proves: {
+            type: "array",
+            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.",
+            minItems: 1,
+            items: { type: "string", pattern: "^CLAIM-" },
+            uniqueItems: true,
+        },
+        value_source: {
+            type: "array",
+            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.",
+            minItems: 1,
+            items: {
+                type: "object",
+                required: ["symbol_id"],
+                properties: {
+                    symbol_id: { type: "string", minLength: 1 },
+                    export: { type: "string", minLength: 1 },
+                },
+                additionalProperties: false,
+            },
+        },
+        constraint_source: {
+            type: "object",
+            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.",
+            required: ["fact_ids"],
+            properties: {
+                fact_ids: {
+                    type: "array",
+                    minItems: 1,
+                    items: { type: "string", minLength: 1 },
+                },
+            },
+            additionalProperties: false,
+        },
     },
     additionalProperties: false,
 };
@@ -371,6 +491,20 @@ export function proofRunArtifactErrors(value) {
             !artifact.diagnostics.every((entry) => nonEmptyString(entry)))
             errors.push("artifact.diagnostics must be an array of non-empty strings");
     }
+    if (artifact.certificates !== undefined) {
+        if (!Array.isArray(artifact.certificates))
+            errors.push("artifact.certificates must be an array when present");
+        else
+            artifact.certificates.forEach((entry, index) => {
+                const row = record(entry);
+                if (!row ||
+                    !nonEmptyString(row.version) ||
+                    !includes(CERTIFICATE_PROOF_KINDS, row.kind) ||
+                    !nonEmptyString(row.test_id) ||
+                    !isPlainJson(row))
+                    errors.push(`artifact.certificates[${index}] must be a JSON object with version, a certificate kind (${CERTIFICATE_PROOF_KINDS.join(", ")}) and test_id`);
+            });
+    }
     return errors;
 }
 export function proofContractErrors(value) {
@@ -413,8 +547,110 @@ export function proofContractErrors(value) {
     }
     if (!includes(SUCCESS_POLICIES, contract.success_policy))
         errors.push(`proof_contract.success_policy must be one of: ${SUCCESS_POLICIES.join(", ")}; received ${JSON.stringify(contract.success_policy ?? null)}`);
+    errors.push(...proofContractKindErrors(contract));
+    return errors;
+}
+// implements REQ-kibi-code-proof-kinds
+function proofContractKindErrors(contract) {
+    const errors = [];
+    const kind = contract.kind;
+    if (kind !== undefined && !includes(PROOF_KINDS, kind))
+        errors.push(`proof_contract.kind must be one of: ${PROOF_KINDS.join(", ")}; received ${JSON.stringify(kind)}`);
+    const domain = contract.domain_source;
+    if (domain !== undefined) {
+        const row = record(domain);
+        if (!row ||
+            !nonEmptyString(row.symbol_id) ||
+            (row.export !== undefined && !nonEmptyString(row.export)) ||
+            Object.keys(row).some((key) => key !== "symbol_id" && key !== "export"))
+            errors.push("proof_contract.domain_source must be {symbol_id, export?} naming the symbol that defines the domain and, when its title is not the export name, the export to read");
+    }
+    else if (kind === "exhaustive" || kind === "typecheck")
+        errors.push(`proof_contract.domain_source is required for kind ${String(kind)}: name the symbol the proof reads its domain from`);
+    const witness = contract.witness;
+    if (witness !== undefined) {
+        const row = record(witness);
+        if (!row || !nonEmptyString(row.path) || Object.keys(row).length !== 1)
+            errors.push("proof_contract.witness must be {path} naming the repository-relative witness file");
+    }
+    else if (kind === "typecheck")
+        errors.push("proof_contract.witness is required for kind typecheck: name the file the type checker compiles");
+    const source = contract.constraint_source;
+    if (source !== undefined) {
+        const row = record(source);
+        const ids = row?.fact_ids;
+        if (!row ||
+            Object.keys(row).length !== 1 ||
+            !Array.isArray(ids) ||
+            ids.length === 0 ||
+            !ids.every(nonEmptyString))
+            errors.push("proof_contract.constraint_source must be {fact_ids: [FACT-...]} naming the facts the assumptions come from");
+    }
+    else if ((kind === "arithmetic" || kind === "smt") &&
+        contract.value_source === undefined)
+        errors.push(`proof_contract.constraint_source or value_source is required for kind ${String(kind)}: name the typed facts or code constants its assumptions come from`);
+    const valueSource = contract.value_source;
+    if (valueSource !== undefined) {
+        if (!Array.isArray(valueSource) ||
+            valueSource.length === 0 ||
+            !valueSource.every((entry) => {
+                const row = record(entry);
+                return (row !== null &&
+                    nonEmptyString(row.symbol_id) &&
+                    (row.export === undefined || nonEmptyString(row.export)) &&
+                    Object.keys(row).every((key) => key === "symbol_id" || key === "export"));
+            }))
+            errors.push("proof_contract.value_source must be [{symbol_id, export?}] naming the code constants the assumptions read");
+        else if (kind !== "arithmetic" && kind !== "smt")
+            errors.push(`proof_contract.value_source applies only to kind arithmetic or smt, not ${String(kind ?? "e2e")}`);
+    }
+    const proves = contract.proves;
+    if (proves !== undefined) {
+        if (!Array.isArray(proves) ||
+            proves.length === 0 ||
+            !proves.every((key) => typeof key === "string" && /^CLAIM-[A-Za-z0-9]+$/.test(key)) ||
+            new Set(proves).size !== proves.length)
+            errors.push("proof_contract.proves must be a non-empty list of distinct claim keys (CLAIM-...) the certificate proves");
+        else if (!isCertificateProofKind(kind))
+            errors.push(`proof_contract.proves applies only to certificate kinds (exhaustive, typecheck, arithmetic, smt), not ${String(kind ?? "e2e")}`);
+    }
     return errors;
 }
+/**
+ * The optional contract fields beyond the v1 core, copied only when present
+ * so existing contracts keep their hash.
+ */
+// implements REQ-kibi-code-proof-kinds
+export function optionalProofContractFields(contract) {
+    const fields = {};
+    if (typeof contract.kind === "string")
+        fields.kind = contract.kind;
+    const domain = record(contract.domain_source);
+    if (domain && typeof domain.symbol_id === "string")
+        fields.domain_source = {
+            symbol_id: domain.symbol_id,
+            ...(typeof domain.export === "string" ? { export: domain.export } : {}),
+        };
+    const witness = record(contract.witness);
+    if (witness && typeof witness.path === "string")
+        fields.witness = { path: witness.path };
+    const source = record(contract.constraint_source);
+    if (source && Array.isArray(source.fact_ids))
+        fields.constraint_source = {
+            fact_ids: source.fact_ids.filter((id) => typeof id === "string"),
+        };
+    if (Array.isArray(contract.value_source))
+        fields.value_source = contract.value_source
+            .map((entry) => record(entry))
+            .filter((row) => row !== null && typeof row.symbol_id === "string")
+            .map((row) => ({
+            symbol_id: String(row.symbol_id),
+            ...(typeof row.export === "string" ? { export: row.export } : {}),
+        }));
+    if (Array.isArray(contract.proves))
+        fields.proves = contract.proves.filter((key) => typeof key === "string");
+    return fields;
+}
 export function proofBindingsErrors(value) {
     if (!Array.isArray(value))
         return ["proof_bindings must be an array of binding objects"];

package/dist/public/proof-receipt.d.ts

@@ -1,15 +1,22 @@
 import { type ProofFingerprintComponents } from "./proof-fingerprint.js";
-import { PROOF_RECEIPT_VERSION, PROOF_RESULT_OUTCOMES, PROOF_RUN_OUTCOMES, type ProofContract } from "./proof-protocol.js";
+import { PROOF_RECEIPT_VERSIONS, PROOF_RESULT_OUTCOMES, PROOF_RUN_OUTCOMES, type ProofContract, type ProofKind } from "./proof-protocol.js";
 export declare const PROOF_RECEIPT_MAX_AGE_SECONDS: number;
+/**
+ * How a certificate binds to a claim its contract names in proves: derived
+ * (Kibi checked it against the claim's fact; the only verdict that proves),
+ * attested (the fact has no derivation; the author vouches) or rejected.
+ */
+export declare const CLAIM_BINDING_VERDICTS: readonly ["derived", "attested", "rejected"];
+export type ClaimBindingVerdict = (typeof CLAIM_BINDING_VERDICTS)[number];
 export declare const PROOF_RECEIPT_OUTCOMES: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
 export declare const PROOF_RECEIPT_SCHEMA: {
     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";
@@ -191,6 +198,63 @@ export declare const PROOF_RECEIPT_SCHEMA: {
                 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: {
@@ -217,7 +281,7 @@ export declare const PROOF_RECEIPT_SCHEMA: {
     readonly additionalProperties: false;
 };
 export type ProofReceipt = Readonly<{
-    version: typeof PROOF_RECEIPT_VERSION;
+    version: (typeof PROOF_RECEIPT_VERSIONS)[number];
     receipt_id: string;
     test_id: string;
     scope: "unit" | "integration" | "end_to_end";
@@ -259,13 +323,32 @@ export type ProofReceipt = Readonly<{
         readonly target: string;
         readonly reason: string;
     }[];
+    /** v2: what the contract's checker establishes. */
+    kind?: ProofKind;
+    /** v2: proved only for a passed certificate kind whose certificate re-checked. */
+    evidence_level?: "proved" | "tested";
+    certificate?: Readonly<Record<string, unknown>>;
+    certificate_digest?: string;
+    certificate_rejection?: string;
+    /** Certificate kinds: the binding to each claim the contract names in proves. */
+    claim_bindings?: readonly ClaimBinding[];
+}>;
+/** How one certificate binds to one requirement claim, judged at ingest. */
+export type ClaimBinding = Readonly<{
+    claim_key: string;
+    requirement_id?: string;
+    fact_id?: string;
+    binding: ClaimBindingVerdict;
+    scope?: "code" | "intent";
+    obligation?: Readonly<Record<string, unknown>>;
+    reason?: string;
 }>;
 export declare function finishedAtPrecedesStartedAt(startedAt: number | null, finishedAt: number | null): boolean;
-/** Structural validation of one kibi.proof-receipt.v1 entry. */
+/** Structural validation of one kibi.proof-receipt.v1 or v2 entry. */
 export declare function validProofReceiptShape(testId: string, receipt: unknown): boolean;
 /**
  * Full-history validation for proof_receipts: unique ids, per-test binding,
- * supported scope, ordered timestamps, and structurally valid v1 entries.
+ * supported scope, ordered timestamps, and structurally valid v1 or v2 entries.
  */
 export declare function proofReceiptHistoryErrors(testId: string, verificationScope: unknown, receipts: readonly Readonly<Record<string, unknown>>[]): readonly string[];
 /** The current receipt must match the live scope, contract hash, and fingerprint. */

package/dist/public/proof-receipt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proof-receipt.d.ts","sourceRoot":"","sources":["../../src/public/proof-receipt.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"proof-receipt.d.ts","sourceRoot":"","sources":["../../src/public/proof-receipt.ts"],"names":[],"mappings":"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"}