kibi-cli 1.0.1 → 2.1.0

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

@@ -99,6 +99,7 @@ export declare const OPERATION_CATALOG: readonly [{
     };
     readonly requiresProlog: true;
     readonly effects: readonly ["kb-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof import("./discovery-executors.js").executeQuery;
 }, {
     readonly name: "kb_search";
@@ -219,6 +220,7 @@ export declare const OPERATION_CATALOG: readonly [{
     };
     readonly requiresProlog: true;
     readonly effects: readonly ["kb-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof import("./discovery-executors.js").executeSearch;
 }, {
     readonly name: "kb_status";
@@ -230,6 +232,7 @@ export declare const OPERATION_CATALOG: readonly [{
     };
     readonly requiresProlog: false;
     readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly agentVisibleStructuredData: true;
     readonly execute: typeof import("./discovery-executors.js").executeStatus;
 }, {
     readonly name: "kb_find_gaps";
@@ -298,6 +301,14 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly type: "boolean";
                 readonly default: false;
             };
+            readonly statuses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["proven", "missing", "unresolved", "not_applicable"];
+                };
+                readonly description: "Requirement proof-status filter (req mode): include only rows whose proofStatus is listed. Selecting statuses implies include-passing; not_applicable rows carry their typed applicability reason in proofStages.applicability.reason. The summary always reflects the whole KB.";
+            };
             readonly includeTransitive: {
                 readonly type: "boolean";
                 readonly default: true;
@@ -858,208 +869,302 @@ export declare const OPERATION_CATALOG: readonly [{
                         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";
@@ -1223,7 +1328,7 @@ export declare const OPERATION_CATALOG: readonly [{
                 };
                 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"];
@@ -1344,9 +1449,9 @@ export declare const OPERATION_CATALOG: readonly [{
                 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";
@@ -1376,6 +1481,11 @@ export declare const OPERATION_CATALOG: readonly [{
                 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;
@@ -1580,6 +1690,15 @@ export declare const OPERATION_CATALOG: readonly [{
                             readonly type: "string";
                             readonly minLength: 1;
                         };
+                        readonly scenarioIds: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly maxItems: 20;
+                            readonly description: "Stable scenario draft IDs verified by this test. Required when multiple scenario drafts are supplied.";
+                        };
                         readonly verificationScope: {
                             readonly type: "string";
                             readonly enum: readonly ["unit", "integration", "end_to_end"];
@@ -1667,34 +1786,56 @@ export declare const OPERATION_CATALOG: readonly [{
     readonly effects: readonly ["kb-read", "kb-write", "workspace-read", "workspace-write"];
     readonly execute: typeof import("./index.js").executeApplyPlan;
 }, {
-    readonly name: "kb_ingest_verification";
-    readonly cliName: "ingest-verification";
-    readonly description: "Ingest a reporter-produced kibi.playwright-run.v1 artifact for a contracted test. Revalidates the live workspace snapshot, runner/command contract, required case/project coverage, and append-only receipt history before deriving and appending a kibi.verification-receipt.v2. It never accepts a caller-authored receipt or trusted outcome.";
+    readonly name: "kb_ingest_proof";
+    readonly cliName: "ingest-proof";
+    readonly description: "Ingest a producer-emitted kibi.proof-run.v1 artifact and evaluate it against each selected test's kibi.proof-contract.v1 proof obligations. Revalidates the live workspace snapshot, integration command binding, run-level outcome, attempt history, success policy, and append-only proof-receipt history before deriving and appending idempotent kibi.proof-receipt.v1 receipts. Producers report what happened; Kibi evaluates proof. Prefer `kibi prove` so the configured producer runs automatically; direct ingestion is an integration path for custom producers and agents.";
     readonly businessInputSchema: {
         readonly type: "object";
-        readonly required: readonly ["testId", "snapshot", "artifact"];
+        readonly required: readonly ["snapshot", "artifact"];
         readonly properties: {
-            readonly testId: {
-                readonly type: "string";
-                readonly minLength: 1;
-                readonly description: "Existing test entity with verification_contract.v1.";
-            };
             readonly snapshot: {
                 readonly type: "string";
                 readonly pattern: "^[a-f0-9]{64}$";
-                readonly description: "Workspace verification snapshot captured immediately before the run.";
+                readonly description: "Workspace snapshot captured immediately before the run.";
             };
             readonly artifact: {
                 readonly type: "object";
-                readonly required: readonly ["version", "runner", "command_argv", "code_snapshot", "environment_hash", "started_at", "finished_at", "process_exit_code", "cases"];
+                readonly description: "Producer-emitted kibi.proof-run.v1 proof artifact. Producers report what happened; Kibi evaluates proof obligations and policies. Produce it via `kibi prove` or direct kb_ingest_proof calls.";
+                readonly required: readonly ["version", "producer", "command_argv", "code_snapshot", "environment", "run", "proof_results"];
                 readonly properties: {
                     readonly version: {
                         readonly type: "string";
-                        readonly const: "kibi.playwright-run.v1";
+                        readonly const: "kibi.proof-run.v1";
                     };
-                    readonly runner: {
-                        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 executor: {
+                        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";
@@ -1708,39 +1849,152 @@ export declare const OPERATION_CATALOG: readonly [{
                         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 environment: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
                     };
-                    readonly process_exit_code: {
-                        readonly type: "integer";
+                    readonly run: {
+                        readonly type: "object";
+                        readonly required: readonly ["outcome", "exit_code", "started_at", "finished_at"];
+                        readonly properties: {
+                            readonly outcome: {
+                                readonly type: "string";
+                                readonly enum: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
+                            };
+                            readonly exit_code: {
+                                readonly type: "integer";
+                            };
+                            readonly started_at: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly finished_at: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly failure_phase: {
+                                readonly type: "string";
+                                readonly enum: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
+                            };
+                        };
+                        readonly additionalProperties: false;
                     };
-                    readonly cases: {
+                    readonly proof_results: {
                         readonly type: "array";
                         readonly minItems: 1;
                         readonly maxItems: 1000;
                         readonly items: {
                             readonly type: "object";
+                            readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
+                            readonly required: readonly ["symbol_id", "target", "outcome", "binding", "attempts"];
+                            readonly properties: {
+                                readonly symbol_id: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Stable proof symbol ID (SYM-*).";
+                                };
+                                readonly target: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Ecosystem-neutral execution target (browser, runtime, database, device, deployment, or default).";
+                                };
+                                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 maxItems: 100;
+                                                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 diagnostics: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                };
+                            };
+                            readonly additionalProperties: false;
                         };
                     };
+                    readonly integration: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly diagnostics: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly testIds: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
                 };
-                readonly additionalProperties: true;
+                readonly description: "Existing test entities with proof_contract.v1. Omit to evaluate every test contracted to the artifact's integration.";
             };
         };
     };
     readonly requiresProlog: true;
     readonly effects: readonly ["kb-read", "kb-write", "workspace-read"];
-    readonly execute: typeof import("./index.js").executeIngestVerification;
+    readonly execute: typeof import("./index.js").executeIngestProof;
 }];
 export declare function withContractDefaults(spec: OperationSpec): ResolvedOperationSpec;
+export declare function requireKnownSpec(spec: ResolvedOperationSpec | undefined, name: OperationName): ResolvedOperationSpec;
 export declare function getSpec(name: OperationName): ResolvedOperationSpec;
 export declare function listSpecs(): readonly ResolvedOperationSpec[];
 //# sourceMappingURL=catalog.d.ts.map