kibi-cli 1.0.1 → 2.1.0

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

@@ -10,9 +10,9 @@ export declare const checkSpec: {
                 readonly type: "array";
                 readonly items: {
                     readonly type: "string";
-                    readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "source-relationship-parity", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "rule-safety", "rule-verifiability", "semantic-completeness", "query-plan-safety"];
+                    readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. 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, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, 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, proof-contract-symbols. 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";
@@ -42,6 +42,11 @@ export declare const checkSpec: {
                 readonly type: "string";
                 readonly description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.";
             };
+            readonly async: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.";
+            };
         };
     };
     readonly requiresProlog: true;

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

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEY,CAAC"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DY,CAAC"}

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

@@ -1,4 +1,5 @@
 import { executeCheck } from "../check-executor.js";
+import { SELECTABLE_RULES_ALLOWED, SELECTABLE_RULE_NAMES, } from "./check-rules.generated.js";
 export const checkSpec = {
     name: "kb_check",
     cliName: "check",
@@ -10,27 +11,9 @@ export const checkSpec = {
                 type: "array",
                 items: {
                     type: "string",
-                    enum: [
-                        "must-priority-coverage",
-                        "symbol-coverage",
-                        "symbol-traceability",
-                        "no-dangling-refs",
-                        "source-relationship-parity",
-                        "no-cycles",
-                        "required-fields",
-                        "deprecated-adr-no-successor",
-                        "domain-contradictions",
-                        "strict-fact-shape",
-                        "strict-req-fact-pairing",
-                        "predicate-verifiability",
-                        "logic-coverage",
-                        "rule-safety",
-                        "rule-verifiability",
-                        "semantic-completeness",
-                        "query-plan-safety",
-                    ],
+                    enum: [...SELECTABLE_RULE_NAMES],
                 },
-                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, rule-safety, rule-verifiability, semantic-completeness, query-plan-safety. 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.",
+                description: `Optional rule subset. Allowed: ${SELECTABLE_RULES_ALLOWED}. 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.`,
             },
             sourceFiles: {
                 type: "array",
@@ -58,6 +41,11 @@ export const checkSpec = {
                 type: "string",
                 description: "Optional workspace root for impact diagnostics. Defaults to the MCP server workspace.",
             },
+            async: {
+                type: "boolean",
+                default: false,
+                description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.",
+            },
         },
     },
     requiresProlog: true,

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

@@ -40,6 +40,7 @@ export declare const querySpec: {
     };
     readonly requiresProlog: true;
     readonly effects: readonly ["kb-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof executeQuery;
 };
 export declare const searchSpec: {
@@ -161,6 +162,7 @@ export declare const searchSpec: {
     };
     readonly requiresProlog: true;
     readonly effects: readonly ["kb-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof executeSearch;
 };
 export declare const statusSpec: {
@@ -173,6 +175,7 @@ export declare const statusSpec: {
     };
     readonly requiresProlog: false;
     readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof executeStatus;
 };
 //# sourceMappingURL=discovery.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CAUuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6FuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}

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

@@ -48,6 +48,7 @@ export const querySpec = {
     },
     requiresProlog: true,
     effects: ["kb-read"],
+    agentVisibleStructuredData: true,
     execute: executeQuery,
 };
 export const searchSpec = {
@@ -134,6 +135,7 @@ export const searchSpec = {
     },
     requiresProlog: true,
     effects: ["kb-read"],
+    agentVisibleStructuredData: true,
     execute: executeSearch,
 };
 export const statusSpec = {
@@ -144,5 +146,6 @@ export const statusSpec = {
     // Status must remain available when the branch store cannot be attached.
     requiresProlog: false,
     effects: ["kb-read", "workspace-read"],
+    agentVisibleStructuredData: true,
     execute: executeStatus,
 };

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

@@ -107,208 +107,302 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly enum: readonly ["internal", "consumer"];
             readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
         };
