kibi-cli 2.3.0 → 2.5.0

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.",

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -45,6 +45,36 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             readonly type: "string";
             readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
         };
+        readonly origin: {
+            readonly description: "Optional provenance: who authored the entity (kind: human, agent, migration, import) and on what authority (ref, approved_by, recorded_at). Omit it to keep an existing entity's origin; a new entity written without one is recorded as {kind: agent, recorded_at: <write time>}. A supplied origin without recorded_at gets the write time.";
+            readonly type: "object";
+            readonly required: readonly ["kind"];
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["human", "agent", "migration", "import"];
+                    readonly description: "Who authored the entity: human, agent, migration (backfilled by kibi migrate) or import.";
+                };
+                readonly ref: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly pattern: "\\S";
+                    readonly description: "Source reference for the authored content: URL, document path, ticket, commit or conversation id.";
+                };
+                readonly approved_by: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly pattern: "\\S";
+                    readonly description: "The person who reviewed and approved this entity's content. Distinct from the requirement-level approved_by of an exception.";
+                };
+                readonly recorded_at: {
+                    readonly type: "string";
+                    readonly pattern: "^\\d{4}-\\d{2}-\\d{2}(?:[T ]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?(?:Z|[+-]\\d{2}:?\\d{2})?)?$";
+                    readonly description: "ISO-8601 time the provenance was recorded.";
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly semantic_text: {
             readonly type: "string";
             readonly description: "Requirement-only authored prose used for semantic inventory hashes and UTF-8 spans. Keep text_ref available for independent document or code evidence.";
@@ -57,7 +87,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 readonly type: "string";
                 readonly pattern: "^CLAIM-[A-F0-9]{16}$";
             };
-            readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
+            readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_model mode analyze (CLI: semantic-advisor). A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
         };
         readonly semantic_clauses: {
             readonly type: "array";
@@ -66,18 +96,43 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 readonly type: "string";
                 readonly minLength: 1;
             };
-            readonly description: "Optional complete atomic decomposition used by kb_semantic_advisor and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.";
+            readonly description: "Optional complete atomic decomposition used by kb_model mode analyze and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.";
         };
         readonly semantic_inventory_version: {
             readonly type: "string";
             readonly const: "kibi.semantic-inventory.v1";
-            readonly description: "Requirement-only proposition ledger contract version returned by kb_semantic_advisor.";
+            readonly description: "Requirement-only proposition ledger contract version returned by kb_model mode analyze (CLI: semantic-advisor).";
         };
         readonly semantic_source_field: {
             readonly type: "string";
             readonly enum: readonly ["semantic_text", "text_ref", "title"];
             readonly description: "Requirement field whose exact UTF-8 bytes anchor semantic_inventory spans.";
         };
+        readonly approved_by: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Requirement-only. The human who approved this exception requirement. An exception that exempts a requirement and is specified_by a success scenario makes that scenario feasible only when approved_by is set.";
+        };
+        readonly approval_ref: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Requirement-only. Optional reference to the exception's approval decision record.";
+        };
+        readonly rationale: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly description: "Requirement-only. Why the requirement exists, in one or two sentences from whoever stated the intent; not part of the checked meaning.";
+        };
+        readonly exempts_claims: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+            };
+            readonly description: "Requirement-only. Claim keys of the exempted requirement whose constraints this exception waives; omit to waive the whole requirement.";
+        };
         readonly semantic_source_hash: {
             readonly type: "string";
             readonly pattern: "^[a-f0-9]{64}$";
@@ -407,7 +462,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
         readonly fact_kind: {
             readonly type: "string";
             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 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 (mode requirement or predicates) when starting from prose.";
         };
         readonly subject_key: {
             readonly type: "string";
@@ -475,14 +530,14 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
         };
         readonly predicate_name: {
             readonly type: "string";
-            readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.";
+            readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_name.";
         };
         readonly predicate_args: {
             readonly type: "array";
             readonly items: {
                 readonly type: "string";
             };
-            readonly description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.";
+            readonly description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_args.";
         };
         readonly predicate_namespace: {
             readonly type: "string";
@@ -514,6 +569,16 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
             };
             readonly description: "Optional ordered argument explanations.";
         };
