kibi-cli 0.19.0 → 2.0.0

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

@@ -1,4 +1,4 @@
-import type { OperationName, OperationSpec } from "./types.js";
+import type { OperationName, OperationSpec, ResolvedOperationSpec } from "./types.js";
 export declare const OPERATION_CATALOG: readonly [{
     readonly name: "kb_skills_list";
     readonly cliName: "skills list";
@@ -103,7 +103,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_search";
     readonly cliName: "search";
-    readonly description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
+    readonly description: "Search KB entities for discovery using legacy lexical ranking or deterministic intent-v1 ranking. Intent mode accepts host-agent semantic facets and source locations, returns evidence and abstains below its confidence threshold. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -131,6 +131,90 @@ export declare const OPERATION_CATALOG: readonly [{
                 readonly default: 0;
                 readonly description: "Optional zero-based pagination offset. Default: 0.";
             };
+            readonly rankingMode: {
+                readonly type: "string";
+                readonly enum: readonly ["legacy", "intent-v1"];
+                readonly default: "legacy";
+                readonly description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.";
+            };
+            readonly semanticFacets: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly actors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly objects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                };
+                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.";
+            };
+            readonly sourceLocations: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "Workspace-relative source path.";
+                        };
+                        readonly line: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly column: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Optional changed-code locations. Results are matched to source-linked symbols/entities and include source evidence.";
+            };
+            readonly minScore: {
+                readonly type: "number";
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly default: 0.18;
+                readonly description: "Intent-v1 acceptance threshold between 0 and 1. Low-confidence queries abstain instead of returning misleading matches.";
+            };
         };
     };
     readonly requiresProlog: true;
@@ -139,12 +223,12 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_status";
     readonly cliName: "status";
-    readonly description: "Report current branch, KB snapshot and freshness metadata, plus the deterministic workspace snapshot used to validate execution receipts. Read-only status inspection with no mutation side effects.";
+    readonly description: "Report current branch, KB snapshot, freshness metadata, schema status, and a typed kibi.migration-plan.v2 action graph. Read-only status inspection with no mutation side effects; damaged stores are diagnosed without starting the engine.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {};
     };