-        readonly verification_contract: {
+        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", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+            readonly required: readonly ["version", "integration", "required_proofs", "success_policy"];
             readonly properties: {
                 readonly version: {
                     readonly type: "string";
-                    readonly const: "kibi.verification-contract.v1";
+                    readonly const: "kibi.proof-contract.v1";
                 };
-                readonly runner: {
+                readonly integration: {
                     readonly type: "string";
                     readonly minLength: 1;
                 };
-                readonly command_argv: {
+                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 items: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id", "target"];
+                readonly properties: {
+                    readonly symbol_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                };
-                readonly required_case_symbols: {
-                    readonly type: "array";
-                    readonly items: {
+                    readonly target: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly uniqueItems: true;
-                };
-                readonly required_projects: {
-                    readonly type: "array";
-                    readonly items: {
+                    readonly native_id: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
-                    readonly uniqueItems: true;
-                };
-                readonly success_policy: {
-                    readonly type: "string";
-                    readonly const: "all_required_cases_first_attempt";
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly source_file: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly line: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                    };
                 };
+                readonly additionalProperties: false;
             };
-            readonly additionalProperties: false;
         };
-        readonly verification_receipts: {
+        readonly proof_receipts: {
             readonly type: "array";
             readonly maxItems: 50;
             readonly items: {
-                readonly oneOf: readonly [{
-                    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 properties: {
-                        readonly version: {
-                            readonly type: "string";
-                            readonly const: "kibi.verification-receipt.v1";
-                        };
-                        readonly receipt_id: {
-                            readonly type: "string";
-                            readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                        };
-                        readonly test_id: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly runner: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly command: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly scope: {
-                            readonly type: "string";
-                            readonly enum: readonly ["unit", "integration", "end_to_end"];
-                        };
-                        readonly outcome: {
-                            readonly type: "string";
-                            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
-                        };
-                        readonly code_snapshot: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
-                        readonly environment_hash: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
-                        readonly started_at: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly finished_at: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly artifact_digest: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
+                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 additionalProperties: false;
-                }, {
-                    readonly required: readonly ["version", "receipt_id", "test_id", "runner", "command", "scope", "outcome", "code_snapshot", "environment_hash", "started_at", "finished_at", "artifact_digest", "command_argv", "contract_hash", "case_results"];
-                    readonly properties: {
-                        readonly version: {
-                            readonly type: "string";
-                            readonly const: "kibi.verification-receipt.v2";
+                    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;
+                    };
+                    readonly scope: {
+                        readonly type: "string";
+                        readonly enum: readonly ["unit", "integration", "end_to_end"];
+                    };
+                    readonly outcome: {
+                        readonly type: "string";
+                        readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
+                    };
+                    readonly code_snapshot: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly environment_hash: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly started_at: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly finished_at: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly artifact_digest: {
+                        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 command_argv: {
-                            readonly type: "array";
-                            readonly minItems: 1;
-                            readonly items: {
+                    };
+                    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 contract_hash: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
-                        readonly case_results: {
-                            readonly type: "array";
-                            readonly minItems: 1;
-                            readonly maxItems: 1000;
-                            readonly items: {
-                                readonly type: "object";
-                                readonly required: readonly ["symbol_id", "project", "outcome", "retries", "duration_ms"];
-                                readonly properties: {
-                                    readonly symbol_id: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly project: {
-                                        readonly type: "string";
-                                        readonly minLength: 1;
-                                    };
-                                    readonly outcome: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["passed", "failed", "timed_out", "skipped", "interrupted"];
-                                    };
-                                    readonly retries: {
-                                        readonly type: "integer";
-                                        readonly minimum: 0;
-                                    };
-                                    readonly duration_ms: {
-                                        readonly type: "integer";
-                                        readonly minimum: 0;
-                                    };
-                                };
-                                readonly additionalProperties: false;
+                            readonly version: {
+                                readonly type: "string";
+                                readonly minLength: 1;
                             };
                         };
-                        readonly receipt_id: {
-                            readonly type: "string";
-                            readonly pattern: "^VR-[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$";
-                        };
-                        readonly test_id: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly runner: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly command: {
-                            readonly type: "string";
-                            readonly minLength: 1;
-                        };
-                        readonly scope: {
-                            readonly type: "string";
-                            readonly enum: readonly ["unit", "integration", "end_to_end"];
-                        };
-                        readonly outcome: {
-                            readonly type: "string";
-                            readonly enum: readonly ["passed", "failed", "errored", "cancelled", "skipped", "timed_out", "interrupted"];
-                        };
-                        readonly code_snapshot: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
-                        readonly environment_hash: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
-                        };
-                        readonly started_at: {
+                        readonly additionalProperties: false;
+                    };
+                    readonly command_argv: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
                             readonly type: "string";
                             readonly minLength: 1;
                         };
-                        readonly finished_at: {
-                            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 artifact_digest: {
-                            readonly type: "string";
-                            readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    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 type: "object";
-                    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";
@@ -472,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":"AAKA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiT3B,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"}