kibi-cli 0.19.0 → 2.0.0

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -89,7 +89,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
         };
         readonly granularity_reason: {
             readonly type: "string";
-            readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+            readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link", "test-suite"];
             readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
         };
         readonly symbol_role: {
@@ -107,30 +107,101 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly enum: readonly ["internal", "consumer"];
             readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
         };
-        readonly verification_receipts: {
+        readonly proof_contract: {
+            readonly description: "Semantic proof contract binding this test to explicit proof obligations executed by one configured integration.";
+            readonly type: "object";
+            readonly required: readonly ["version", "integration", "required_proofs", "success_policy"];
+            readonly properties: {
+                readonly version: {
+                    readonly type: "string";
+                    readonly const: "kibi.proof-contract.v1";
+                };
+                readonly integration: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly required_proofs: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly maxItems: 1000;
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["symbol_id", "target"];
+                        readonly properties: {
+                            readonly symbol_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly target: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+                readonly success_policy: {
+                    readonly type: "string";
+                    readonly enum: readonly ["all_required_first_attempt"];
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly proof_bindings: {
+            readonly description: "Optional native-runner bindings (native ids, aliases, source coordinates) for proof obligations. Bindings are provenance metadata and never replace the semantic contract.";
             readonly type: "array";
-            readonly maxItems: 50;
             readonly items: {
                 readonly type: "object";
-                readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest"];
+                readonly required: readonly ["symbol_id", "target"];
                 readonly properties: {
-                    readonly version: {
+                    readonly symbol_id: {
                         readonly type: "string";
-                        readonly const: "kibi.verification-receipt.v1";
+                        readonly minLength: 1;
                     };
-                    readonly receipt_id: {
+                    readonly target: {
                         readonly type: "string";
-                        readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                        readonly minLength: 1;
                     };
-                    readonly test_id: {
+                    readonly native_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly runner: {
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly source_file: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly command: {
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly proof_receipts: {
+            readonly type: "array";
+            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 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 receipt_id: {
+                        readonly type: "string";
+                        readonly pattern: "^PR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
+                    };
+                    readonly test_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
@@ -140,7 +211,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                     };
                     readonly outcome: {
                         readonly type: "string";
-                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped"];
+                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
                     };
                     readonly code_snapshot: {
                         readonly type: "string";
@@ -162,10 +233,176 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                         readonly type: "string";
                         readonly pattern: "^[a-f0-9]{64}$";
                     };
+                    readonly contract_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly binding_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly fingerprint: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly fingerprint_components: {
+                        readonly type: "object";
+                        readonly required: readonly ["contract", "integration", "command", "bindings", "producer"];
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly contract: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly integration: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly command: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly bindings: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                            readonly producer: {
+                                readonly type: "string";
+                                readonly pattern: "^[a-f0-9]{64}$";
+                            };
+                        };
+                    };
+                    readonly integration_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly producer: {
+                        readonly type: "object";
+                        readonly required: readonly ["name"];
+                        readonly properties: {
+                            readonly name: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly version: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly command_argv: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly run_outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                    };
+                    readonly proof_results: {
+                        readonly type: "array";
+                        readonly minItems: 0;
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly outcome: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                };
+                                readonly binding: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["native_case", "aggregate_run"];
+                                };
+                                readonly native_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly attempts: {
+                                    readonly oneOf: readonly [{
+                                        readonly type: "object";
+                                        readonly required: readonly ["status", "entries"];
+                                        readonly properties: {
+                                            readonly status: {
+                                                readonly type: "string";
+                                                readonly const: "complete";
+                                            };
+                                            readonly entries: {
+                                                readonly type: "array";
+                                                readonly minItems: 1;
+                                                readonly items: {
+                                                    readonly type: "object";
+                                                    readonly required: readonly ["outcome"];
+                                                    readonly properties: {
+                                                        readonly outcome: {
+                                                            readonly type: "string";
+                                                            readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
+                                                        };
+                                                        readonly duration_ms: {
+                                                            readonly type: "number";
+                                                            readonly minimum: 0;
+                                                        };
+                                                    };
+                                                    readonly additionalProperties: false;
+                                                };
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }, {
+                                        readonly type: "object";
+                                        readonly required: readonly ["status"];
+                                        readonly properties: {
+                                            readonly status: {
+                                                readonly type: "string";
+                                                readonly const: "unavailable";
+                                            };
+                                        };
+                                        readonly additionalProperties: false;
+                                    }];
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly gaps: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["symbol_id", "target", "reason"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly reason: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
                 };
                 readonly additionalProperties: false;
             };
-            readonly description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.";
+            readonly description: "Append-only proof evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot, current contract hash, and effective execution fingerprint within the seven-day freshness window. Ingest rotates the oldest entries at the cap.";
         };
         readonly fact_kind: {
             readonly type: "string";
@@ -329,7 +566,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
     };
     readonly allOf: readonly [Record<string, unknown>, {
         readonly if: {
-            readonly required: readonly ["verification_receipts"];
+            readonly required: readonly ["proof_receipts"];
         };
         readonly then: {
             readonly required: readonly ["verification_scope"];

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+S3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0T3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC"}

package/dist/public/operations/specs/mutation-schemas.js

@@ -1,4 +1,5 @@
-import { VERIFICATION_RECEIPT_SCHEMA } from "../../verification-receipt.js";
+import { PROOF_BINDINGS_SCHEMA, PROOF_CONTRACT_SCHEMA, } from "../../proof-protocol.js";
+import { MAX_PROOF_RECEIPTS, PROOF_RECEIPT_SCHEMA, } from "../../proof-receipt.js";
 export const ENTITY_TYPES = [
     "req",
     "scenario",
@@ -103,6 +104,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
                 "module-level-behavior",
                 "extractor-miss",
                 "legacy-link",
+                "test-suite",
             ],
             description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.",
         },
@@ -128,11 +130,19 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             enum: ["internal", "consumer"],
             description: "Optional typed verification perspective for test entities. Example: 'consumer'.",
         },
-        verification_receipts: {
+        proof_contract: {
+            ...PROOF_CONTRACT_SCHEMA,
+            description: "Semantic proof contract binding this test to explicit proof obligations executed by one configured integration.",
+        },
+        proof_bindings: {
+            ...PROOF_BINDINGS_SCHEMA,
+            description: "Optional native-runner bindings (native ids, aliases, source coordinates) for proof obligations. Bindings are provenance metadata and never replace the semantic contract.",
+        },
+        proof_receipts: {
             type: "array",
-            maxItems: 50,
-            items: VERIFICATION_RECEIPT_SCHEMA,
-            description: "Append-only test execution evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot and within the seven-day freshness window.",
+            maxItems: MAX_PROOF_RECEIPTS,
+            items: PROOF_RECEIPT_SCHEMA,
+            description: "Append-only proof evidence. Proof accepts only the newest valid passed receipt bound to the current code snapshot, current contract hash, and effective execution fingerprint within the seven-day freshness window. Ingest rotates the oldest entries at the cap.",
         },
         fact_kind: {
             type: "string",
@@ -283,7 +293,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
     allOf: [
         CLAIM_PROVENANCE_CONDITIONAL,
         {
-            if: { required: ["verification_receipts"] },
+            if: { required: ["proof_receipts"] },
             // biome-ignore lint/suspicious/noThenProperty: JSON Schema conditional keyword.
             then: { required: ["verification_scope"] },
         },

package/dist/public/operations/specs/mutation.d.ts

@@ -38,14 +38,54 @@ export declare const deleteSpec: {
     readonly description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.";
     readonly businessInputSchema: {
         readonly type: "object";
-        readonly required: readonly ["ids"];
+        readonly oneOf: readonly [{
+            readonly required: readonly ["ids"];
+            readonly not: {
+                readonly required: readonly ["relationships"];
+            };
+        }, {
+            readonly required: readonly ["relationships"];
+            readonly not: {
+                readonly required: readonly ["ids"];
+            };
+        }];
         readonly properties: {
             readonly ids: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
                 };
-                readonly description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.";
+                readonly minItems: 1;
+                readonly description: "Entity IDs to delete after dependency checks.";
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "from", "to"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly from: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly to: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Exact relationship triples to retract, including legacy shard records.";
+            };
+            readonly approvedPlanHash: {
+                readonly type: "string";
+                readonly pattern: "^[a-fA-F0-9]{64}$";
+                readonly description: "Exact hash returned by a prior authored-entity deletion plan.";
             };
         };
     };

package/dist/public/operations/specs/mutation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAOvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAIxF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;CAoBuC,CAAC"}
+{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAOvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAIxF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CuC,CAAC"}

package/dist/public/operations/specs/mutation.js

@@ -29,12 +29,36 @@ export const deleteSpec = {
     description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.",
     businessInputSchema: {
         type: "object",
-        required: ["ids"],
+        oneOf: [
+            { required: ["ids"], not: { required: ["relationships"] } },
+            { required: ["relationships"], not: { required: ["ids"] } },
+        ],
         properties: {
             ids: {
                 type: "array",
                 items: { type: "string" },
-                description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.",
+                minItems: 1,
+                description: "Entity IDs to delete after dependency checks.",
+            },
+            relationships: {
+                type: "array",
+                minItems: 1,
+                items: {
+                    type: "object",
+                    required: ["type", "from", "to"],
+                    additionalProperties: false,
+                    properties: {
+                        type: { type: "string", minLength: 1 },
+                        from: { type: "string", minLength: 1 },
+                        to: { type: "string", minLength: 1 },
+                    },
+                },
+                description: "Exact relationship triples to retract, including legacy shard records.",
+            },
+            approvedPlanHash: {
+                type: "string",
+                pattern: "^[a-fA-F0-9]{64}$",
+                description: "Exact hash returned by a prior authored-entity deletion plan.",
             },
         },
     },