kibi-cli 0.16.1 → 0.17.0

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

@@ -21,11 +21,39 @@ export declare const semanticAdvisorSpec: {
                 };
                 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"];
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
                 readonly default: "req";
-                readonly description: "Entity type context for analysis. Currently requirement prose is supported.";
+                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";

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

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA2BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAuBzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDE,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA8BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}

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

@@ -28,6 +28,9 @@ export async function executeSemanticAdvisor(args, _context) {
             },
         },
         ...(args.clauses !== undefined ? { clauses: args.clauses } : {}),
+        ...(args.interpretations !== undefined
+            ? { interpretations: args.interpretations }
+            : {}),
     });
     return {
         content: [
@@ -48,6 +51,9 @@ async function executeSemanticAdvisorInput(input, context) {
     const clauses = Array.isArray(input.clauses)
         ? input.clauses.filter((value) => typeof value === "string")
         : undefined;
+    const interpretations = Array.isArray(input.interpretations)
+        ? input.interpretations.filter((value) => typeof value === "object" && value !== null)
+        : undefined;
     return executeSemanticAdvisor({
         text: requiredText(input.text),
         ...(type ? { type } : {}),
@@ -56,6 +62,7 @@ async function executeSemanticAdvisorInput(input, context) {
         ...(source ? { source } : {}),
         ...(status ? { status } : {}),
         ...(clauses !== undefined ? { clauses } : {}),
+        ...(interpretations !== undefined ? { interpretations } : {}),
     }, context);
 }
 export const semanticAdvisorSpec = {
@@ -75,11 +82,36 @@ export const semanticAdvisorSpec = {
                 items: { type: "string" },
                 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.",
             },
+            interpretations: {
+                type: "array",
+                maxItems: 3,
+                description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.",
+                items: {
+                    type: "object",
+                    required: ["claim_key", "claim_text", "ir"],
+                    properties: {
+                        claim_key: { type: "string" },
+                        claim_text: { type: "string" },
+                        confidence: { type: "number", minimum: 0, maximum: 1 },
+                        span: { type: "object" },
+                        ir: { type: "object" },
+                    },
+                },
+            },
             type: {
                 type: "string",
-                enum: ["req"],
+                enum: [
+                    "req",
+                    "scenario",
+                    "test",
+                    "adr",
+                    "flag",
+                    "event",
+                    "symbol",
+                    "fact",
+                ],
                 default: "req",
-                description: "Entity type context for analysis. Currently requirement prose is supported.",
+                description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.",
             },
             id: {
                 type: "string",

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

@@ -98,7 +98,7 @@ export declare const upsertSpec: {
                     };
                     readonly fact_kind: {
                         readonly type: "string";
-                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate"];
+                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate", "rule_schema", "rule"];
                         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: {
@@ -220,6 +220,41 @@ export declare const upsertSpec: {
                         };
                         readonly description: "Optional ground-term examples for a predicate schema.";
                     };
+                    readonly semantic_inventory: {
+                        readonly type: "array";
+                        readonly description: "Requirement proposition ledger returned by kb_semantic_advisor; preserve entries while modeling each assertive span.";
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                    readonly rule_ir: {
+                        readonly type: "object";
+                        readonly description: "Schema-validated kibi.logic.v1 rule IR. It is persisted as data and never executed as caller-supplied Prolog.";
+                    };
+                    readonly rule_hash: {
+                        readonly type: "string";
+                        readonly description: "Deterministic hash of canonical rule_ir.";
+                    };
+                    readonly rule_schema_id: {
+                        readonly type: "string";
+                        readonly description: "Rule schema fact ID used to validate this rule.";
+                    };
+                    readonly rule_name: {
+                        readonly type: "string";
+                        readonly description: "Stable rule schema name.";
+                    };
+                    readonly semantic_key: {
+                        readonly type: "string";
+                        readonly description: "Canonical semantic identity of the normalized logical model.";
+                    };
+                    readonly claim_span_start: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly claim_span_end: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
                 };
                 readonly allOf: readonly [Record<string, unknown>];
                 readonly required: readonly ["title", "status"];
@@ -233,7 +268,7 @@ export declare const upsertSpec: {
                     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 enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "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: {

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

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,CAAC"}

package/dist/public/schemas/entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AA4FA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAsMzC,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAuTA,QAAA,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAmRzC,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/public/schemas/entity.js

@@ -59,6 +59,30 @@ const factConditionals = JSON.parse(`[
       }
     }
   },
+  {
+    "if": {
+      "properties": {
+        "type": { "const": "fact" },
+        "fact_kind": { "const": "rule_schema" }
+      },
+      "required": ["type", "fact_kind"]
+    },
+    "then": {
+      "required": ["rule_name", "argument_names", "argument_types"]
+    }
+  },
+  {
+    "if": {
+      "properties": {
+        "type": { "const": "fact" },
+        "fact_kind": { "const": "rule" }
+      },
+      "required": ["type", "fact_kind"]
+    },
+    "then": {
+      "required": ["rule_ir", "rule_hash", "rule_schema_id", "rule_name", "semantic_key"]
+    }
+  },
   {
     "if": {
       "properties": {
@@ -74,10 +98,205 @@ const factConditionals = JSON.parse(`[
     }
   }
 ]`);
+// The persisted rule payload is still data, but its shape is constrained at
+// the JSON boundary as well as by validateLogicIr.  Keeping this vocabulary
+// closed prevents a raw_goal/raw Prolog field from entering an upsert payload.
+const logicTermSchema = {
+    oneOf: [
+        {
+            type: "object",
+            required: ["kind", "name", "type"],
+            properties: {
+                kind: { const: "var" },
+                name: { type: "string", pattern: "^[A-Z][A-Za-z0-9_]*$" },
+                type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "const" },
+                value: { type: "string", minLength: 1 },
+                type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "number" },
+                value: { type: "number" },
+                unit: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value", "unit"],
+            properties: {
+                kind: { const: "duration" },
+                value: { type: "number", minimum: 0 },
+                unit: { type: "string", enum: ["ms", "s", "m", "h", "d", "w"] },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "value"],
+            properties: {
+                kind: { const: "timestamp" },
+                value: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "start", "end"],
+            properties: {
+                kind: { const: "interval" },
+                start: { type: "string" },
+                end: { type: "string" },
+            },
+            additionalProperties: false,
+        },
+    ],
+};
+const logicAtomSchema = {
+    type: "object",
+    required: ["kind", "name", "args"],
+    properties: {
+        kind: { const: "atom" },
+        namespace: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+        name: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+        args: {
+            type: "array",
+            maxItems: 8,
+            items: { $ref: "#/$defs/logicTerm" },
+        },
+        polarity: { enum: ["positive", "negative"] },
+        closedWorld: { type: "boolean" },
+    },
+    additionalProperties: false,
+};
+const logicExpressionSchema = {
+    oneOf: [
+        { $ref: "#/$defs/logicAtom" },
+        {
+            type: "object",
+            required: ["kind", "items"],
+            properties: {
+                kind: { enum: ["all", "any"] },
+                items: {
+                    type: "array",
+                    minItems: 1,
+                    maxItems: 32,
+                    items: { $ref: "#/$defs/logicExpression" },
+                },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "item"],
+            properties: {
+                kind: { const: "not" },
+                item: { $ref: "#/$defs/logicAtom" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "operator", "left", "right"],
+            properties: {
+                kind: { const: "compare" },
+                operator: { enum: ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                left: { $ref: "#/$defs/logicTerm" },
+                right: { $ref: "#/$defs/logicTerm" },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "atom", "operator", "value"],
+            properties: {
+                kind: { const: "count" },
+                atom: { $ref: "#/$defs/logicAtom" },
+                operator: { enum: ["eq", "neq", "lt", "lte", "gt", "gte"] },
+                value: { type: "integer", minimum: 0 },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            required: ["kind", "relation", "left", "right"],
+            properties: {
+                kind: { const: "temporal" },
+                relation: {
+                    enum: ["before", "after", "during", "overlaps", "starts", "finishes"],
+                },
+                left: { $ref: "#/$defs/logicTerm" },
+                right: { $ref: "#/$defs/logicTerm" },
+            },
+            additionalProperties: false,
+        },
+    ],
+};
+const logicRuleSchema = {
+    type: "object",
+    required: ["version", "kind", "modality"],
+    properties: {
+        version: { const: "kibi.logic.v1" },
+        kind: { enum: ["atom", "rule", "constraint"] },
+        modality: { enum: ["assert", "deny", "oblige", "permit", "forbid"] },
+        head: { $ref: "#/$defs/logicAtom" },
+        body: { $ref: "#/$defs/logicExpression" },
+        variables: {
+            type: "array",
+            maxItems: 32,
+            items: {
+                type: "object",
+                required: ["name", "type"],
+                properties: {
+                    name: { type: "string", pattern: "^[A-Z][A-Za-z0-9_]*$" },
+                    type: { type: "string", pattern: "^[a-z][a-z0-9_:.\\/-]*$" },
+                    quantifier: { enum: ["forall", "exists"] },
+                },
+                additionalProperties: false,
+            },
+        },
+        exceptions: {
+            type: "array",
+            maxItems: 16,
+            items: { $ref: "#/$defs/logicExpression" },
+        },
+        scope: {
+            type: "object",
+            properties: {
+                authority: { type: "string" },
+                name: { type: "string" },
+                tags: { type: "array", items: { type: "string" } },
+            },
+            additionalProperties: false,
+        },
+        validFrom: { type: "string" },
+        validTo: { type: "string" },
+        ruleSchemaId: { type: "string", minLength: 1 },
+    },
+    additionalProperties: false,
+};
 const entitySchema = {
     $id: "entity.schema.json",
     title: "Entity",
     type: "object",
+    $defs: {
+        logicTerm: logicTermSchema,
+        logicAtom: logicAtomSchema,
+        logicExpression: logicExpressionSchema,
+        logicRule: logicRuleSchema,
+    },
     properties: {
         id: { type: "string" },
         title: { type: "string" },
@@ -120,6 +339,53 @@ const entitySchema = {
             uniqueItems: true,
             items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
         },
+        semantic_inventory: {
+            type: "array",
+            items: {
+                type: "object",
+                required: ["claim_key", "claim_text", "role", "status", "span"],
+                properties: {
+                    claim_key: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+                    claim_text: { type: "string", minLength: 1 },
+                    role: {
+                        type: "string",
+                        enum: [
+                            "normative",
+                            "definition",
+                            "descriptive",
+                            "condition",
+                            "exception",
+                            "rationale",
+                            "example",
+                            "subjective",
+                        ],
+                    },
+                    status: {
+                        type: "string",
+                        enum: [
+                            "modeled",
+                            "ambiguous",
+                            "ontology_gap",
+                            "nonlogical",
+                            "missing",
+                        ],
+                    },
+                    span: {
+                        type: "object",
+                        required: ["start", "end"],
+                        properties: {
+                            start: { type: "integer", minimum: 0 },
+                            end: { type: "integer", minimum: 0 },
+                        },
+                        additionalProperties: false,
+                    },
+                    semantic_key: { type: "string" },
+                    payload_hash: { type: "string" },
+                    reason: { type: "string" },
+                },
+                additionalProperties: false,
+            },
+        },
         sourceFile: { type: "string" },
         granularity_reason: {
             type: "string",
@@ -165,6 +431,8 @@ const entitySchema = {
                 "meta",
                 "predicate_schema",
                 "predicate",
+                "rule_schema",
+                "rule",
             ],
         },
         subject_key: { type: "string" },
@@ -196,6 +464,13 @@ const entitySchema = {
         aliases: { type: "array", items: { type: "string" } },
         examples: { type: "array", items: { type: "string" } },
         predicate_args: { type: "array", items: { type: "string" } },
+        rule_ir: { $ref: "#/$defs/logicRule" },
+        rule_hash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+        rule_schema_id: { type: "string", minLength: 1 },
+        rule_name: { type: "string", minLength: 1 },
+        semantic_key: { type: "string", pattern: "^SEM-[A-F0-9]{24}$" },
+        claim_span_start: { type: "integer", minimum: 0 },
+        claim_span_end: { type: "integer", minimum: 0 },
     },
     required: [
         "id",
@@ -252,6 +527,13 @@ const entitySchema = {
                         { required: ["aliases"] },
                         { required: ["examples"] },
                         { required: ["predicate_args"] },
+                        { required: ["rule_ir"] },
+                        { required: ["rule_hash"] },
+                        { required: ["rule_schema_id"] },
+                        { required: ["rule_name"] },
+                        { required: ["semantic_key"] },
+                        { required: ["claim_span_start"] },
+                        { required: ["claim_span_end"] },
                     ],
                 },
             },
@@ -269,6 +551,14 @@ const entitySchema = {
                 },
             },
         },
+        {
+            if: {
+                properties: { type: { const: "req" } },
+            },
+            else: {
+                not: { required: ["semantic_inventory"] },
+            },
+        },
         ...factConditionals,
     ],
     additionalProperties: false,

package/dist/public/schemas/relationship.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/public/schemas/relationship.js

@@ -34,6 +34,7 @@ const relationshipSchema = {
                 "constrains",
                 "requires_property",
                 "requires_predicate",
+                "requires_rule",
                 "guards",
                 "publishes",
                 "consumes",