kibi-cli 0.18.1 → 1.0.1

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: {
@@ -401,7 +485,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 +519,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 +554,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 +627,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 +702,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 +840,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,63 +858,206 @@ 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 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 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 verification_contract: {
+                        readonly type: "object";
+                        readonly required: readonly ["version", "runner", "command_argv", "required_case_symbols", "required_projects", "success_policy"];
+                        readonly properties: {
+                            readonly version: {
+                                readonly type: "string";
+                                readonly const: "kibi.verification-contract.v1";
+                            };
+                            readonly runner: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly command_argv: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly items: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly command: {
+                            };
+                            readonly required_case_symbols: {
+                                readonly type: "array";
+                                readonly items: {
                                     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"];
-                                };
-                                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 uniqueItems: true;
+                            };
+                            readonly required_projects: {
+                                readonly type: "array";
+                                readonly items: {
                                     readonly type: "string";
                                     readonly minLength: 1;
                                 };
-                                readonly finished_at: {
-                                    readonly type: "string";
-                                    readonly minLength: 1;
+                                readonly uniqueItems: true;
+                            };
+                            readonly success_policy: {
+                                readonly type: "string";
+                                readonly const: "all_required_cases_first_attempt";
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                    readonly verification_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 artifact_digest: {
-                                    readonly type: "string";
-                                    readonly pattern: "^[a-f0-9]{64}$";
+                                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 command_argv: {
+                                        readonly type: "array";
+                                        readonly minItems: 1;
+                                        readonly items: {
+                                            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 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 additionalProperties: false;
+                                readonly type: "object";
+                                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.";
                     };
@@ -1027,6 +1254,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 +1279,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 +1336,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 +1344,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 ["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 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, 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 sourceFiles: {
                 readonly type: "array";
@@ -1093,7 +1374,7 @@ 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.";
             };
         };
     };
@@ -1125,7 +1406,341 @@ 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 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_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 businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["testId", "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 artifact: {
+                readonly type: "object";
+                readonly required: readonly ["version", "runner", "command_argv", "code_snapshot", "environment_hash", "started_at", "finished_at", "process_exit_code", "cases"];
+                readonly properties: {
+                    readonly version: {
+                        readonly type: "string";
+                        readonly const: "kibi.playwright-run.v1";
+                    };
+                    readonly runner: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    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_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 process_exit_code: {
+                        readonly type: "integer";
+                    };
+                    readonly cases: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly maxItems: 1000;
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+                readonly additionalProperties: true;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "kb-write", "workspace-read"];
+    readonly execute: typeof import("./index.js").executeIngestVerification;
 }];
-export declare function getSpec(name: OperationName): OperationSpec;
-export declare function listSpecs(): readonly OperationSpec[];
+export declare function withContractDefaults(spec: OperationSpec): ResolvedOperationSpec;
+export declare function getSpec(name: OperationName): ResolvedOperationSpec;
+export declare function listSpecs(): readonly ResolvedOperationSpec[];
 //# sourceMappingURL=catalog.d.ts.map