kibi-cli 0.12.8 → 0.16.1

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

@@ -0,0 +1,907 @@
+import type { OperationName, OperationSpec } from "./types.js";
+export declare const OPERATION_CATALOG: readonly [{
+    readonly name: "kb_skills_list";
+    readonly cliName: "skills list";
+    readonly description: "List bundled Kibi agent skills available for progressive disclosure. Read-only; does not mutate the KB or require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: (_input: Readonly<Record<string, unknown>>, _context: import("./runtime-types.js").OperationContext) => Promise<import("./types.js").OperationResult<{
+        readonly skills: readonly import("../skills.js").SkillManifest[];
+    }>>;
+}, {
+    readonly name: "kb_skills_load";
+    readonly cliName: "skills load";
+    readonly description: "Load a bundled Kibi agent skill by ID, returning its manifest metadata, Markdown body, declared resources, content hash, and source type. Read-only; does not execute scripts or require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["id"];
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Bundled skill ID to load. Example: 'kibi-usage'.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: (input: Readonly<Record<string, unknown>>, _context: import("./runtime-types.js").OperationContext) => Promise<import("./types.js").OperationResult<{
+        readonly metadata: import("../skills.js").SkillManifest;
+        readonly body: string;
+        readonly resources: readonly string[];
+        readonly contentHash: string;
+        readonly sourceType: "bundled";
+    }>>;
+}, {
+    readonly name: "kb_skills_read";
+    readonly cliName: "skills read";
+    readonly description: "Read a declared resource from a bundled Kibi agent skill. Resource paths are restricted to the skill manifest; arbitrary file paths are not exposed. Read-only; does not require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["id", "resource"];
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Bundled skill ID. Example: 'kibi-usage'.";
+            };
+            readonly resource: {
+                readonly type: "string";
+                readonly description: "Manifest-declared resource path to read. Example: 'resources/workflows.md'.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: (input: Readonly<Record<string, unknown>>, _context: import("./runtime-types.js").OperationContext) => Promise<import("./types.js").OperationResult<{
+        readonly content: string;
+    }>>;
+}, {
+    readonly name: "kb_query";
+    readonly cliName: "query";
+    readonly description: "Read entities from the KB with filters. Use for discovery and lookup before edits. Do not use for writes. No mutation side effects. Tags filter by metadata tags only, not entity IDs.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Optional entity type filter. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Optional exact entity ID. Example: 'REQ-001'. If omitted, returns matching entities by other filters.";
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional tag filter. Matches entities that contain any provided tag. Example: ['security','billing'].";
+            };
+            readonly sourceFile: {
+                readonly type: "string";
+                readonly description: "Optional source-file substring filter. Example: 'src/auth/login.ts'. Uses KB source linkage, not file-system scanning.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly default: 100;
+                readonly description: "Optional max rows to return after filtering. Default: 100 when omitted. Example: 25.";
+            };
+            readonly offset: {
+                readonly type: "number";
+                readonly default: 0;
+                readonly description: "Optional zero-based pagination offset. Default: 0. Example: 50 to skip first 50 rows.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("./discovery-executors.js").executeQuery;
+}, {
+    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 businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["query"];
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 4096;
+                readonly description: "Free-text query for metadata and markdown body discovery. Example: 'OAuth login flow'.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Optional entity type filter to narrow discovery. Example: 'req'.";
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly default: 20;
+                readonly description: "Optional max rows to return after ranking. Default: 20.";
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly default: 0;
+                readonly description: "Optional zero-based pagination offset. Default: 0.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("./discovery-executors.js").executeSearch;
+}, {
+    readonly name: "kb_status";
+    readonly cliName: "status";
+    readonly description: "Report current branch, snapshot, and freshness metadata for the attached KB. Read-only status inspection with no mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof import("./discovery-executors.js").executeStatus;
+}, {
+    readonly name: "kb_find_gaps";
+    readonly cliName: "find-gaps";
+    readonly description: "Run bulk missing/present relationship analysis over KB entities. Use for questions like which requirements lack scenarios or tests. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+            };
+            readonly missingRelationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly presentRelationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly sourceFile: {
+                readonly type: "string";
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly default: 100;
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("./index.js").executeFindGaps;
+}, {
+    readonly name: "kb_coverage";
+    readonly cliName: "coverage";
+    readonly description: "Generate curated coverage reports for requirements, symbols, or grouped types. Read-only reporting with no mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly by: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "symbol", "type"];
+                readonly default: "req";
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly includePassing: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly includeTransitive: {
+                readonly type: "boolean";
+                readonly default: true;
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly default: 100;
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("./index.js").executeCoverage;
+}, {
+    readonly name: "kb_graph";
+    readonly cliName: "graph";
+    readonly description: "Run bounded graph traversal from one or more seed IDs across curated relationship types. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["seedIds"];
+        readonly properties: {
+            readonly seedIds: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly direction: {
+                readonly type: "string";
+                readonly enum: readonly ["outgoing", "incoming", "both"];
+                readonly default: "outgoing";
+            };
+            readonly depth: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly minimum: 1;
+                readonly maximum: 5;
+            };
+            readonly entityTypes: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly maxNodes: {
+                readonly type: "integer";
+                readonly default: 200;
+            };
+            readonly maxEdges: {
+                readonly type: "integer";
+                readonly default: 500;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("./index.js").executeGraph;
+}, {
+    readonly name: "kb_semantic_advisor";
+    readonly cliName: "semantic-advisor";
+    readonly description: "Analyze requirement prose without mutating the KB and return semantic advisor receipts with modeling suggestions. Use before constructing kb_upsert payloads when prose may contain machine-checkable logic. Suggestions can include strict-property facts, predicate facts, ambiguity observations, or ontology-gap observations; all suggestions are advisory and reviewable.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Requirement prose to inspect for machine-checkable modeling suggestions.";
+            };
+            readonly clauses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req"];
+                readonly default: "req";
+                readonly description: "Entity type context for analysis. Currently requirement prose is supported.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Optional requirement ID used for deterministic draft relationship guidance.";
+            };
+            readonly title: {
+                readonly type: "string";
+                readonly description: "Optional requirement title for draft apply plans.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional provenance for draft suggestions.";
+            };
+            readonly status: {
+                readonly type: "string";
+                readonly description: "Optional requirement status for draft suggestions.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: (input: Readonly<Record<string, unknown>>, context: import("./runtime-types.js").OperationContext) => Promise<import("../../operations/semantic-advisor/types.js").SemanticAdvisorOperationResult>;
+}, {
+    readonly name: "kb_model_requirement";
+    readonly cliName: "model-requirement";
+    readonly description: "Convert a prose requirement plus optional extracted claim fields into a deterministic strict-lane write set. Read-only modeling returns a sequential applyPlan for later kb_upsert calls. High-confidence claims emit req+fact strict output; lower-confidence claims emit an observation review artifact. Includes migration warnings when legacy schemaVersion metadata is detected.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Required prose requirement text to model. Example: 'Customer data must be retained for 7 years.'";
+            };
+            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 sourceFiles: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional related source files. The first value is used as the source fallback when source is omitted.";
+            };
+            readonly confidence: {
+                readonly type: "number";
+                readonly default: 0.8;
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly description: "Confidence score for the extracted claim. >= 0.70 yields strict-lane output; lower confidence yields observation-only review output.";
+            };
+            readonly subjectKey: {
+                readonly type: "string";
+                readonly description: "Optional extracted semantic claim subjectKey. Example: 'Customer.Data'.";
+            };
+            readonly propertyKey: {
+                readonly type: "string";
+                readonly description: "Optional extracted semantic claim propertyKey. Example: 'Retention Years'.";
+            };
+            readonly operator: {
+                readonly type: "string";
+                readonly enum: readonly ["eq", "gte", "lte", "neq", "bool", "polarity"];
+                readonly description: "Optional extracted semantic claim operator. Example: 'eq'.";
+            };
+            readonly value: {
+                readonly description: "Optional extracted semantic claim value. Accepts string, number, or boolean.";
+            };
+            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 existingLogicClaims: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                };
+                readonly uniqueItems: true;
+                readonly description: "Existing requirement logic_claims values. The returned requirement update merges the new atomic claim key into this manifest instead of replacing prior claims.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("../../operations/modeling/model-requirement.js").executeModelRequirement;
+}, {
+    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, a safe predicate-fact applyPlan, a separate requires_predicate relationshipPlan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Required prose requirement or claim to classify into ontology predicates. Example: 'When users navigate away, draft edits must auto-save.'.";
+            };
+            readonly requirementId: {
+                readonly type: "string";
+                readonly description: "Optional existing requirement ID. When provided, the response includes a relationshipPlan describing the req -> fact requires_predicate link to attach after preserving existing requirement metadata.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional provenance or text reference for generated predicate facts or ontology-gap observations.";
+            };
+            readonly subjectHint: {
+                readonly type: "string";
+                readonly description: "Optional canonical subject key to use as the first predicate argument. Example: 'editor.annotation'.";
+            };
+            readonly maxCandidates: {
+                readonly type: "integer";
+                readonly default: 5;
+                readonly minimum: 1;
+                readonly maximum: 20;
+                readonly description: "Maximum ranked predicate candidates to return. Default: 5.";
+            };
+            readonly minScore: {
+                readonly type: "number";
+                readonly default: 0.35;
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly description: "Minimum candidate score. Higher values make ontology-gap fallback more likely. Default: 0.35.";
+            };
+            readonly includeExistingSchemas: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Whether to include existing KB fact_kind=predicate_schema facts alongside Kibi's built-in predicate catalog. Default: true.";
+            };
+            readonly existingLogicClaims: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                };
+                readonly uniqueItems: true;
+                readonly description: "Existing requirement logic_claims values. Returned relationship guidance includes a merged manifest so repeated clause modeling does not discard earlier claims.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    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 businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly includeGenericMarkdown: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Whether to include generic markdown file content as candidate facts. Default: true.";
+            };
+            readonly minConfidence: {
+                readonly type: "number";
+                readonly default: 0.8;
+                readonly minimum: 0.6;
+                readonly maximum: 0.95;
+                readonly description: "Minimum confidence threshold for candidates. Clamped to [0.60, 0.95]. Default: 0.80.";
+            };
+            readonly maxCandidates: {
+                readonly type: "integer";
+                readonly default: 50;
+                readonly minimum: 1;
+                readonly maximum: 200;
+                readonly description: "Maximum number of candidates to return. Clamped to [1, 200]. Default: 50.";
+            };
+            readonly entityTypes: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["req", "scenario", "test", "adr", "fact", "symbol"];
+                };
+                readonly description: "Optional filter to limit candidate generation to specific entity types.";
+            };
+            readonly bootstrapContext: {
+                readonly type: "object";
+                readonly description: "Optional declared bootstrap context supplied by the agent to ground the read-only synthesis output.";
+                readonly properties: {
+                    readonly projectSummary: {
+                        readonly type: "string";
+                        readonly description: "Optional short summary of the project or bootstrap goal.";
+                    };
+                    readonly sourceOfTruthPaths: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional repo-relative paths that should be treated as declared sources of truth.";
+                    };
+                    readonly sourceOfTruthNotes: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional notes about how to interpret the declared sources of truth.";
+                    };
+                    readonly priorityRoots: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional repo roots the bootstrap flow should prioritize when authoring entities.";
+                    };
+                    readonly verificationAnchors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional verification commands, documents, or checkpoints to reference in the output.";
+                    };
+                };
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["workspace-read"];
+    readonly execute: typeof import("./index.js").executeAutopilotGenerate;
+}, {
+    readonly name: "kb_validate_upsert";
+    readonly cliName: "validate-upsert";
+    readonly description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model_requirement, kb_suggest_predicates, ambiguity review, or an ontology-gap observation.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["type", "id", "properties"];
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+            };
+            readonly id: {
+                readonly type: "string";
+            };
+            readonly properties: {
+                readonly type: "object";
+                readonly description: "Entity properties to validate using the same snake_case field names accepted by kb_upsert.";
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                };
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof import("../../operations/mutation/validate-upsert.js").executeValidateUpsert;
+}, {
+    readonly name: "kb_upsert";
+    readonly cliName: "upsert";
+    readonly description: "Create or update one entity and optional relationships. Use for KB mutations after validating intent; prefer kb_validate_upsert first because it returns semantic advisor receipts for prose-heavy requirements. Use kb_model_requirement before hand-writing strict property facts from prose, and kb_suggest_predicates before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request. Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["type", "id", "properties"];
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Entity type to create/update. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Unique entity ID (string). Example: 'REQ-123'. Existing ID updates the entity; new ID creates it.";
+            };
+            readonly properties: {
+                readonly type: "object";
+                readonly description: "Entity fields to persist. Must include title and status. If created_at, updated_at, or source are omitted, server fills defaults.";
+                readonly properties: {
+                    readonly title: {
+                        readonly type: "string";
+                        readonly description: "Required short title. Example: 'Protect account settings endpoint'.";
+                    };
+                    readonly status: {
+                        readonly type: "string";
+                        readonly description: "Required lifecycle state. Allowed values depend on entity type; backward-compatible legacy statuses are also accepted. Examples: 'open', 'passing', 'accepted', 'active'.";
+                    };
+                    readonly source: {
+                        readonly type: "string";
+                        readonly description: "Optional provenance string. Example: 'docs/requirements/REQ-123.md'. Defaults to 'mcp://kibi/upsert'.";
+                    };
+                    readonly tags: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional categorization tags. Example: ['security','api'].";
+                    };
+                    readonly owner: {
+                        readonly type: "string";
+                        readonly description: "Optional owner name/team. Example: 'platform-team'.";
+                    };
+                    readonly priority: {
+                        readonly type: "string";
+                        readonly description: "Optional priority label. Example: 'high'.";
+                    };
+                    readonly severity: {
+                        readonly type: "string";
+                        readonly description: "Optional severity label. Example: 'critical'.";
+                    };
+                    readonly links: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional references. Example: ['REQ-010','https://example.com/spec'].";
+                    };
+                    readonly text_ref: {
+                        readonly type: "string";
+                        readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
+                    };
+                    readonly logic_claims: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                        };
+                        readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
+                    };
+                    readonly sourceFile: {
+                        readonly type: "string";
+                        readonly description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.";
+                    };
+                    readonly granularity_reason: {
+                        readonly type: "string";
+                        readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+                        readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
+                    };
+                    readonly symbol_role: {
+                        readonly type: "string";
+                        readonly enum: readonly ["behavioral", "structural", "type-shape", "config", "module", "unknown"];
+                        readonly description: "Optional role classification for symbol entities. Example: 'behavioral'.";
+                    };
+                    readonly verification_scope: {
+                        readonly type: "string";
+                        readonly enum: readonly ["unit", "integration", "end_to_end"];
+                        readonly description: "Optional typed verification scope for test entities. Example: 'end_to_end'.";
+                    };
+                    readonly verification_perspective: {
+                        readonly type: "string";
+                        readonly enum: readonly ["internal", "consumer"];
+                        readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
+                    };
+                    readonly fact_kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate"];
+                        readonly description: "Optional fact lane kind for fact entities. Strict lane uses 'subject' and 'property_value'; context lane uses 'observation' or 'meta'; ontology lane uses 'predicate_schema' or 'predicate'. Use kb_model_requirement or kb_suggest_predicates when starting from prose.";
+                    };
+                    readonly subject_key: {
+                        readonly type: "string";
+                        readonly description: "Snake_case only. Optional canonical subject key for strict fact entities. Example: 'user.session'. Do not use subjectKey in kb_upsert.properties.";
+                    };
+                    readonly property_key: {
+                        readonly type: "string";
+                        readonly description: "Snake_case only. Optional canonical property key for property_value facts. Example: 'session.timeout_minutes'. Do not use propertyKey in kb_upsert.properties.";
+                    };
+                    readonly operator: {
+                        readonly type: "string";
+                        readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte"];
+                        readonly description: "Optional comparison operator for property_value facts. Example: 'eq'.";
+                    };
+                    readonly value_type: {
+                        readonly type: "string";
+                        readonly enum: readonly ["string", "int", "number", "bool"];
+                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, or value_bool; do not use generic value.";
+                    };
+                    readonly value_string: {
+                        readonly type: "string";
+                        readonly description: "Optional string value for property_value facts.";
+                    };
+                    readonly value_int: {
+                        readonly type: "integer";
+                        readonly description: "Optional integer value for property_value facts.";
+                    };
+                    readonly value_number: {
+                        readonly type: "number";
+                        readonly description: "Optional number value for property_value facts.";
+                    };
+                    readonly value_bool: {
+                        readonly type: "boolean";
+                        readonly description: "Optional boolean value for property_value facts.";
+                    };
+                    readonly unit: {
+                        readonly type: "string";
+                        readonly description: "Optional unit for numeric property_value facts.";
+                    };
+                    readonly scope: {
+                        readonly type: "string";
+                        readonly description: "Optional scope qualifier for fact entities.";
+                    };
+                    readonly polarity: {
+                        readonly type: "string";
+                        readonly enum: readonly ["require", "forbid", "assert", "deny"];
+                        readonly description: "Optional polarity for property_value or predicate facts.";
+                    };
+                    readonly closed_world: {
+                        readonly type: "boolean";
+                        readonly description: "Optional closed-world marker for strict fact interpretation.";
+                    };
+                    readonly canonical_key: {
+                        readonly type: "string";
+                        readonly description: "Optional canonical identity key for predicate or strict fact claims.";
+                    };
+                    readonly claim_key: {
+                        readonly type: "string";
+                        readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                        readonly description: "Stable semantic-advisor key for the atomic prose clause grounded by this fact.";
+                    };
+                    readonly claim_text: {
+                        readonly type: "string";
+                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit.";
+                    };
+                    readonly predicate_name: {
+                        readonly type: "string";
+                        readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.";
+                    };
+                    readonly predicate_args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.";
+                    };
+                    readonly predicate_namespace: {
+                        readonly type: "string";
+                        readonly description: "Optional namespace for a project-local predicate schema.";
+                    };
+                    readonly predicate_arity: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly description: "Required arity for predicate_schema facts.";
+                    };
+                    readonly argument_names: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Ordered argument role names for predicate_schema facts.";
+                    };
+                    readonly argument_types: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Ordered argument types for predicate_schema facts.";
+                    };
+                    readonly argument_descriptions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ordered argument explanations.";
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional vocabulary aliases for predicate discovery.";
+                    };
+                    readonly examples: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ground-term examples for a predicate schema.";
+                    };
+                };
+                readonly allOf: readonly [Record<string, unknown>];
+                readonly required: readonly ["title", "status"];
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "from", "to"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+                            readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
+                        };
+                        readonly from: {
+                            readonly type: "string";
+                            readonly description: "Source entity ID (must exist). Example: 'SYM-login-handler'.";
+                        };
+                        readonly to: {
+                            readonly type: "string";
+                            readonly description: "Target entity ID (must exist). Example: 'REQ-001'.";
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-write", "workspace-write"];
+    readonly execute: typeof import("../../operations/mutation/upsert.js").executeUpsert;
+}, {
+    readonly name: "kb_delete";
+    readonly cliName: "delete";
+    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 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 requiresProlog: true;
+    readonly effects: readonly ["kb-write", "workspace-write"];
+    readonly execute: typeof import("../../operations/mutation/delete.js").executeDelete;
+}, {
+    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.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly rules: {
+                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", "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, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+            };
+            readonly sourceFiles: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional repo-relative source files to inspect for early impact diagnostics. Use with includeImpactDiagnostics after meaningful source edits.";
+            };
+            readonly staged: {
+                readonly type: "boolean";
+                readonly description: "When true, inspect staged source changes for impact diagnostics using the shared CLI impact analyzer without shelling out to kibi check.";
+            };
+            readonly includeWorkingTreeDiff: {
+                readonly type: "boolean";
+                readonly description: "When true, inspect current unstaged working-tree diffs for impact diagnostics. Pair with sourceFiles to scope the analysis.";
+            };
+            readonly includeImpactDiagnostics: {
+                readonly type: "boolean";
+                readonly description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation and symbol_semantic_review_needed in structured output.";
+            };
+            readonly maxDiagnostics: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly description: "Optional maximum number of impact diagnostics to return. Graph validation violations are not capped by this value.";
+            };
+            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 requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof import("./check-executor.js").executeCheck;
+}, {
+    readonly name: "kb_sparql_remote";
+    readonly cliName: "sparql-remote";
+    readonly description: "Opt-in remote SPARQL query tool for external HTTP(S) RDF endpoints. This does not query Kibi's local RDF store directly, stores no credentials, and depends on network availability.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["endpoint", "query"];
+        readonly properties: {
+            readonly endpoint: {
+                readonly type: "string";
+                readonly description: "Remote SPARQL endpoint URL. Must start with http:// or https://.";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "SPARQL SELECT query to send to the remote endpoint.";
+            };
+            readonly timeoutMs: {
+                readonly type: "number";
+                readonly description: "Optional positive timeout in milliseconds for the remote query.";
+            };
+        };
+    };
+    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>>;
+}];
+export declare function getSpec(name: OperationName): OperationSpec;
+export declare function listSpecs(): readonly OperationSpec[];
+//# sourceMappingURL=catalog.d.ts.map