kibi-cli 2.3.0 → 2.5.0

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

@@ -4,7 +4,7 @@ export { executePlanBootstrap } from "../../../operations/bootstrap/generate.js"
 export declare const planBootstrapSpec: {
     readonly name: "kb_plan_bootstrap";
     readonly cliName: "plan-bootstrap";
-    readonly description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.";
+    readonly description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis of the repository plus any declared knowledge sources and cited intent claims returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -71,6 +71,78 @@ export declare const planBootstrapSpec: {
                         };
                         readonly description: "Optional verification commands, documents, or checkpoints to reference in the output.";
                     };
+                    readonly knowledgeSources: {
+                        readonly type: "array";
+                        readonly maxItems: 50;
+                        readonly description: "Knowledge sources outside the code that the human confirmed during the bootstrap interview (issue trackers, wikis, specs, decision logs). Kibi never contacts them; the agent reads them through its own connectors and cites them from intentClaims. Bound into the plan hash.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["id", "kind", "title", "locator", "authority"];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-z0-9][a-z0-9-]*$";
+                                    readonly description: "Stable kebab-case handle that intentClaims cite, for example jira-payments.";
+                                };
+                                readonly kind: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["issue_tracker", "wiki", "specification", "design", "decision_log", "support", "chat", "repository_docs", "other"];
+                                };
+                                readonly title: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly locator: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Where the source lives: a URL, project key, space name, or repo-relative path.";
+                                };
+                                readonly authority: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["authoritative", "supporting", "stale"];
+                                    readonly description: "The human's call: authoritative claims become higher-confidence candidates, supporting claims lower ones, and stale sources are cited but never produce candidates.";
+                                };
+                                readonly connector: {
+                                    readonly type: "string";
+                                    readonly description: "Optional name of the MCP server or tool the agent used to read the source.";
+                                };
+                                readonly notes: {
+                                    readonly type: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly intentClaims: {
+                        readonly type: "array";
+                        readonly maxItems: 200;
+                        readonly description: "Statements of product intent the agent harvested from knowledgeSources, each citing its source. Normative claims the strict modeler can ground become cited req candidates; the rest become explicit authoring follow-ups. Bound into the plan hash.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["statement", "sourceId", "reference"];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly statement: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "One normative statement in the source's meaning, for example 'Refunds must not exceed the original charge.'";
+                                };
+                                readonly sourceId: {
+                                    readonly type: "string";
+                                    readonly description: "The id of a declared knowledge source.";
+                                };
+                                readonly reference: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                    readonly description: "Exact citation inside the source: a ticket key, page URL, or section anchor.";
+                                };
+                                readonly excerpt: {
+                                    readonly type: "string";
+                                    readonly description: "Optional short quote supporting the claim.";
+                                };
+                            };
+                        };
+                    };
                 };
             };
         };

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

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAOjF,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF7B,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AASjF,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2J7B,CAAC"}

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

@@ -1,10 +1,11 @@
 import { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
+import { KNOWLEDGE_SOURCE_AUTHORITIES, KNOWLEDGE_SOURCE_KINDS, } from "../../../operations/bootstrap/types.js";
 export { executePlanBootstrap } from "../../../operations/bootstrap/generate.js";
 // implements REQ-KIBI-BOOTSTRAP-PLAN
 export const planBootstrapSpec = {
     name: "kb_plan_bootstrap",
     cliName: "plan-bootstrap",
-    description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.",
+    description: "Generate a deterministic, snapshot-bound kibi.bootstrap-plan.v1 for repository onboarding. Read-only analysis of the repository plus any declared knowledge sources and cited intent claims returns evidence, bounded context questions, exact dependency-ordered actions, a canonical plan hash, and no mutation side effects.",
     businessInputSchema: {
         type: "object",
         properties: {
@@ -63,6 +64,70 @@ export const planBootstrapSpec = {
                         items: { type: "string" },
                         description: "Optional verification commands, documents, or checkpoints to reference in the output.",
                     },
+                    knowledgeSources: {
+                        type: "array",
+                        maxItems: 50,
+                        description: "Knowledge sources outside the code that the human confirmed during the bootstrap interview (issue trackers, wikis, specs, decision logs). Kibi never contacts them; the agent reads them through its own connectors and cites them from intentClaims. Bound into the plan hash.",
+                        items: {
+                            type: "object",
+                            required: ["id", "kind", "title", "locator", "authority"],
+                            additionalProperties: false,
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    pattern: "^[a-z0-9][a-z0-9-]*$",
+                                    description: "Stable kebab-case handle that intentClaims cite, for example jira-payments.",
+                                },
+                                kind: { type: "string", enum: [...KNOWLEDGE_SOURCE_KINDS] },
+                                title: { type: "string", minLength: 1 },
+                                locator: {
+                                    type: "string",
+                                    minLength: 1,
+                                    description: "Where the source lives: a URL, project key, space name, or repo-relative path.",
+                                },
+                                authority: {
+                                    type: "string",
+                                    enum: [...KNOWLEDGE_SOURCE_AUTHORITIES],
+                                    description: "The human's call: authoritative claims become higher-confidence candidates, supporting claims lower ones, and stale sources are cited but never produce candidates.",
+                                },
+                                connector: {
+                                    type: "string",
+                                    description: "Optional name of the MCP server or tool the agent used to read the source.",
+                                },
+                                notes: { type: "string" },
+                            },
+                        },
+                    },
+                    intentClaims: {
+                        type: "array",
+                        maxItems: 200,
+                        description: "Statements of product intent the agent harvested from knowledgeSources, each citing its source. Normative claims the strict modeler can ground become cited req candidates; the rest become explicit authoring follow-ups. Bound into the plan hash.",
+                        items: {
+                            type: "object",
+                            required: ["statement", "sourceId", "reference"],
+                            additionalProperties: false,
+                            properties: {
+                                statement: {
+                                    type: "string",
+                                    minLength: 1,
+                                    description: "One normative statement in the source's meaning, for example 'Refunds must not exceed the original charge.'",
+                                },
+                                sourceId: {
+                                    type: "string",
+                                    description: "The id of a declared knowledge source.",
+                                },
+                                reference: {
+                                    type: "string",
+                                    minLength: 1,
+                                    description: "Exact citation inside the source: a ticket key, page URL, or section anchor.",
+                                },
+                                excerpt: {
+                                    type: "string",
+                                    description: "Optional short quote supporting the claim.",
+                                },
+                            },
+                        },
+                    },
                 },
             },
         },

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"}