kibi-cli 2.4.0 → 2.5.1

package/dist/public/operations/specs/check-rules.generated.d.ts

@@ -1,5 +1,5 @@
 /** Every selectable kb_check rule name, registry order. */
 export declare const SELECTABLE_RULE_NAMES: readonly string[];
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, predicate-schema-conformance";
+export declare const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance";
 //# sourceMappingURL=check-rules.generated.d.ts.map

package/dist/public/operations/specs/check-rules.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EA4BlD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,ijBAC2gB,CAAC"}
+{"version":3,"file":"check-rules.generated.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check-rules.generated.ts"],"names":[],"mappings":"AAUA,2DAA2D;AAC3D,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EA0ClD,CAAC;AAGF,8EAA8E;AAC9E,eAAO,MAAM,wBAAwB,04BACo2B,CAAC"}

package/dist/public/operations/specs/check-rules.generated.js

@@ -14,9 +14,16 @@ export const SELECTABLE_RULE_NAMES = [
     "symbol-traceability",
     "no-dangling-refs",
     "source-relationship-parity",
+    "source-path-dangling",
     "no-cycles",
     "required-fields",
     "deprecated-adr-no-successor",
+    "superseded-requirement-open",
+    "scenario-feasibility",
+    "scenario-feasibility-unknown",
+    "exception-claim-keys",
+    "numeric-string-value",
+    "rule-key-arguments-missing",
     "domain-contradictions",
     "logic-coverage",
     "rule-safety",
@@ -35,8 +42,15 @@ export const SELECTABLE_RULE_NAMES = [
     "subject-key-identity",
     "subject-key-shape",
     "ontology-quality",
+    "exception-unapproved",
+    "exception-approval-self-attested",
+    "agent-requirement-unapproved",
+    "requirement-rationale-missing",
+    "symbol-owner-superseded",
+    "adr-unlinked",
+    "adr-proposed",
     "predicate-schema-conformance",
 ];
 // implements REQ-006
 /** Comma-separated "Allowed:" fragment for the kb_check rules description. */
-export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, predicate-schema-conformance";
+export const SELECTABLE_RULES_ALLOWED = "must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance";

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

@@ -12,7 +12,7 @@ export declare const checkSpec: {
                     readonly type: "string";
                     readonly enum: readonly string[];
                 };
-                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, predicate-schema-conformance. If omitted, server runs canonical and advisory rules plus the full-KB qualityDiagnostics audit scan, including usage telemetry acceptance when evidence exists; migration rules run only when explicitly selected. Advisory and migration findings are non-blocking qualityDiagnostics. If supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, source-relationship-parity, source-path-dangling, no-cycles, required-fields, deprecated-adr-no-successor, superseded-requirement-open, scenario-feasibility, scenario-feasibility-unknown, exception-claim-keys, numeric-string-value, rule-key-arguments-missing, domain-contradictions, logic-coverage, rule-safety, rule-verifiability, query-plan-safety, req-status-vocabulary, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, strict-readiness, semantic-completeness, proof-contract-symbols, entity-id-style, domain-redundancy, domain-implication, subject-key-identity, subject-key-shape, ontology-quality, exception-unapproved, exception-approval-self-attested, agent-requirement-unapproved, requirement-rationale-missing, symbol-owner-superseded, adr-unlinked, adr-proposed, predicate-schema-conformance. 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";
@@ -45,7 +45,7 @@ export declare const checkSpec: {
             readonly async: {
                 readonly type: "boolean";
                 readonly default: false;
-                readonly description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.";
+                readonly description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout. The MCP server registers kb_job_status only when KIBI_MCP_OPTIONAL_TOOLS includes it; otherwise async runs the check synchronously.";
             };
         };
     };

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

@@ -44,7 +44,7 @@ export const checkSpec = {
             async: {
                 type: "boolean",
                 default: false,
-                description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout.",
+                description: "When true, start the check as a background job and return a kibi.job.v1 receipt immediately instead of holding the request until the tool timeout. Poll kb_job_status with the returned jobId. Use for full checks on large KBs that exceed the configured tool timeout. The MCP server registers kb_job_status only when KIBI_MCP_OPTIONAL_TOOLS includes it; otherwise async runs the check synchronously.",
             },
         },
     },

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