+        readonly key_arguments: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly description: "predicate_schema only: argument names that determine the remaining arguments (a functional dependency), e.g. [\"sensor\"] for reading(sensor, value). Rule contradiction analysis treats two atoms with identical keys as the same fact; without it the predicate is multivalued and opposing rules stay unresolved instead of disjoint.";
+        };
         readonly argument_constants: {
             readonly type: "object";
             readonly additionalProperties: {
@@ -553,7 +618,7 @@ export declare const ENTITY_PROPERTIES_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 description: "Requirement proposition ledger returned by kb_model mode analyze (CLI: semantic-advisor); preserve entries while modeling each assertive span.";
             readonly items: {
                 readonly type: "object";
             };
@@ -606,7 +671,7 @@ export declare const RELATIONSHIPS_SCHEMA: {
         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", "requires_rule", "guards", "publishes", "consumes", "supersedes", "restates", "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", "restates", "assumes", "exempts", "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/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6U3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA4CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoX3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}

package/dist/public/operations/specs/mutation-schemas.js

@@ -1,3 +1,4 @@
+import { ENTITY_ORIGIN_SCHEMA } from "../../entity-origin.js";
 import { PROOF_BINDINGS_SCHEMA, PROOF_CONTRACT_SCHEMA, } from "../../proof-protocol.js";
 import { MAX_PROOF_RECEIPTS, PROOF_RECEIPT_SCHEMA, } from "../../proof-receipt.js";
 export const ENTITY_TYPES = [
@@ -61,6 +62,10 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             type: "string",
             description: "Optional text anchor/reference. Example: 'requirements.md#L40'.",
         },
+        origin: {
+            ...ENTITY_ORIGIN_SCHEMA,
+            description: "Optional provenance: who authored the entity (kind: human, agent, migration, import) and on what authority (ref, approved_by, recorded_at). Omit it to keep an existing entity's origin; a new entity written without one is recorded as {kind: agent, recorded_at: <write time>}. A supplied origin without recorded_at gets the write time.",
+        },
         semantic_text: {
             type: "string",
             description: "Requirement-only authored prose used for semantic inventory hashes and UTF-8 spans. Keep text_ref available for independent document or code evidence.",
@@ -70,24 +75,46 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             minItems: 1,
             uniqueItems: true,
             items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
-            description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.",
+            description: "Requirement-only manifest of every atomic normative claim key returned by kb_model mode analyze (CLI: semantic-advisor). A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.",
         },
         semantic_clauses: {
             type: "array",
             minItems: 1,
             items: { type: "string", minLength: 1 },
-            description: "Optional complete atomic decomposition used by kb_semantic_advisor and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.",
+            description: "Optional complete atomic decomposition used by kb_model mode analyze and proposition-complete ingestion. Preserve it when automatic sentence splitting needs a reviewed override.",
         },
         semantic_inventory_version: {
             type: "string",
             const: "kibi.semantic-inventory.v1",
-            description: "Requirement-only proposition ledger contract version returned by kb_semantic_advisor.",
+            description: "Requirement-only proposition ledger contract version returned by kb_model mode analyze (CLI: semantic-advisor).",
         },
         semantic_source_field: {
             type: "string",
             enum: ["semantic_text", "text_ref", "title"],
             description: "Requirement field whose exact UTF-8 bytes anchor semantic_inventory spans.",
         },
+        approved_by: {
+            type: "string",
+            minLength: 1,
+            description: "Requirement-only. The human who approved this exception requirement. An exception that exempts a requirement and is specified_by a success scenario makes that scenario feasible only when approved_by is set.",
+        },
+        approval_ref: {
+            type: "string",
+            minLength: 1,
+            description: "Requirement-only. Optional reference to the exception's approval decision record.",
+        },
+        rationale: {
+            type: "string",
+            minLength: 1,
+            description: "Requirement-only. Why the requirement exists, in one or two sentences from whoever stated the intent; not part of the checked meaning.",
+        },
+        exempts_claims: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+            description: "Requirement-only. Claim keys of the exempted requirement whose constraints this exception waives; omit to waive the whole requirement.",
+        },
         semantic_source_hash: {
             type: "string",
             pattern: "^[a-f0-9]{64}$",
@@ -156,7 +183,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
                 "rule_schema",
                 "rule",
             ],
-            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.",
+            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 (mode requirement or predicates) when starting from prose.",
         },
         subject_key: {
             type: "string",
@@ -224,12 +251,12 @@ export const ENTITY_PROPERTIES_SCHEMA = {
         },
         predicate_name: {
             type: "string",
-            description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.",
+            description: "Optional predicate name for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_name.",
         },
         predicate_args: {
             type: "array",
             items: { type: "string" },
-            description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.",
+            description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_model mode predicates before hand-writing predicate_args.",
         },
         predicate_namespace: {
             type: "string",
@@ -255,6 +282,13 @@ export const ENTITY_PROPERTIES_SCHEMA = {
             items: { type: "string" },
             description: "Optional ordered argument explanations.",
         },
+        key_arguments: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            uniqueItems: true,
+            description: 'predicate_schema only: argument names that determine the remaining arguments (a functional dependency), e.g. ["sensor"] for reading(sensor, value). Rule contradiction analysis treats two atoms with identical keys as the same fact; without it the predicate is multivalued and opposing rules stay unresolved instead of disjoint.',
+        },
         argument_constants: {
             type: "object",
             additionalProperties: {
@@ -284,7 +318,7 @@ export const ENTITY_PROPERTIES_SCHEMA = {
         },
         semantic_inventory: {
             type: "array",
-            description: "Requirement proposition ledger returned by kb_semantic_advisor; preserve entries while modeling each assertive span.",
+            description: "Requirement proposition ledger returned by kb_model mode analyze (CLI: semantic-advisor); preserve entries while modeling each assertive span.",
             items: { type: "object" },
         },
         rule_ir: {
@@ -344,6 +378,8 @@ export const RELATIONSHIPS_SCHEMA = {
                     "consumes",
                     "supersedes",
                     "restates",
+                    "assumes",
+                    "exempts",
                     "relates_to",
                 ],
                 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).",

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

@@ -4,7 +4,7 @@ export { upsertSpec } from "./upsert.js";
 export declare const validateUpsertSpec: {
     readonly name: "kb_validate_upsert";
     readonly cliName: "validate-upsert";
-    readonly description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model_requirement, kb_suggest_predicates, ambiguity review, or an ontology-gap observation.";
+    readonly description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model mode requirement or predicates, ambiguity review, or an ontology-gap observation.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["type", "id", "properties"];

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

@@ -5,7 +5,7 @@ export { upsertSpec } from "./upsert.js";
 export const validateUpsertSpec = {
     name: "kb_validate_upsert",
     cliName: "validate-upsert",
-    description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model_requirement, kb_suggest_predicates, ambiguity review, or an ontology-gap observation.",
+    description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model mode requirement or predicates, ambiguity review, or an ontology-gap observation.",
     businessInputSchema: {
         type: "object",
         required: ["type", "id", "properties"],

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

@@ -228,7 +228,7 @@ export declare const compileIntentSpec: {
 export declare const applyPlanSpec: {
     readonly name: "kb_apply_plan";
     readonly cliName: "apply-plan";
-    readonly description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.";
+    readonly description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Compile plans apply all-or-nothing: a durable journal records every source write and store mutation before the first write, all steps commit in one store transaction, and an interrupted application is completed or rolled back by the next mutating call. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly oneOf: readonly [{
@@ -268,7 +268,7 @@ export declare const applyPlanSpec: {
             readonly recoveryJournalId: {
                 readonly type: "string";
                 readonly pattern: "^[A-Za-z0-9._-]+$";
-                readonly description: "Typed recovery journal identifier returned by a committed_with_repairs result. Recovery replays only the immutable journal and never the original plan request.";
+                readonly description: "Typed recovery journal identifier returned by a committed_with_repairs result or a PLAN_APPLY_RECOVERY_REQUIRED error. Recovery replays only the immutable journal and never the original plan request; a compile-plan journal (plan-apply-*) is completed or rolled back deterministically and reports which.";
             };
         };
     };

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

@@ -2,7 +2,7 @@ import { executeApplyPlan, } from "../../../operations/planning/apply-plan.js";
 import { executeCompileIntent, } from "../../../operations/planning/compile-intent.js";
 export { executeApplyPlan } from "../../../operations/planning/apply-plan.js";
 export { executeCompileIntent } from "../../../operations/planning/compile-intent.js";
-// implements REQ-kibi-change-to-proof-plan-compiler
+// implements REQ-kibi-change-to-proof-plan-compiler-v2
 export const compileIntentSpec = {
     name: "kb_compile_intent",
     cliName: "compile-intent",
@@ -145,11 +145,11 @@ export const compileIntentSpec = {
     effects: ["kb-read", "workspace-read"],
     execute: executeCompileIntent,
 };
-// implements REQ-kibi-change-to-proof-plan-compiler
+// implements REQ-kibi-change-to-proof-plan-compiler-v2
 export const applyPlanSpec = {
     name: "kb_apply_plan",
     cliName: "apply-plan",
-    description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.",
+    description: "Apply an explicitly approved kibi.bootstrap-plan.v1, kibi.compile-plan.v1, kibi.migration-plan.v2, or entity-deletion plan after revalidating its canonical hash and live snapshots. Compile plans apply all-or-nothing: a durable journal records every source write and store mutation before the first write, all steps commit in one store transaction, and an interrupted application is completed or rolled back by the next mutating call. Bootstrap actions are dependency-ordered, sequential, source-first, and recoverable from a typed journal.",
     businessInputSchema: {
         type: "object",
         oneOf: [
@@ -183,7 +183,7 @@ export const applyPlanSpec = {
             recoveryJournalId: {
                 type: "string",
                 pattern: "^[A-Za-z0-9._-]+$",
-                description: "Typed recovery journal identifier returned by a committed_with_repairs result. Recovery replays only the immutable journal and never the original plan request.",
+                description: "Typed recovery journal identifier returned by a committed_with_repairs result or a PLAN_APPLY_RECOVERY_REQUIRED error. Recovery replays only the immutable journal and never the original plan request; a compile-plan journal (plan-apply-*) is completed or rolled back deterministically and reports which.",
             },
         },
     },

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

@@ -1 +1 @@
-{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/reporting.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/reporting.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,3 @@
-import { join } from "node:path";
-import { resolveBoundSymbolScope } from "../../../extractors/manifest.js";
 import { PROOF_RECEIPT_MAX_AGE_SECONDS } from "../../proof-receipt.js";
 import { executeStatus } from "../discovery-executors.js";
 import { buildLegacyMigrationPlanFromContext, } from "../legacy-migration-plan.js";
@@ -101,13 +99,12 @@ export function currentProofBindingMode() {
         ? "strict_snapshot"
         : "per_contract";
 }
+// implements REQ-kibi-verification-evidence-contract
 export async function perContractTestBindings(context) {
     if (currentProofBindingMode() !== "per_contract")
         return null;
     const { loadEntities } = await import("../discovery-entities.js");
-    const { receiptBindingHash } = await import("../../proof-fingerprint.js");
-    const { removeFrontmatterBlock } = await import("../../../operations/proof/receipt-document.js");
-    const { loadCoveredBySymbolsByTest, receiptCodeScopeSymbolIds } = await import("../../../operations/proof/code-scope.js");
+    const { currentReceiptBindingHash, loadCoveredBySymbolsByTest } = await import("../../../operations/proof/code-scope.js");
     // Only the contract, scoped code, and authored source feed the binding
     // hash. The paged projection never materializes receipt histories, which
     // grow without bound and previously overflowed the bounded Prolog output
@@ -128,32 +125,22 @@ export async function perContractTestBindings(context) {
         ? await loadCoveredBySymbolsByTest(requireProlog(context))
         : new Map();
     const entries = [];
-    const manifestPath = join(context.workspaceRoot, ".kb", "symbols.yaml");
+    const fs = context.fs;
     for (const test of tests) {
         const testId = typeof test.id === "string" ? test.id : "";
-        const contract = test.proof_contract !== undefined &&
-            test.proof_contract !== null &&
-            typeof test.proof_contract === "object"
-            ? test.proof_contract
-            : undefined;
-        const source = typeof test.source === "string" ? test.source : "";
-        if (testId === "" || contract === undefined || source === "")
-            continue;
-        if (!/\.(md|mdx)$/i.test(source))
-            continue;
-        if (!context.fs)
+        if (testId === "" || fs === undefined)
             continue;
-        try {
-            const absolute = join(context.workspaceRoot, source);
-            const authored = await context.fs.readFile(absolute);
-            const stripped = removeFrontmatterBlock(authored, "proof_receipts");
-            const codeScope = resolveBoundSymbolScope(manifestPath, receiptCodeScopeSymbolIds(contract, test.proof_bindings, coveredBy.get(testId) ?? []));
-            const binding = receiptBindingHash(contract, stripped ?? authored, codeScope);
+        // The same computation ingest uses to write binding_hash. Unreadable or
+        // non-markdown documents keep strict snapshot semantics for that test.
+        const binding = await currentReceiptBindingHash({
+            workspaceRoot: context.workspaceRoot,
+            readFile: (absolute) => fs.readFile(absolute),
+            test,
+            coveredBySymbols: coveredBy.get(testId) ?? [],
+        });
+        if (binding !== undefined) {
             entries.push(`${toPrologAtom(testId)}: ${toPrologAtom(binding)}`);
         }
-        catch {
-            // Unreadable documents keep strict semantics for that test.
-        }
     }
     if (entries.length === 0)
         return null;