kibi-cli 0.16.1 → 0.18.1

package/dist/operations/mutation/contradictions.d.ts

@@ -4,7 +4,7 @@ type TransactionInput = {
     readonly relationships: readonly RelationshipInput[];
     readonly skipContradictionCheck: boolean;
 };
-export declare function buildUpsertTransaction(input: TransactionInput): string;
+export declare function buildUpsertCommitGoal(input: TransactionInput): string;
 export declare function formatUpsertError(entityId: string, raw?: string): string;
 export {};
 //# sourceMappingURL=contradictions.d.ts.map

package/dist/operations/mutation/contradictions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contradictions.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/contradictions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C,CAAC;AAGF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CActE;AAGD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CA0BxE"}
+{"version":3,"file":"contradictions.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/contradictions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C,CAAC;AAGF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAOrE;AAGD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CA6CxE"}

package/dist/operations/mutation/contradictions.js

@@ -2,39 +2,44 @@ import { escapeAtom } from "../../prolog/codec.js";
 import { formatInvalidRelationshipError } from "./relationships.js";
 import { buildPropertyList, buildRelationshipMetadata, } from "./serialization.js";
 // implements REQ-kibi-operation-interface-parity
-export function buildUpsertTransaction(input) {
-    const id = String(input.entity.id);
+export function buildUpsertCommitGoal(input) {
     const type = String(input.entity.type);
-    const goals = [
-        `kb_assert_entity_no_audit(${type}, ${buildPropertyList(input.entity)})`,
-        ...input.relationships.map((relationship) => `kb_assert_relationship_no_audit(${String(relationship.type)}, '${escapeAtom(String(relationship.from))}', '${escapeAtom(String(relationship.to))}', ${buildRelationshipMetadata(relationship)})`),
-    ];
-    if (type === "req" && !input.skipContradictionCheck) {
-        goals.push(`check_req_contradiction('${escapeAtom(id)}')`);
-    }
-    return `rdf_transaction((${goals.join(", ")}))`;
+    const relationships = input.relationships.map((relationship) => `rel(${String(relationship.type)}, '${escapeAtom(String(relationship.from))}', '${escapeAtom(String(relationship.to))}', ${buildRelationshipMetadata(relationship)})`);
+    return `kb_commit_upsert(${type}, ${buildPropertyList(input.entity)}, [${relationships.join(", ")}], ${input.skipContradictionCheck ? "true" : "false"}, ChangeKind)`;
 }
 // implements REQ-kibi-operation-interface-parity
 export function formatUpsertError(entityId, raw) {
     if (!raw)
         return `Failed to upsert entity ${entityId}: Unknown error`;
-    const invalidRelationship = formatInvalidRelationshipError(raw);
+    const stage = raw.match(/\(stage=([^)]+)\)/)?.[1];
+    const stageSuffix = stage === undefined ? "" : ` (stage=${stage})`;
+    const diagnosticFree = raw.replace(/^__KIBI_(?:STAGE|RUNTIME)__:[^\r\n]*\r?\n?/gm, "");
+    if (diagnosticFree.includes("stale_snapshot")) {
+        return `Failed to upsert entity ${entityId}: KB snapshot is stale; reattach or refresh the runtime before retrying (stale_snapshot)${stageSuffix}`;
+    }
+    if (diagnosticFree.includes("Audit journal is locked") ||
+        diagnosticFree.includes("audit_log") ||
+        diagnosticFree.includes("audit.log") ||
+        diagnosticFree.includes("Resource temporarily unavailable")) {
+        return `Failed to upsert entity ${entityId}: Audit journal is locked by another Kibi runtime; restart the stale MCP/CLI session before retrying${stageSuffix}`;
+    }
+    const invalidRelationship = formatInvalidRelationshipError(diagnosticFree);
     if (invalidRelationship !== null) {
-        return `Failed to upsert entity ${entityId}: ${invalidRelationship}`;
+        return `Failed to upsert entity ${entityId}: ${invalidRelationship}${stageSuffix}`;
     }
-    const contradiction = raw.match(/kb_contradiction\(\s*\[([^\]]+)\]\s*\)/);
+    const contradiction = diagnosticFree.match(/kb_contradiction\(\s*\[([^\]]+)\]\s*\)/);
     if (contradiction) {
         const details = contradiction[1] ?? "";
         const conflicts = [
             ...details.matchAll(/(?:'([^']+)'|"([^"\\]*(?:\\.[^"\\]*)*)")-'([^']+)'/g),
         ].map((match) => `  - Conflicts with ${String(match[3])}: ${String(match[1] ?? match[2])}`);
         if (conflicts.length > 0) {
-            return `Contradiction detected for requirement ${entityId}:\n${[...new Set(conflicts)].join("\n")}\n\nTo resolve:\n  1. Add a supersedes relationship from the new requirement to the conflicting one, OR\n  2. Deprecate the conflicting requirement before creating the new one.`;
+            return `Contradiction detected for requirement ${entityId}:\n${[...new Set(conflicts)].join("\n")}\n\nTo resolve:\n  1. Add a supersedes relationship from the new requirement to the conflicting one, OR\n  2. Deprecate the conflicting requirement before creating the new one.${stageSuffix}`;
         }
-        return `Contradiction detected for entity ${entityId}: This requirement conflicts with existing requirements. Add a supersedes relationship to the conflicting requirement, or deprecate the old requirement before creating the new one.`;
+        return `Contradiction detected for entity ${entityId}: This requirement conflicts with existing requirements. Add a supersedes relationship to the conflicting requirement, or deprecate the old requirement before creating the new one.${stageSuffix}`;
     }
-    if (raw.includes("rdf_transaction")) {
-        return `Failed to upsert entity ${entityId}: Transaction failed`;
+    if (diagnosticFree.includes("rdf_transaction")) {
+        return `Failed to upsert entity ${entityId}: Transaction failed${stageSuffix}`;
     }
-    return `Failed to upsert entity ${entityId}: ${raw}`;
+    return `Failed to upsert entity ${entityId}: ${diagnosticFree || raw}`;
 }

package/dist/operations/mutation/relationships.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAqBpD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgCF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,iBAAiB,GACvB,MAAM,CAER;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAczE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,IAAI,CAMN;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,iBAAiB,GAC9B,MAAM,CAIR;AAuBD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAevC"}
+{"version":3,"file":"relationships.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/relationships.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsBpD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAAC;AAgCF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,iBAAiB,GACvB,MAAM,CAER;AAED,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAczE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,IAAI,CAMN;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,iBAAiB,GAC9B,MAAM,CAIR;AAuBD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,iBAAiB,EAAE,GAC1C,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAevC"}

package/dist/operations/mutation/relationships.js

@@ -12,6 +12,7 @@ const RELATIONSHIP_TYPES = [
     "constrains",
     "requires_property",
     "requires_predicate",
+    "requires_rule",
     "guards",
     "publishes",
     "consumes",
@@ -106,6 +107,13 @@ export async function validateLiveRelationshipTargets(prolog, entity, relationsh
 export async function validateStrictLanePairing(prolog, relationships) {
     for (const relationship of relationships) {
         const target = stringField(relationship, "to");
+        if (relationship.type === "requires_rule") {
+            const result = await prolog.query(`once((kb_entity('${escapeAtom(target)}', fact, _RuleProps), memberchk(fact_kind=_RuleKind, _RuleProps), normalize_term_atom(_RuleKind, rule)))`);
+            if (!result.success) {
+                throw new Error(`Relationship 'requires_rule' requires target '${target}' to be a fact_kind=rule fact.`);
+            }
+            continue;
+        }
         const wrongKind = relationship.type === "constrains"
             ? "property_value"
             : relationship.type === "requires_property"

package/dist/operations/mutation/serialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/serialization.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA0CpD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,CAMR;AAGD,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAOxE;AAGD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBtD"}
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/serialization.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAkDpD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,CAMR;AAGD,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAOxE;AAGD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBtD"}

package/dist/operations/mutation/serialization.js

@@ -20,11 +20,17 @@ const STRING_FIELDS = [
     "updated_at",
     "source",
     "text_ref",
+    "semantic_text",
 ];
 function serializeValue(key, value) {
     if (key === "id" && typeof value === "string") {
         return `'${value.replaceAll("'", "''")}'`;
     }
+    if (key === "rule_ir" ||
+        key === "semantic_inventory" ||
+        key === "verification_receipts") {
+        return toPrologString(JSON.stringify(value));
+    }
     if (Array.isArray(value))
         return JSON.stringify(value);
     if (typeof value === "string") {

package/dist/operations/mutation/strict-fact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-fact.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/strict-fact.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAarD;AAGD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,EAAE,CAyCV;AAGD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,IAAI,CAKN"}
+{"version":3,"file":"strict-fact.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/strict-fact.ts"],"names":[],"mappings":"AAUA,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAarD;AAGD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,EAAE,CA+EV;AAGD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,IAAI,CAuDN"}

package/dist/operations/mutation/strict-fact.js

@@ -1,3 +1,4 @@
+import { validateLogicIr } from "../../logic/ir.js";
 const PROPERTY_VALUE_FIELDS = [
     "value_string",
     "value_int",
@@ -43,6 +44,40 @@ export function factKindShapeHints(entity) {
         }
         return hints;
     }
+    if (entity.fact_kind === "rule_schema") {
+        const missing = ["rule_name", "argument_names", "argument_types"].filter((field) => entity[field] === undefined);
+        const equalLengths = Array.isArray(entity.argument_names) &&
+            Array.isArray(entity.argument_types) &&
+            entity.argument_names.length === entity.argument_types.length;
+        const hints = missing.length > 0
+            ? [`fact_kind 'rule_schema' requires ${missing.join(", ")}.`]
+            : equalLengths
+                ? []
+                : [
+                    "fact_kind 'rule_schema' requires argument_names and argument_types with equal lengths.",
+                ];
+        return hints.length > 0
+            ? [
+                ...hints,
+                "Next action: define the kibi.logic.v1 schema before creating rule facts.",
+            ]
+            : [];
+    }
+    if (entity.fact_kind === "rule") {
+        const missing = [
+            "rule_ir",
+            "rule_hash",
+            "rule_schema_id",
+            "rule_name",
+            "semantic_key",
+        ].filter((field) => entity[field] === undefined);
+        return missing.length > 0
+            ? [
+                `fact_kind 'rule' requires ${missing.join(", ")}.`,
+                "Next action: call kb_model_requirement with typed kibi.logic.v1 IR; raw Prolog is not accepted.",
+            ]
+            : [];
+    }
     if (entity.fact_kind !== "predicate")
         return [];
     const args = entity.predicate_args;
@@ -51,12 +86,12 @@ export function factKindShapeHints(entity) {
         ...(!Array.isArray(args) || args.length === 0 ? ["predicate_args"] : []),
         ...(entity.canonical_key === undefined ? ["canonical_key"] : []),
     ];
-    return missing.length === 0
-        ? []
-        : [
+    if (missing.length !== 0)
+        return [
             `fact_kind 'predicate' requires ${missing.join(", ")}.`,
             "Next action: call kb_suggest_predicates before hand-writing ontology predicate facts.",
         ];
+    return [];
 }
 // implements REQ-kibi-operation-interface-parity
 export function validateFactModelingShape(entity) {
@@ -64,4 +99,34 @@ export function validateFactModelingShape(entity) {
     if (hints.length > 0) {
         throw new Error(`Entity validation failed: ${hints.join("; ")}`);
     }
+    if (entity.type === "fact" && entity.fact_kind === "rule") {
+        const validation = validateLogicIr(entity.rule_ir);
+        if (!validation.valid || !validation.semanticKey) {
+            throw new Error(`Entity validation failed: rule_ir is unsafe or malformed (${validation.errors.join("; ")})`);
+        }
+        if (entity.rule_hash !== undefined &&
+            entity.rule_hash !== validation.ruleHash) {
+            throw new Error(`Entity validation failed: rule_hash must equal ${validation.ruleHash}`);
+        }
+        if (entity.semantic_key !== undefined &&
+            entity.semantic_key !== validation.semanticKey) {
+            throw new Error(`Entity validation failed: semantic_key must equal ${validation.semanticKey}`);
+        }
+        for (const field of ["rule_schema_id", "rule_name"]) {
+            if (typeof entity[field] !== "string" || entity[field].trim() === "") {
+                throw new Error(`Entity validation failed: fact_kind 'rule' requires ${field}`);
+            }
+        }
+    }
+    if (entity.type === "fact" && entity.fact_kind === "rule_schema") {
+        if (typeof entity.rule_name !== "string" ||
+            entity.rule_name.trim() === "") {
+            throw new Error("Entity validation failed: fact_kind 'rule_schema' requires rule_name");
+        }
+        if (!Array.isArray(entity.argument_names) ||
+            !Array.isArray(entity.argument_types) ||
+            entity.argument_names.length !== entity.argument_types.length) {
+            throw new Error("Entity validation failed: rule_schema argument_names and argument_types must have equal lengths");
+        }
+    }
 }

package/dist/operations/mutation/upsert.d.ts

@@ -1,5 +1,7 @@
 import type { OperationContext } from "../../public/operations/runtime-types.js";
 import type { OperationResult } from "../../public/operations/types.js";
-import type { UpsertInput, UpsertPayload } from "./types.js";
+import type { RelationshipInput, UpsertInput, UpsertPayload } from "./types.js";
+export declare function validateAppendOnlyVerificationReceipts(entity: Readonly<Record<string, unknown>>, context: OperationContext): Promise<void>;
+export declare function effectiveRelationships(input: UpsertInput, entity: Readonly<Record<string, unknown>>, relationships: readonly RelationshipInput[], context: OperationContext): Promise<readonly RelationshipInput[]>;
 export declare function executeUpsert(input: UpsertInput, context: OperationContext): Promise<OperationResult<UpsertPayload>>;
 //# sourceMappingURL=upsert.d.ts.map

package/dist/operations/mutation/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/upsert.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAaxE,OAAO,KAAK,EAAqB,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAkChF,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CA0FzC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/upsert.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAgBxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA8BhF,wBAAsB,sCAAsC,CAC1D,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,aAAa,EAAE,SAAS,iBAAiB,EAAE,EAC3C,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,SAAS,iBAAiB,EAAE,CAAC,CAgBvC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAuGzC"}

package/dist/operations/mutation/upsert.js

@@ -1,9 +1,10 @@
 import { escapeAtom } from "../../prolog/codec.js";
+import { loadEntities } from "../../public/operations/discovery-entities.js";
+import { appendOnlyVerificationReceiptHistoryErrors } from "../../public/verification-receipt.js";
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
-import { recordEntityAudit, recordRelationshipAudits } from "./audit.js";
-import { buildUpsertTransaction, formatUpsertError } from "./contradictions.js";
+import { assertLogicalGroundingClaimKeys, assertSemanticInventoryBoundary, } from "../semantic-advisor/ingestion-boundary.js";
+import { buildUpsertCommitGoal, formatUpsertError } from "./contradictions.js";
 import { existingRelationships, validateLiveRelationshipTargets, validateRelationshipSources, validateStrictLanePairing, } from "./relationships.js";
-import { saveMutation } from "./save.js";
 import { validateSymbolGranularity } from "./symbol-granularity.js";
 import { refreshSymbolCoordinates } from "./symbol-refresh.js";
 import { validateUpsertInput } from "./validation.js";
@@ -14,7 +15,36 @@ function requireProlog(context) {
     }
     return context.prolog;
 }
-async function effectiveRelationships(input, entity, relationships, context) {
+function receiptRecords(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((receipt) => receipt !== null &&
+        typeof receipt === "object" &&
+        !Array.isArray(receipt));
+}
+function parseChangeKind(value) {
+    const normalized = value?.trim().replace(/^['"]|['"]$/g, "");
+    return normalized === "created" || normalized === "updated"
+        ? normalized
+        : null;
+}
+export async function validateAppendOnlyVerificationReceipts(entity, context) {
+    if (entity.type !== "test")
+        return;
+    const existing = await loadEntities(requireProlog(context), {
+        id: String(entity.id),
+        type: "test",
+    });
+    const previous = receiptRecords(existing[0]?.verification_receipts);
+    if (!previous || previous.length === 0)
+        return;
+    const next = receiptRecords(entity.verification_receipts);
+    const errors = appendOnlyVerificationReceiptHistoryErrors(previous, next);
+    if (errors.length > 0) {
+        throw new Error(`Entity validation failed: ${errors.join("; ")}`);
+    }
+}
+export async function effectiveRelationships(input, entity, relationships, context) {
     if (input.relationships !== undefined && input.relationships.length > 0) {
         return relationships;
     }
@@ -36,13 +66,18 @@ export async function executeUpsert(input, context) {
     const prolog = requireProlog(context);
     try {
         const validated = validateUpsertInput(input, context.clock());
+        await validateAppendOnlyVerificationReceipts(validated.entity, context);
         validateRelationshipSources(input.id, validated.relationships);
         await validateSymbolGranularity(validated.entity, validated.relationships, context);
         const relationships = await effectiveRelationships(input, validated.entity, validated.relationships, context);
         await validateStrictLanePairing(prolog, relationships);
         await validateLiveRelationshipTargets(prolog, validated.entity, relationships);
-        const exists = await prolog.query(`once(kb_entity('${escapeAtom(input.id)}', _, _))`);
-        const transaction = buildUpsertTransaction({
+        const semantic = analyzeSemanticAdvisorInput({
+            payload: { ...input, relationships },
+        });
+        assertSemanticInventoryBoundary({ ...input, relationships }, relationships, semantic.receipt);
+        await assertLogicalGroundingClaimKeys(prolog, { ...input, relationships }, relationships);
+        const transaction = buildUpsertCommitGoal({
             entity: validated.entity,
             relationships,
             skipContradictionCheck: input._skipContradictionCheck === true,
@@ -51,9 +86,14 @@ export async function executeUpsert(input, context) {
         if (!written.success) {
             throw new Error(formatUpsertError(input.id, written.error));
         }
-        await recordEntityAudit(prolog, exists.success ? "updated" : "created", validated.entity);
-        await recordRelationshipAudits(prolog, relationships);
-        await saveMutation(prolog);
+        // The combined commit is the sole mutation boundary. Invalidate reads only
+        // after Prolog reports success so a failed/rolled-back commit does not
+        // disturb callers' view of the current snapshot.
+        prolog.invalidateCache?.();
+        const changeKind = parseChangeKind(written.bindings.ChangeKind);
+        if (changeKind === null) {
+            throw new Error(`Upsert commit completed without a created/updated result for ${input.id}`);
+        }
         if (input.type === "symbol") {
             try {
                 await refreshSymbolCoordinates(input.id, context);
@@ -63,12 +103,11 @@ export async function executeUpsert(input, context) {
                     throw error;
             }
         }
-        const semantic = analyzeSemanticAdvisorInput({ payload: { ...input } });
         const coverage = await scenarioCoverageWarnings(prolog, validated.relationships, input.type, input.id);
-        const created = exists.success ? 0 : 1;
+        const created = changeKind === "created" ? 1 : 0;
         const payload = {
             created,
-            updated: exists.success ? 1 : 0,
+            updated: changeKind === "updated" ? 1 : 0,
             relationships_created: relationships.length,
             warnings: [...semantic.warnings, ...coverage],
             semanticAdvisor: semantic.receipt,

package/dist/operations/mutation/validate-upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-upsert.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validate-upsert.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAOxE,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGrE,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CAoDjD"}
+{"version":3,"file":"validate-upsert.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validate-upsert.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAYxE,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOrE,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC,CAoFjD"}

package/dist/operations/mutation/validate-upsert.js

@@ -1,16 +1,32 @@
 import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
+import { assertLogicalGroundingClaimKeys, assertSemanticInventoryBoundary, validateSemanticInventoryBoundary, } from "../semantic-advisor/ingestion-boundary.js";
 import { validateLiveRelationshipTargets, validateRelationshipSources, } from "./relationships.js";
 import { validateSymbolGranularity } from "./symbol-granularity.js";
+import { effectiveRelationships, validateAppendOnlyVerificationReceipts, } from "./upsert.js";
 import { validateUpsertInput } from "./validation.js";
 export async function executeValidateUpsert(input, context) {
     try {
         const validated = validateUpsertInput(input, context.clock());
+        await validateAppendOnlyVerificationReceipts(validated.entity, context);
         validateRelationshipSources(input.id, validated.relationships);
         await validateSymbolGranularity(validated.entity, validated.relationships, context);
+        const previewSemantic = analyzeSemanticAdvisorInput({
+            payload: { ...input, relationships: validated.relationships },
+        });
+        const previewBoundary = validateSemanticInventoryBoundary({ ...input, relationships: validated.relationships }, validated.relationships, previewSemantic.receipt);
+        const relationships = context.prolog === undefined || !previewBoundary.applicable
+            ? validated.relationships
+            : await effectiveRelationships(input, validated.entity, validated.relationships, context);
         if (context.prolog !== undefined) {
-            await validateLiveRelationshipTargets(context.prolog, validated.entity, validated.relationships);
+            await validateLiveRelationshipTargets(context.prolog, validated.entity, relationships);
+        }
+        const semantic = analyzeSemanticAdvisorInput({
+            payload: { ...input, relationships },
+        });
+        assertSemanticInventoryBoundary({ ...input, relationships }, relationships, semantic.receipt);
+        if (context.prolog !== undefined) {
+            await assertLogicalGroundingClaimKeys(context.prolog, { ...input, relationships }, relationships);
         }
-        const semantic = analyzeSemanticAdvisorInput({ payload: { ...input } });
         const payload = {
             valid: true,
             errors: [],

package/dist/operations/mutation/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validation.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAO5C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAiF/D,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,IAAI,GACR,eAAe,CA0CjB;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/operations/mutation/validation.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,0BAA0B,EAC3B,MAAM,oCAAoC,CAAC;AAQ5C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAiF/D,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,IAAI,GACR,eAAe,CAwDjB;AAED,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/operations/mutation/validation.js

@@ -3,6 +3,7 @@ import entitySchema from "../../public/schemas/entity.js";
 import relationshipSchema from "../../public/schemas/relationship.js";
 // implements REQ-kibi-operation-interface-parity
 import { SYMBOL_ROLES, isAllowedGranularityReason, } from "../../public/symbol-granularity.js";
+import { verificationReceiptHistoryErrors } from "../../public/verification-receipt.js";
 import { semanticClaimKey } from "../semantic-advisor/clauses.js";
 import { factKindShapeHints, validateFactModelingShape, valueFieldHint, } from "./strict-fact.js";
 const ajv = new Ajv({ strict: false });
@@ -84,6 +85,13 @@ export function validateUpsertInput(input, now) {
     if (!validateEntity(entity)) {
         throw new Error(`Entity validation failed: ${formatEntityErrors(entity, validateEntity.errors ?? [])}`);
     }
+    if (entity.type === "test" && Array.isArray(entity.verification_receipts)) {
+        const receipts = entity.verification_receipts.filter((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+        const receiptErrors = verificationReceiptHistoryErrors(input.id, entity.verification_scope, receipts);
+        if (receiptErrors.length > 0) {
+            throw new Error(`Entity validation failed: ${receiptErrors.join("; ")}`);
+        }
+    }
     validateFactModelingShape(entity);
     if (entity.type === "fact" &&
         typeof entity.claim_key === "string" &&

package/dist/operations/semantic-advisor/analysis-receipt.d.ts

@@ -1,5 +1,5 @@
 import type { SemanticClause } from "./clauses.js";
 import { type Payload } from "./shared.js";
-import type { SemanticAdvisorAnalysisResult, SemanticModelingSuggestion, SemanticSignal } from "./types.js";
-export declare function buildAdvisorResult(payload: Payload, signals: readonly SemanticSignal[], modeled: boolean, suggestions: readonly SemanticModelingSuggestion[], clauses: readonly SemanticClause[]): SemanticAdvisorAnalysisResult;
+import type { SemanticAdvisorAnalysisResult, SemanticInterpretationResult, SemanticModelingSuggestion, SemanticProposition, SemanticShadowCue, SemanticSignal } from "./types.js";
+export declare function buildAdvisorResult(payload: Payload, signals: readonly SemanticSignal[], modeled: boolean, suggestions: readonly SemanticModelingSuggestion[], clauses: readonly SemanticClause[], propositions: readonly SemanticProposition[], interpretations: readonly SemanticInterpretationResult[], shadowAnalysis: readonly SemanticShadowCue[]): SemanticAdvisorAnalysisResult;
 //# sourceMappingURL=analysis-receipt.d.ts.map

package/dist/operations/semantic-advisor/analysis-receipt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analysis-receipt.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analysis-receipt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EAAE,KAAK,OAAO,EAA6B,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EACV,6BAA6B,EAI7B,0BAA0B,EAC1B,cAAc,EACf,MAAM,YAAY,CAAC;AAwCpB,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,SAAS,0BAA0B,EAAE,EAClD,OAAO,EAAE,SAAS,cAAc,EAAE,GACjC,6BAA6B,CAqG/B"}
+{"version":3,"file":"analysis-receipt.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analysis-receipt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,6BAA6B,EAI7B,4BAA4B,EAC5B,0BAA0B,EAC1B,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AA0CpB,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,SAAS,0BAA0B,EAAE,EAClD,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,YAAY,EAAE,SAAS,mBAAmB,EAAE,EAC5C,eAAe,EAAE,SAAS,4BAA4B,EAAE,EACxD,cAAc,EAAE,SAAS,iBAAiB,EAAE,GAC3C,6BAA6B,CAkH/B"}

package/dist/operations/semantic-advisor/analysis-receipt.js

@@ -1,4 +1,4 @@
-import { payloadHash, propertiesOf } from "./shared.js";
+import { SEMANTIC_INVENTORY_VERSION, payloadHash, propertiesOf, semanticSourceHash, semanticSourceOf, } from "./shared.js";
 function chooseLane(signals) {
     if (signals.some(({ kind }) => kind === "numeric_cardinality" || kind === "numeric_threshold"))
         return "strict_property";
@@ -19,15 +19,20 @@ function summary(readiness, lane) {
         return "Requirement prose appears to contain scalar, threshold, or cardinality logic that should be modeled with strict facts.";
     if (lane === "predicate")
         return "Requirement prose appears to contain relational or behavioral logic that should be modeled with ontology predicates.";
+    if (lane === "rule")
+        return "Requirement prose has a typed interpretation candidate; validate and persist it as a safe kibi.logic.v1 rule.";
     return "Requirement prose appears normative but needs review before it can participate in logic checks.";
 }
 // implements REQ-mcp-semantic-advisor-preflight
-export function buildAdvisorResult(payload, signals, modeled, suggestions, clauses) {
+export function buildAdvisorResult(payload, signals, modeled, suggestions, clauses, propositions, interpretations, shadowAnalysis) {
+    const semanticSource = semanticSourceOf(payload);
     const suggestionLane = suggestions.some(({ kind }) => kind === "strict_property")
         ? "strict_property"
-        : suggestions.some(({ kind }) => kind === "predicate")
-            ? "predicate"
-            : null;
+        : suggestions.some(({ kind }) => kind === "rule")
+            ? "rule"
+            : suggestions.some(({ kind }) => kind === "predicate")
+                ? "predicate"
+                : null;
     const candidateLane = modeled
         ? "none"
         : (suggestionLane ?? chooseLane(signals));
@@ -42,21 +47,22 @@ export function buildAdvisorResult(payload, signals, modeled, suggestions, claus
             ? ["kb_model_requirement"]
             : candidateLane === "predicate"
                 ? ["kb_suggest_predicates"]
-                : candidateLane === "observation_review"
-                    ? ["kb_model_requirement", "kb_suggest_predicates"]
-                    : [];
-    const expectedClaimKeys = clauses
-        .filter((clause) => clause.normative)
-        .map((clause) => clause.claim_key);
+                : candidateLane === "rule"
+                    ? ["kb_model_requirement"]
+                    : candidateLane === "observation_review"
+                        ? ["kb_model_requirement", "kb_suggest_predicates"]
+                        : [];
+    const expectedClaimKeys = propositions
+        .filter(({ role }) => !["rationale", "example", "subjective"].includes(role))
+        .map(({ claim_key }) => claim_key);
     const rawDeclaredClaimKeys = propertiesOf(payload).logic_claims;
     const declaredClaimKeys = Array.isArray(rawDeclaredClaimKeys)
         ? rawDeclaredClaimKeys.filter((value) => typeof value === "string")
         : [];
     const missingClaimKeys = expectedClaimKeys.filter((claimKey) => !declaredClaimKeys.includes(claimKey));
-    const unresolvedClaimKeys = suggestions
-        .filter((suggestion) => suggestion.kind === "ambiguity_observation" ||
-        suggestion.kind === "ontology_gap")
-        .map((suggestion) => suggestion.claim_key);
+    const unresolvedClaimKeys = propositions
+        .filter(({ status }) => ["ambiguous", "ontology_gap", "missing"].includes(status))
+        .map(({ claim_key }) => claim_key);
     const coverageStatus = expectedClaimKeys.length === 0
         ? "not_applicable"
         : modeled
@@ -65,8 +71,13 @@ export function buildAdvisorResult(payload, signals, modeled, suggestions, claus
                 ? "unverified"
                 : "partial";
     const receipt = {
-        version: "semantic-advisor-v1",
+        version: "semantic-advisor-v2",
         payload_hash: payloadHash(payload),
+        inventory_contract: {
+            version: SEMANTIC_INVENTORY_VERSION,
+            source_field: semanticSource.field,
+            source_hash: semanticSourceHash(semanticSource.text),
+        },
         logic_readiness: readiness,
         candidate_lane: candidateLane,
         signals,
@@ -86,6 +97,9 @@ export function buildAdvisorResult(payload, signals, modeled, suggestions, claus
                 ],
                 message: "Numeric cardinality prose can mean an exact count, an upper/lower bound, named membership, or an example; model it explicitly before relying on contradiction checks.",
             })),
+        propositions,
+        interpretations,
+        shadow_analysis: shadowAnalysis,
         suggestions,
         clauses: clauses.map((clause) => ({
             ...clause,

package/dist/operations/semantic-advisor/analyze-prose.d.ts

@@ -1,5 +1,5 @@
 import type { SemanticAdvisorAnalysisResult, SemanticAdvisorInput } from "./types.js";
-export declare const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v1";
+export declare const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
 export { semanticClaimKey } from "./clauses.js";
 export declare function analyzeSemanticAdvisorInput(input: SemanticAdvisorInput): SemanticAdvisorAnalysisResult;
 //# sourceMappingURL=analyze-prose.d.ts.map

package/dist/operations/semantic-advisor/analyze-prose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze-prose.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analyze-prose.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAKrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAsThD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CAuB/B"}
+{"version":3,"file":"analyze-prose.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analyze-prose.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAWrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AA01BhD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CA+D/B"}