-    readonly requiresProlog: true;
+    readonly requiresProlog: false;
     readonly effects: readonly ["kb-read", "workspace-read"];
     readonly execute: typeof import("./discovery-executors.js").executeStatus;
 }, {
@@ -195,7 +279,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_coverage";
     readonly cliName: "coverage";
-    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Requirement reports include a deterministic, dependency-ordered, read-only repair plan; optional legacy migration previews reconstruct authored proposition inventories and rank exact schema candidates without producing executable writes. Paginated plans identify incomplete scope. Requirement rows keep coverageStatus separate from proofStatus and require fresh snapshot-bound E2E receipts before proof. No mutation side effects.";
+    readonly description: "Generate curated structural coverage and conservative end-to-end requirement proof reports for requirements, symbols, or grouped types. Reports include the compatible repair plan plus typed kibi.migration-plan.v2 actions; semantic and E2E actions remain review/execution work. Paginated plans identify incomplete scope and no mutation occurs.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -214,6 +298,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;
@@ -401,7 +493,7 @@ export declare const OPERATION_CATALOG: readonly [{
             };
             readonly source: {
                 readonly type: "string";
-                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.";
+                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: '.kb/requirements/customer-retention.md'.";
             };
             readonly sourceFiles: {
                 readonly type: "array";
@@ -435,7 +527,7 @@ export declare const OPERATION_CATALOG: readonly [{
             };
             readonly provenance: {
                 readonly type: "string";
-                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.";
+                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: '.kb/requirements/customer-retention.md#L1'.";
             };
             readonly existingLogicClaims: {
                 readonly type: "array";
@@ -470,7 +562,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_suggest_predicates";
     readonly cliName: "suggest-predicates";
-    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, an applicable predicate-fact plan only when every ordered argument is bound, a separate requires_predicate relationship plan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Retrieval/ranking is followed by a semantic applicability gate and conservative binding review; complete-looking generic placeholders never trigger application. Read-only guidance returns additive candidate diagnostics, an applicable predicate-fact plan only for a semantically eligible candidate with reviewed bindings, or an explicit ontology-gap observation plus a deterministic review-only predicate schema draft when no schema fits.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["text"];
@@ -543,9 +635,9 @@ export declare const OPERATION_CATALOG: readonly [{
     readonly effects: readonly ["kb-read"];
     readonly execute: typeof import("../../operations/modeling/suggest-predicates.js").executeSuggestPredicates;
 }, {
-    readonly name: "kb_autopilot_generate";
-    readonly cliName: "autopilot-generate";
-    readonly description: "Generate agent-centric bootstrap output for KB population. Read-only analysis that returns activation state, bootstrap guidance, candidate entities with evidence, payoff summary, and exact applyPlan payloads for later kb_upsert calls. No mutation side effects.";
+    readonly name: "kb_plan_bootstrap";
+    readonly cliName: "plan-bootstrap";
+    readonly description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -618,7 +710,7 @@ export declare const OPERATION_CATALOG: readonly [{
     };
     readonly requiresProlog: false;
     readonly effects: readonly ["workspace-read"];
-    readonly execute: typeof import("./index.js").executeAutopilotGenerate;
+    readonly execute: typeof import("./index.js").executePlanBootstrap;
 }, {
     readonly name: "kb_validate_upsert";
     readonly cliName: "validate-upsert";
@@ -756,7 +848,7 @@ export declare const OPERATION_CATALOG: readonly [{
                     };
                     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: {
@@ -774,30 +866,101 @@ export declare const OPERATION_CATALOG: readonly [{
                         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;
                                 };
@@ -807,7 +970,7 @@ export declare const OPERATION_CATALOG: readonly [{
                                 };
                                 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";
@@ -829,10 +992,176 @@ export declare const OPERATION_CATALOG: readonly [{
                                     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";
@@ -996,7 +1325,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"];
@@ -1027,6 +1356,20 @@ export declare const OPERATION_CATALOG: readonly [{
                     };
                 };
             };
+            readonly document: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "Optional source-first document write. Paths are workspace-relative; omit body when updating to preserve the existing body bytes.";
+                readonly properties: {
+                    readonly path: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly body: {
+                        readonly type: "string";
+                    };
+                };
+            };
         };
     };
     readonly requiresProlog: true;
@@ -1038,14 +1381,54 @@ export declare const OPERATION_CATALOG: readonly [{
     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.";
             };
         };
     };
@@ -1055,7 +1438,7 @@ export declare const OPERATION_CATALOG: readonly [{
 }, {
     readonly name: "kb_check";
     readonly cliName: "check";
-    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review, including telemetry acceptance when .kb/usage.log exists.";
+    readonly description: "Run KB validation rules and return violations, quality diagnostics, and typed kibi.migration-plan.v2 actions. Use before or after mutations and after source edits; checks remain read-only and never infer or apply actions from prose suggestions.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -1063,9 +1446,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", "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, 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 all rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; 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. 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";
@@ -1093,7 +1476,12 @@ export declare const OPERATION_CATALOG: readonly [{
             };
             readonly workspaceRoot: {
                 readonly type: "string";
-                readonly description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.";
+                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.";
             };
         };
     };
@@ -1125,7 +1513,485 @@ export declare const OPERATION_CATALOG: readonly [{
     readonly requiresProlog: false;
     readonly effects: readonly ["network-read"];
     readonly execute: (input: import("./index.js").SparqlRemoteInput, context: import("./runtime-types.js").OperationContext) => Promise<import("./types.js").OperationResult<import("./index.js").SparqlRemoteOutput>>;
+}, {
+    readonly name: "kb_compile_intent";
+    readonly cliName: "compile-intent";
+    readonly description: "Compile complete change intent into a deterministic, snapshot-bound read-only plan. Reuses intent-aware discovery and semantic modeling, accounts for every proposition, reports contradiction witnesses, proposes traceability links, and emits dependency-ordered kb_upsert-style steps only for resolved typed claims. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["intent", "mode"];
+        readonly properties: {
+            readonly intent: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 10000;
+                readonly description: "Complete post-change normative intent. Send the desired behavior, not a patch fragment.";
+            };
+            readonly mode: {
+                readonly type: "string";
+                readonly enum: readonly ["create", "update"];
+                readonly description: "Create a new requirement or update an existing one. Update auto-selection is allowed only with a high-confidence, well-separated candidate.";
+            };
+            readonly requirementId: {
+                readonly type: "string";
+                readonly description: "Optional exact requirement ID. Required for an update when automatic selection is below the confidence and margin gates.";
+            };
+            readonly title: {
+                readonly type: "string";
+                readonly description: "Optional requirement title; existing title is preserved for updates when omitted.";
+            };
+            readonly clauses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly maxItems: 64;
+                readonly description: "Optional complete atomic clause decomposition. Each assertive clause receives independent proposition accounting.";
+            };
+            readonly semanticFacets: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly actors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly objects: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly constraints: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly maxItems: 20;
+                    };
+                };
+                readonly description: "Host-agent facets forwarded to deterministic intent-v1 discovery.";
+            };
+            readonly sourceLocations: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["path"];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly line: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly column: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly symbol: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Workspace-relative source coordinates used for discovery and before-hash binding.";
+            };
+            readonly interpretations: {
+                readonly type: "array";
+                readonly maxItems: 3;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["claim_key", "claim_text", "ir"];
+                    readonly properties: {
+                        readonly claim_key: {
+                            readonly type: "string";
+                        };
+                        readonly claim_text: {
+                            readonly type: "string";
+                        };
+                        readonly confidence: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                            readonly maximum: 1;
+                        };
+                        readonly span: {
+                            readonly type: "object";
+                        };
+                        readonly ir: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+                readonly description: "Optional host-supplied typed kibi.logic.v1 interpretations; Kibi validates them before including rule steps.";
+            };
+            readonly scenarioDrafts: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["title", "body"];
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly body: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly description: "Optional scenario drafts. Each is linked requirement -> scenario with specified_by.";
+            };
+            readonly testDrafts: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["title", "body"];
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly title: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly body: {
+                            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"];
+                        };
+                        readonly verificationPerspective: {
+                            readonly type: "string";
+                            readonly enum: readonly ["internal", "consumer"];
+                        };
+                    };
+                };
+                readonly description: "Optional test drafts. Tests are attached to scenarios with verified_by; direct req -> test proof links are not emitted.";
+            };
+            readonly proposalDecisions: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["proposalId", "decision"];
+                    readonly properties: {
+                        readonly proposalId: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly decision: {
+                            readonly type: "string";
+                            readonly enum: readonly ["accept", "reject"];
+                        };
+                    };
+                };
+                readonly description: "Explicit decisions for deterministic traceability proposals. Pending proposals never enter steps.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof import("./index.js").executeCompileIntent;
+}, {
+    readonly name: "kb_apply_plan";
+    readonly cliName: "apply-plan";
+    readonly description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly oneOf: readonly [{
+            readonly required: readonly ["plan", "approvedPlanHash"];
+            readonly not: {
+                readonly required: readonly ["recoveryJournalId"];
+            };
+        }, {
+            readonly required: readonly ["recoveryJournalId"];
+            readonly not: {
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["plan"];
+                }, {
+                    readonly required: readonly ["approvedPlanHash"];
+                }];
+            };
+        }];
+        readonly properties: {
+            readonly approvedPlanHash: {
+                readonly type: "string";
+                readonly pattern: "^[a-fA-F0-9]{64}$";
+                readonly description: "Exact SHA-256 planHash returned by kb_plan_bootstrap, kb_compile_intent, or another approved plan after human review.";
+            };
+            readonly plan: {
+                readonly type: "object";
+                readonly required: readonly ["version", "planHash"];
+                readonly description: "The complete kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or hash-bound kibi.entity-deletion-plan.v1 object. Migration plans require approvedActionIds and reject blocked/non-automatic actions.";
+            };
+            readonly approvedActionIds: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly description: "Required for migration-plan.v2. Exact automatic action IDs explicitly approved for this application.";
+            };
+            readonly recoveryJournalId: {
+                readonly type: "string";
+                readonly pattern: "^[A-Za-z0-9._-]+$";
+                readonly description: "Typed recovery journal identifier returned by a committed_with_repairs result. Recovery replays only the immutable journal and never the original plan request.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "kb-write", "workspace-read", "workspace-write"];
+    readonly execute: typeof import("./index.js").executeApplyPlan;
+}, {
+    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 ["snapshot", "artifact"];
+        readonly properties: {
+            readonly snapshot: {
+                readonly type: "string";
+                readonly pattern: "^[a-f0-9]{64}$";
+                readonly description: "Workspace snapshot captured immediately before the run.";
+            };
+            readonly artifact: {
+                readonly type: "object";
+                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.proof-run.v1";
+                    };
+                    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";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly code_snapshot: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{64}$";
+                    };
+                    readonly environment: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                    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 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 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").executeIngestProof;
 }];
-export declare function getSpec(name: OperationName): OperationSpec;
-export declare function listSpecs(): readonly OperationSpec[];
+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