@@ -0,0 +1,351 @@
+import type { OperationContext } from "../runtime-types.js";
+import type { OperationResult } from "../types.js";
+/**
+ * Composite operations keep the agent-facing tool list short. Each one
+ * dispatches to an existing operation by `action` or `mode` and returns that
+ * operation's payload unchanged plus the selector, so the narrower CLI routes
+ * and the composite tool always agree.
+ */
+type Executor = (input: never, context: OperationContext) => Promise<unknown>;
+export declare function dispatchComposite(selector: "action" | "mode", routes: Readonly<Record<string, {
+    readonly execute: Executor;
+    readonly businessInputSchema: Readonly<Record<string, unknown>>;
+}>>, input: Readonly<Record<string, unknown>>, context: OperationContext): Promise<OperationResult<Record<string, unknown>>>;
+export declare const SKILL_ROUTES: {
+    readonly list: {
+        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: OperationContext) => Promise<OperationResult<{
+            readonly skills: readonly import("../../skills.js").SkillManifest[];
+        }>>;
+    };
+    readonly load: {
+        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: OperationContext) => Promise<OperationResult<{
+            readonly metadata: import("../../skills.js").SkillManifest;
+            readonly body: string;
+            readonly resources: readonly string[];
+            readonly contentHash: string;
+            readonly sourceType: "bundled";
+        }>>;
+    };
+    readonly read: {
+        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: OperationContext) => Promise<OperationResult<{
+            readonly content: string;
+        }>>;
+    };
+};
+export declare const MODEL_ROUTES: {
+    readonly analyze: {
+        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 interpretations: {
+                    readonly type: "array";
+                    readonly maxItems: 3;
+                    readonly description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.";
+                    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 type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                    readonly default: "req";
+                    readonly description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.";
+                };
+                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: OperationContext) => Promise<import("../../../operations/semantic-advisor/types.js").SemanticAdvisorOperationResult>;
+    };
+    readonly requirement: {
+        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: '.kb/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", "gt", "gte", "lt", "lte", "neq", "bool", "polarity"];
+                    readonly description: "Optional extracted semantic claim operator. Use gt/lt for strict bounds ('greater than zero' is gt 0, not gte 0). 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: '.kb/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 requirementId: {
+                    readonly type: "string";
+                    readonly description: "Optional existing requirement ID to receive the requires_rule relationship.";
+                };
+                readonly claimKey: {
+                    readonly type: "string";
+                    readonly description: "Optional advisor-issued claim key for the exact proposition represented by logic.";
+                };
+                readonly claimText: {
+                    readonly type: "string";
+                    readonly description: "Optional exact proposition text represented by logic; defaults to text.";
+                };
+                readonly logic: {
+                    readonly type: "object";
+                    readonly description: "Optional typed kibi.logic.v1 IR. Kibi validates and canonicalizes it into a rule fact; raw Prolog is rejected.";
+                };
+            };
+        };
+        readonly requiresProlog: true;
+        readonly effects: readonly ["kb-read"];
+        readonly execute: typeof import("../../../operations/modeling/model-requirement.js").executeModelRequirement;
+    };
+    readonly predicates: {
+        readonly name: "kb_suggest_predicates";
+        readonly cliName: "suggest-predicates";
+        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"];
+            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 schemaId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "Optional exact reviewed predicate schema ID. When supplied, Kibi selects that schema instead of lexical rank order and fails closed if it is unavailable.";
+                };
+                readonly argumentBindings: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly description: "Optional exact predicate argument values keyed by a candidate schema's argument_names. Required before applying a candidate whose binding_status is incomplete; Kibi never substitutes guessed values for unbound arguments.";
+                };
+                readonly polarityHint: {
+                    readonly type: "string";
+                    readonly enum: readonly ["assert", "deny"];
+                    readonly description: "Optional reviewed polarity override for claims whose surface negation does not express predicate denial. Use only after reviewing the selected schema and full claim scope.";
+                };
+                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;
+    };
+};
+export declare const skillsSpec: {
+    readonly name: "kb_skills";
+    readonly cliName: "skill";
+    readonly description: "Read bundled Kibi agent skills (workflow guidance). action:list returns the catalog; action:load returns a skill's metadata, Markdown body, declared resources and content hash (start with id 'kibi-usage'); action:read returns one manifest-declared resource. Read-only; does not require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["action"];
+        readonly properties: {
+            readonly action: {
+                readonly type: "string";
+                readonly enum: readonly ["list", "load", "read"];
+                readonly description: "list, load (needs id) or read (needs id and resource).";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: (input: Readonly<Record<string, unknown>>, context: OperationContext) => Promise<OperationResult<Record<string, unknown>>>;
+};
+export declare const modelSpec: {
+    readonly name: "kb_model";
+    readonly cliName: "model";
+    readonly description: "Turn requirement prose into checkable structure without writing the KB. mode:analyze returns the semantic advisor receipt: the clause ledger, what is grounded, what is ambiguous and suggested modeling (pass clauses for compound prose and optional typed kibi.logic.v1 interpretations). mode:requirement converts one claim (subjectKey, propertyKey, operator, value, or typed logic) into a strict-lane write set and applyPlan. mode:predicates ranks ontology predicate schemas and returns an applicable predicate-fact plan only for reviewed bindings, otherwise an ontology-gap observation. Apply returned plans with kb_upsert.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["mode", "text"];
+        readonly properties: {
+            readonly mode: {
+                readonly type: "string";
+                readonly enum: readonly ["analyze", "requirement", "predicates"];
+                readonly description: "analyze (advisor receipt), requirement (strict claim write set) or predicates (ontology predicate plan).";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: (input: Readonly<Record<string, unknown>>, context: OperationContext) => Promise<OperationResult<Record<string, unknown>>>;
+};
+export {};
+//# sourceMappingURL=composite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/composite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAMlE;;;;;GAKG;AACH,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAkB9E,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAC3B,MAAM,EAAE,QAAQ,CACd,MAAM,CACJ,MAAM,EACN;IACE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjE,CACF,CACF,EACD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CA+BnD;AAGD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIf,CAAC;AAGX,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;CAqBW,CAAC;AAGnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;CAwBY,CAAC"}

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

@@ -0,0 +1,96 @@
+import { modelRequirementSpec, suggestPredicatesSpec } from "./modeling.js";
+import { semanticAdvisorSpec } from "./semantic.js";
+import { skillsListSpec, skillsLoadSpec, skillsReadSpec } from "./skills.js";
+function properties(spec) {
+    const props = spec.businessInputSchema.properties;
+    return props && typeof props === "object"
+        ? props
+        : {};
+}
+function requiredFields(spec) {
+    const required = spec.businessInputSchema.required;
+    return Array.isArray(required) ? required : [];
+}
+export async function dispatchComposite(selector, routes, input, context) {
+    const choice = input[selector];
+    const route = typeof choice === "string" ? routes[choice] : undefined;
+    if (route === undefined) {
+        throw new Error(`${selector} must be one of: ${Object.keys(routes).join(", ")}`);
+    }
+    const { [selector]: _selector, ...rest } = input;
+    for (const field of requiredFields(route)) {
+        if (rest[field] === undefined) {
+            throw new Error(`${field} is required when ${selector} is ${choice}`);
+        }
+    }
+    const result = await route.execute(rest, context);
+    // Routed executors return an OperationResult; host adapters may hand back
+    // the bare payload, which is used as-is.
+    const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+    const wrapped = isRecord(result) && ("structuredContent" in result || "content" in result);
+    const structured = wrapped ? result.structuredContent : result;
+    const payload = isRecord(structured) ? structured : {};
+    const content = wrapped && Array.isArray(result.content)
+        ? result.content
+        : [{ type: "text", text: `${selector} ${String(choice)} completed` }];
+    return {
+        content,
+        structuredContent: { [selector]: choice, ...payload },
+    };
+}
+// implements REQ-kibi-mcp-tool-consolidation
+export const SKILL_ROUTES = {
+    list: skillsListSpec,
+    load: skillsLoadSpec,
+    read: skillsReadSpec,
+};
+// implements REQ-kibi-mcp-tool-consolidation
+export const MODEL_ROUTES = {
+    analyze: semanticAdvisorSpec,
+    requirement: modelRequirementSpec,
+    predicates: suggestPredicatesSpec,
+};
+// implements REQ-kibi-mcp-tool-consolidation
+export const skillsSpec = {
+    name: "kb_skills",
+    cliName: "skill",
+    description: "Read bundled Kibi agent skills (workflow guidance). action:list returns the catalog; action:load returns a skill's metadata, Markdown body, declared resources and content hash (start with id 'kibi-usage'); action:read returns one manifest-declared resource. Read-only; does not require Prolog.",
+    businessInputSchema: {
+        type: "object",
+        required: ["action"],
+        properties: {
+            action: {
+                type: "string",
+                enum: ["list", "load", "read"],
+                description: "list, load (needs id) or read (needs id and resource).",
+            },
+            ...properties(skillsReadSpec),
+        },
+    },
+    requiresProlog: false,
+    effects: ["local-read"],
+    execute: (input, context) => dispatchComposite("action", SKILL_ROUTES, input, context),
+};
+// implements REQ-kibi-mcp-tool-consolidation
+export const modelSpec = {
+    name: "kb_model",
+    cliName: "model",
+    description: "Turn requirement prose into checkable structure without writing the KB. mode:analyze returns the semantic advisor receipt: the clause ledger, what is grounded, what is ambiguous and suggested modeling (pass clauses for compound prose and optional typed kibi.logic.v1 interpretations). mode:requirement converts one claim (subjectKey, propertyKey, operator, value, or typed logic) into a strict-lane write set and applyPlan. mode:predicates ranks ontology predicate schemas and returns an applicable predicate-fact plan only for reviewed bindings, otherwise an ontology-gap observation. Apply returned plans with kb_upsert.",
+    businessInputSchema: {
+        type: "object",
+        required: ["mode", "text"],
+        properties: {
+            mode: {
+                type: "string",
+                enum: ["analyze", "requirement", "predicates"],
+                description: "analyze (advisor receipt), requirement (strict claim write set) or predicates (ontology predicate plan).",
+            },
+            ...properties(semanticAdvisorSpec),
+            ...properties(suggestPredicatesSpec),
+            ...properties(modelRequirementSpec),
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: (input, context) => dispatchComposite("mode", MODEL_ROUTES, input, context),
+};

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

@@ -46,7 +46,7 @@ export declare const querySpec: {
 export declare const searchSpec: {
     readonly name: "kb_search";
     readonly cliName: "search";
-    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 description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -77,8 +77,13 @@ export declare const searchSpec: {
             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 default: "intent-v1";
+                readonly description: "Optional deterministic ranking mode. Default intent-v1: question-aware ranking with semantic facets, source-aware evidence, graph boosts, superseded demotion and abstention. Use legacy for the older lexical ranking.";
+            };
+            readonly answer: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.";
             };
             readonly semanticFacets: {
                 readonly type: "object";

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

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

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

@@ -54,7 +54,7 @@ export const querySpec = {
 export const searchSpec = {
     name: "kb_search",
     cliName: "search",
-    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.",
+    description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["query"],
@@ -85,8 +85,13 @@ export const searchSpec = {
             rankingMode: {
                 type: "string",
                 enum: ["legacy", "intent-v1"],
-                default: "legacy",
-                description: "Optional deterministic ranking mode. Omit for backward-compatible lexical search; use intent-v1 for semantic facets, source-aware evidence, graph boosts, and abstention.",
+                default: "intent-v1",
+                description: "Optional deterministic ranking mode. Default intent-v1: question-aware ranking with semantic facets, source-aware evidence, graph boosts, superseded demotion and abstention. Use legacy for the older lexical ranking.",
+            },
+            answer: {
+                type: "boolean",
+                default: true,
+                description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.",
             },
             semanticFacets: {
                 type: "object",

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

@@ -40,8 +40,8 @@ export declare const modelRequirementSpec: {
             };
             readonly operator: {
                 readonly type: "string";
-                readonly enum: readonly ["eq", "gte", "lte", "neq", "bool", "polarity"];
-                readonly description: "Optional extracted semantic claim operator. Example: 'eq'.";
+                readonly enum: readonly ["eq", "gt", "gte", "lt", "lte", "neq", "bool", "polarity"];
+                readonly description: "Optional extracted semantic claim operator. Use gt/lt for strict bounds ('greater than zero' is gt 0, not gte 0). Example: 'eq'.";
             };
             readonly value: {
                 readonly description: "Optional extracted semantic claim value. Accepts string, number, or boolean.";

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

@@ -38,8 +38,8 @@ export const modelRequirementSpec = {
             },
             operator: {
                 type: "string",
-                enum: ["eq", "gte", "lte", "neq", "bool", "polarity"],
-                description: "Optional extracted semantic claim operator. Example: 'eq'.",
+                enum: ["eq", "gt", "gte", "lt", "lte", "neq", "bool", "polarity"],
+                description: "Optional extracted semantic claim operator. Use gt/lt for strict bounds ('greater than zero' is gt 0, not gte 0). Example: 'eq'.",
             },
             value: {
                 description: "Optional extracted semantic claim value. Accepts string, number, or boolean.",