kibi-cli 0.17.0 → 0.18.1

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";
@@ -25,6 +25,7 @@ function summary(readiness, lane) {
 }
 // implements REQ-mcp-semantic-advisor-preflight
 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 === "rule")
@@ -72,6 +73,11 @@ export function buildAdvisorResult(payload, signals, modeled, suggestions, claus
     const receipt = {
         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,

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":"AA8BA,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAWrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AA6zBhD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CAuD/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"}

package/dist/operations/semantic-advisor/analyze-prose.js

@@ -8,7 +8,7 @@ import { CORE_PREDICATE_RULES } from "./predicate-rules-core.js";
 import { POLICY_PREDICATE_RULES } from "./predicate-rules-policy.js";
 import { PRODUCT_TAIL_PREDICATE_RULES } from "./predicate-rules-product-tail.js";
 import { PRODUCT_PREDICATE_RULES } from "./predicate-rules-product.js";
-import { isRecord, payloadHash, propertiesOf, relationship, sourceOf, statementOf, stringValue, } from "./shared.js";
+import { isRecord, payloadHash, propertiesOf, relationship, semanticClausesOf, semanticSourceHash, semanticSourceOf, sourceOf, statementOf, stringValue, } from "./shared.js";
 import { detectStrictSuggestion } from "./strict-rules.js";
 export const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
 export { semanticClaimKey } from "./clauses.js";
@@ -52,7 +52,12 @@ const SIGNAL_PATTERNS = [
 ];
 function proseOf(payload) {
     const properties = propertiesOf(payload);
-    return [properties.title, properties.text_ref, properties.description]
+    return [
+        properties.title,
+        properties.semantic_text,
+        properties.text_ref,
+        properties.description,
+    ]
         .map(stringValue)
         .filter(Boolean)
         .join("\n");
@@ -69,8 +74,8 @@ function logicalGroundingSlots(payload) {
     return relationships.filter((relationship) => isRecord(relationship) &&
         ["requires_property", "requires_predicate", "requires_rule"].includes(stringValue(relationship.type))).length;
 }
-function isModeled(payload, expectedClaimCount) {
-    if (expectedClaimCount === 0)
+function isModeled(payload, expectedClaimKeys) {
+    if (expectedClaimKeys.length === 0)
         return false;
     const relationships = Array.isArray(payload.relationships)
         ? payload.relationships
@@ -79,7 +84,16 @@ function isModeled(payload, expectedClaimCount) {
         .filter(isRecord)
         .map((relationship) => stringValue(relationship.type))
         .filter(Boolean));
-    return (logicalGroundingSlots(payload) >= expectedClaimCount &&
+    const rawInventory = propertiesOf(payload).semantic_inventory;
+    const inventory = Array.isArray(rawInventory)
+        ? rawInventory.filter(isRecord)
+        : [];
+    const modeledClaimKeys = inventory
+        .filter(({ status }) => status === "modeled")
+        .map(({ claim_key }) => stringValue(claim_key));
+    return (logicalGroundingSlots(payload) === expectedClaimKeys.length &&
+        modeledClaimKeys.length === expectedClaimKeys.length &&
+        expectedClaimKeys.every((claimKey) => modeledClaimKeys.includes(claimKey)) &&
         ((types.has("constrains") && types.has("requires_property")) ||
             types.has("requires_predicate") ||
             types.has("requires_rule")));
@@ -231,13 +245,8 @@ function modelingSuggestions(payload, modeled, clauses, interpretations) {
     const suggestions = [];
     const seen = new Set();
     const expectedClaimKeys = clauses
-        .filter((clause) => clause.normative)
+        .filter((clause) => !["rationale", "example", "subjective"].includes(propositionRole(clause.text, clause.normative)))
         .map((clause) => clause.claim_key);
-    const rawDeclaredClaimKeys = propertiesOf(payload).logic_claims;
-    const declaredClaimKeys = Array.isArray(rawDeclaredClaimKeys)
-        ? rawDeclaredClaimKeys.filter((value) => typeof value === "string")
-        : [];
-    const mergedClaimKeys = Array.from(new Set([...declaredClaimKeys, ...expectedClaimKeys]));
     for (const clause of clauses) {
         const candidate = clause.text;
         const rawSuggestion = predicateSuggestion(payload, candidate) ??
@@ -245,9 +254,9 @@ function modelingSuggestions(payload, modeled, clauses, interpretations) {
             ambiguitySuggestion(payload, candidate) ??
             detectStrictSuggestion(payload, candidate);
         const suggestion = rawSuggestion
-            ? withClauseProvenance(rawSuggestion, clause, mergedClaimKeys, statementOf(payload))
+            ? withClauseProvenance(rawSuggestion, clause, clauses, expectedClaimKeys, statementOf(payload), semanticSourceOf(payload).field)
             : clause.normative
-                ? unmatchedClauseSuggestion(payload, clause, mergedClaimKeys)
+                ? unmatchedClauseSuggestion(payload, clause, clauses, expectedClaimKeys)
                 : null;
         if (!suggestion)
             continue;
@@ -264,7 +273,7 @@ function modelingSuggestions(payload, modeled, clauses, interpretations) {
         const suggestion = ruleSuggestion(payload, interpretation);
         if (!suggestion)
             continue;
-        const withProvenance = withClauseProvenance(suggestion, clause, mergedClaimKeys, statementOf(payload));
+        const withProvenance = withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, statementOf(payload), semanticSourceOf(payload).field);
         const key = withProvenance.kind === "rule"
             ? `${withProvenance.claim_key}:rule:${withProvenance.semantic_key}`
             : `${withProvenance.claim_key}:${withProvenance.kind}`;
@@ -275,9 +284,45 @@ function modelingSuggestions(payload, modeled, clauses, interpretations) {
     }
     return suggestions;
 }
-function withClauseProvenance(suggestion, clause, expectedClaimKeys, statement) {
+function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, statement, sourceField) {
     const clauseOffset = statement.indexOf(clause.text);
     const clauseSpan = utf8Span(statement || clause.text, clauseOffset >= 0 ? clauseOffset : 0, clauseOffset >= 0 ? clauseOffset + clause.text.length : clause.text.length);
+    const status = suggestion.kind === "ambiguity_observation"
+        ? "ambiguous"
+        : suggestion.kind === "ontology_gap"
+            ? "ontology_gap"
+            : "modeled";
+    let inventoryCursor = 0;
+    const semanticInventory = clauses.map((entry) => {
+        const located = propositionSpan(statement, entry, inventoryCursor);
+        inventoryCursor = located.next;
+        const role = propositionRole(entry.text, entry.normative);
+        const context = ["rationale", "example", "subjective"].includes(role);
+        const entryStatus = entry.index === clause.index
+            ? status
+            : context
+                ? "nonlogical"
+                : "missing";
+        return {
+            claim_key: entry.claim_key,
+            claim_text: entry.text,
+            role,
+            status: entryStatus,
+            span: located.span,
+            reason: entry.index === clause.index
+                ? status === "modeled"
+                    ? "Draft apply plan contains a typed grounding for this proposition."
+                    : suggestion.rationale
+                : context
+                    ? "Prose is retained for human context and is not a verifiable domain proposition."
+                    : "No typed grounding is included for this proposition in the current draft plan.",
+        };
+    });
+    const inventoryContract = {
+        version: "kibi.semantic-inventory.v1",
+        source_field: sourceField,
+        source_hash: semanticSourceHash(statement),
+    };
     const applyPlan = suggestion.applyPlan.map((step) => {
         if (!isRecord(step))
             return step;
@@ -288,32 +333,16 @@ function withClauseProvenance(suggestion, clause, expectedClaimKeys, statement)
             const existing = Array.isArray(properties.logic_claims)
                 ? properties.logic_claims.filter((value) => typeof value === "string")
                 : [];
-            const inventory = Array.isArray(properties.semantic_inventory)
-                ? properties.semantic_inventory.filter(isRecord)
-                : [];
-            const status = suggestion.kind === "ambiguity_observation"
-                ? "ambiguous"
-                : suggestion.kind === "ontology_gap"
-                    ? "ontology_gap"
-                    : "modeled";
             return {
                 ...step,
                 properties: {
                     ...properties,
                     logic_claims: Array.from(new Set([...existing, ...expectedClaimKeys])),
-                    semantic_inventory: [
-                        ...inventory.filter((entry) => entry.claim_key !== clause.claim_key),
-                        {
-                            claim_key: clause.claim_key,
-                            claim_text: clause.text,
-                            role: clause.normative ? "normative" : "descriptive",
-                            status,
-                            span: clauseSpan,
-                            reason: status === "modeled"
-                                ? "Draft apply plan contains a typed grounding for this proposition."
-                                : suggestion.rationale,
-                        },
-                    ],
+                    semantic_clauses: clauses.map(({ text }) => text),
+                    semantic_inventory_version: inventoryContract.version,
+                    semantic_source_field: inventoryContract.source_field,
+                    semantic_source_hash: inventoryContract.source_hash,
+                    semantic_inventory: semanticInventory,
                 },
             };
         }
@@ -342,16 +371,9 @@ function withClauseProvenance(suggestion, clause, expectedClaimKeys, statement)
                     claimKey: clause.claim_key,
                     claimText: clause.text,
                     logicClaims: expectedClaimKeys,
-                    semanticInventory: [
-                        {
-                            claim_key: clause.claim_key,
-                            claim_text: clause.text,
-                            role: clause.normative ? "normative" : "descriptive",
-                            status: "modeled",
-                            span: clauseSpan,
-                            reason: "The returned typed fact grounds this proposition.",
-                        },
-                    ],
+                    semanticClauses: clauses.map(({ text }) => text),
+                    semanticInventory,
+                    inventoryContract,
                     instructions: "Create the predicate fact, merge the returned logicClaims into the requirement logic_claims manifest, then add requires_predicate without overwriting other requirement metadata.",
                 },
             }
@@ -363,23 +385,16 @@ function withClauseProvenance(suggestion, clause, expectedClaimKeys, statement)
                     claimKey: clause.claim_key,
                     claimText: clause.text,
                     logicClaims: expectedClaimKeys,
-                    semanticInventory: [
-                        {
-                            claim_key: clause.claim_key,
-                            claim_text: clause.text,
-                            role: clause.normative ? "normative" : "descriptive",
-                            status: "modeled",
-                            span: clauseSpan,
-                            reason: "The returned typed rule grounds this proposition.",
-                        },
-                    ],
+                    semanticClauses: clauses.map(({ text }) => text),
+                    semanticInventory,
+                    inventoryContract,
                     instructions: "Create the rule_schema and rule facts, merge the returned logicClaims into the requirement logic_claims manifest, then add requires_rule without overwriting other requirement metadata.",
                 },
             }
             : {}),
     };
 }
-function unmatchedClauseSuggestion(payload, clause, expectedClaimKeys) {
+function unmatchedClauseSuggestion(payload, clause, clauses, expectedClaimKeys) {
     return withClauseProvenance({
         kind: "ontology_gap",
         claim_key: clause.claim_key,
@@ -394,7 +409,7 @@ function unmatchedClauseSuggestion(payload, clause, expectedClaimKeys) {
             "review:ontology-gap",
             "needs_schema_extension",
         ]),
-    }, clause, expectedClaimKeys, statementOf(payload));
+    }, clause, clauses, expectedClaimKeys, statementOf(payload), semanticSourceOf(payload).field);
 }
 function propositionRole(statement, normative) {
     if (/\b(?:for example|e\.g\.|such as|illustrative)\b/i.test(statement))
@@ -668,17 +683,17 @@ export function analyzeSemanticAdvisorInput(input) {
     const statement = statementOf(payload) || proseOf(payload);
     const signals = requirement ? detectSignals(proseOf(payload)) : [];
     const clauses = statement
-        ? extractSemanticClauses(statement, input.clauses)
+        ? extractSemanticClauses(statement, input.clauses ?? semanticClausesOf(payload))
         : [];
     const rawDeclaredClaims = propertiesOf(payload).logic_claims;
     const declaredClaims = Array.isArray(rawDeclaredClaims)
         ? rawDeclaredClaims.filter((value) => typeof value === "string")
         : [];
     const expectedClaims = clauses
-        .filter((clause) => clause.normative)
+        .filter((clause) => !["rationale", "example", "subjective"].includes(propositionRole(clause.text, clause.normative)))
         .map((clause) => clause.claim_key);
     const modeled = requirement &&
-        isModeled(payload, expectedClaims.length) &&
+        isModeled(payload, expectedClaims) &&
         expectedClaims.length > 0 &&
         expectedClaims.every((claimKey) => declaredClaims.includes(claimKey));
     const suggestions = modelingSuggestions(payload, modeled, clauses, input.interpretations);

package/dist/operations/semantic-advisor/clauses.d.ts

@@ -5,6 +5,7 @@ export type SemanticClause = Readonly<{
     normative: boolean;
     source: "detected" | "supplied";
 }>;
+export declare function normalizeSemanticClause(value: string): string;
 export declare function semanticClaimKey(text: string): string;
 export declare function extractSemanticClauses(text: string, suppliedClauses?: readonly string[]): readonly SemanticClause[];
 //# sourceMappingURL=clauses.d.ts.map

package/dist/operations/semantic-advisor/clauses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clauses.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/clauses.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACjC,CAAC,CAAC;AAkBH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrD;AAeD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAClC,SAAS,cAAc,EAAE,CAgB3B"}
+{"version":3,"file":"clauses.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/clauses.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACjC,CAAC,CAAC;AAKH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAW7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrD;AAeD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAClC,SAAS,cAAc,EAAE,CAgB3B"}

package/dist/operations/semantic-advisor/clauses.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 const NORMATIVE_PATTERN = /\b(?:must|shall|should|required|requires?|may\s+only|only\s+.+?\s+(?:may|can)|must\s+not|shall\s+not|cannot|can't|forbidden|denied|defaults?\s+to|before|unless|when|if)\b/i;
-function normalizeClause(value) {
+export function normalizeSemanticClause(value) {
     return (value
         .replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "")
         .replace(/\s+/g, " ")
@@ -11,7 +11,7 @@ function normalizeClause(value) {
         .trim());
 }
 export function semanticClaimKey(text) {
-    const normalized = normalizeClause(text).toLowerCase();
+    const normalized = normalizeSemanticClause(text).toLowerCase();
     const digest = createHash("sha256").update(normalized).digest("hex");
     return `CLAIM-${digest.slice(0, 16).toUpperCase()}`;
 }
@@ -23,21 +23,21 @@ function detectedClauses(text) {
             return [sentence];
         return sentence.split(/\s+(?:,\s*)?and\s+(?=(?:the\s+)?[a-z][^.!?]{0,100}\b(?:must|shall|should|requires?|cannot|can't|expire|default|transition|states?\s+are)\b)/i);
     })
-        .map(normalizeClause)
+        .map(normalizeSemanticClause)
         .filter(Boolean);
 }
 export function extractSemanticClauses(text, suppliedClauses) {
     const source = suppliedClauses === undefined ? "detected" : "supplied";
     const raw = suppliedClauses ?? detectedClauses(text);
-    const unique = Array.from(new Set(raw.map(normalizeClause).filter(Boolean)));
-    if (suppliedClauses !== undefined && unique.length === 0) {
+    const normalized = raw.map(normalizeSemanticClause).filter(Boolean);
+    if (suppliedClauses !== undefined && normalized.length === 0) {
         throw new Error("Semantic advisor clauses must contain at least one non-empty atomic claim");
     }
-    return unique.map((clause, index) => ({
+    return normalized.map((clause, index) => ({
         claim_key: semanticClaimKey(clause),
         text: clause,
         index,
-        normative: source === "supplied" || NORMATIVE_PATTERN.test(clause),
+        normative: NORMATIVE_PATTERN.test(clause),
         source,
     }));
 }

package/dist/operations/semantic-advisor/ingestion-boundary.d.ts

@@ -0,0 +1,18 @@
+import type { PrologPort } from "../../public/operations/runtime-types.js";
+import { type Payload } from "./shared.js";
+import type { SemanticAdvisorReceipt } from "./types.js";
+export interface SemanticInventoryBoundaryResult {
+    readonly applicable: boolean;
+    readonly errors: readonly string[];
+    readonly sourceHash: string;
+}
+type SemanticRelationship = Readonly<{
+    type?: unknown;
+    from?: unknown;
+    to?: unknown;
+}>;
+export declare function validateSemanticInventoryBoundary(payload: Payload, relationships: readonly SemanticRelationship[], receipt: SemanticAdvisorReceipt): SemanticInventoryBoundaryResult;
+export declare function assertSemanticInventoryBoundary(payload: Payload, relationships: readonly SemanticRelationship[], receipt: SemanticAdvisorReceipt): void;
+export declare function assertLogicalGroundingClaimKeys(prolog: PrologPort, payload: Payload, relationships: readonly SemanticRelationship[]): Promise<void>;
+export {};
+//# sourceMappingURL=ingestion-boundary.d.ts.map

package/dist/operations/semantic-advisor/ingestion-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion-boundary.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/ingestion-boundary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAE3E,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,sBAAsB,EAAuB,MAAM,YAAY,CAAC;AAgB9E,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,KAAK,oBAAoB,GAAG,QAAQ,CAAC;IACnC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;CACd,CAAC,CAAC;AAgCH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,+BAA+B,CAmIjC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAWN;AAGD,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,GAC7C,OAAO,CAAC,IAAI,CAAC,CA+Cf"}

package/dist/operations/semantic-advisor/ingestion-boundary.js

@@ -0,0 +1,167 @@
+import { escapeAtom } from "../../prolog/codec.js";
+import { semanticClaimKey } from "./clauses.js";
+import { SEMANTIC_INVENTORY_VERSION, isRecord, propertiesOf, semanticSourceHash, semanticSourceOf, stringValue, } from "./shared.js";
+const CURRENT_REQUIREMENT_STATUSES = new Set([
+    "open",
+    "in_progress",
+    "closed",
+    "active",
+    "approved",
+]);
+const CONTEXT_ROLES = new Set(["rationale", "example", "subjective"]);
+const LOGICAL_RELATIONSHIPS = new Set([
+    "requires_property",
+    "requires_predicate",
+    "requires_rule",
+]);
+function inventoryOf(payload) {
+    const raw = propertiesOf(payload).semantic_inventory;
+    return Array.isArray(raw) ? raw.filter(isRecord) : [];
+}
+function exactSpanText(source, span) {
+    const start = span.start;
+    const end = span.end;
+    if (typeof start !== "number" ||
+        typeof end !== "number" ||
+        !Number.isInteger(start) ||
+        !Number.isInteger(end) ||
+        start < 0 ||
+        end <= start)
+        return null;
+    const bytes = Buffer.from(source, "utf8");
+    if (end > bytes.length)
+        return null;
+    return bytes.subarray(start, end).toString("utf8");
+}
+function propositionIsAssertive(proposition) {
+    return !CONTEXT_ROLES.has(proposition.role);
+}
+// implements REQ-kibi-proposition-complete-ingestion
+export function validateSemanticInventoryBoundary(payload, relationships, receipt) {
+    const properties = propertiesOf(payload);
+    const semanticSource = semanticSourceOf(payload);
+    const sourceHash = semanticSourceHash(semanticSource.text);
+    const currentRequirement = stringValue(payload.type) === "req" &&
+        CURRENT_REQUIREMENT_STATUSES.has(stringValue(properties.status));
+    const assertive = receipt.propositions.filter(propositionIsAssertive);
+    const applicable = currentRequirement &&
+        semanticSource.text.length > 0 &&
+        (semanticSource.field !== "title" ||
+            assertive.some(({ role }) => role === "normative"));
+    if (!applicable)
+        return { applicable, errors: [], sourceHash };
+    const errors = [];
+    if (properties.semantic_inventory_version !== SEMANTIC_INVENTORY_VERSION) {
+        errors.push(`semantic_inventory_version must be '${SEMANTIC_INVENTORY_VERSION}'`);
+    }
+    if (properties.semantic_source_field !== semanticSource.field) {
+        errors.push(`semantic_source_field must be '${semanticSource.field}' for the current requirement prose`);
+    }
+    if (properties.semantic_source_hash !== sourceHash) {
+        errors.push(`semantic_source_hash must equal the SHA-256 hash of ${semanticSource.field} (expected '${sourceHash}')`);
+    }
+    const inventory = inventoryOf(payload);
+    if (!Array.isArray(properties.semantic_inventory)) {
+        errors.push("semantic_inventory must contain one entry for every advisor proposition");
+    }
+    if (inventory.length !== receipt.propositions.length) {
+        errors.push(`semantic_inventory must contain exactly ${receipt.propositions.length} proposition(s); received ${inventory.length}`);
+    }
+    const seenKeys = new Set();
+    const seenSpans = new Set();
+    for (const [index, entry] of inventory.entries()) {
+        const expected = receipt.propositions[index];
+        const claimKey = stringValue(entry.claim_key);
+        const claimText = stringValue(entry.claim_text);
+        const role = stringValue(entry.role);
+        const status = stringValue(entry.status);
+        const span = isRecord(entry.span) ? entry.span : {};
+        const start = span.start;
+        const end = span.end;
+        const spanKey = `${String(start)}:${String(end)}`;
+        if (seenKeys.has(claimKey))
+            errors.push(`semantic_inventory has duplicate claim_key '${claimKey}'`);
+        seenKeys.add(claimKey);
+        if (seenSpans.has(spanKey))
+            errors.push(`semantic_inventory has duplicate span '${spanKey}'`);
+        seenSpans.add(spanKey);
+        const derivedKey = semanticClaimKey(claimText);
+        if (claimKey !== derivedKey) {
+            errors.push(`semantic_inventory[${index}].claim_key must match claim_text (expected '${derivedKey}')`);
+        }
+        const sliced = exactSpanText(semanticSource.text, span);
+        if (sliced !== claimText) {
+            errors.push(`semantic_inventory[${index}].span must select its exact claim_text from ${semanticSource.field}`);
+        }
+        if (expected &&
+            (claimKey !== expected.claim_key ||
+                claimText !== expected.claim_text ||
+                role !== expected.role ||
+                start !== expected.span.start ||
+                end !== expected.span.end)) {
+            errors.push(`semantic_inventory[${index}] does not match advisor proposition '${expected.claim_key}'`);
+        }
+        const contextRole = CONTEXT_ROLES.has(role);
+        if (contextRole && status !== "nonlogical") {
+            errors.push(`semantic_inventory[${index}] role '${role}' must use status 'nonlogical'`);
+        }
+        if (!contextRole && status === "nonlogical") {
+            errors.push(`semantic_inventory[${index}] assertive role '${role}' cannot use status 'nonlogical'`);
+        }
+    }
+    const declaredClaims = Array.isArray(properties.logic_claims)
+        ? properties.logic_claims.filter((value) => typeof value === "string")
+        : [];
+    const expectedClaims = assertive.map(({ claim_key }) => claim_key);
+    if (declaredClaims.length !== expectedClaims.length ||
+        expectedClaims.some((claimKey) => !declaredClaims.includes(claimKey))) {
+        errors.push("logic_claims must contain exactly every assertive semantic_inventory claim_key");
+    }
+    const modeledCount = inventory.filter(({ status }) => status === "modeled").length;
+    const groundingCount = relationships.filter((relationship) => relationship.from === payload.id &&
+        LOGICAL_RELATIONSHIPS.has(stringValue(relationship.type))).length;
+    if (modeledCount !== groundingCount) {
+        errors.push(`modeled semantic_inventory entries (${modeledCount}) must equal logical grounding relationships (${groundingCount})`);
+    }
+    return { applicable, errors, sourceHash };
+}
+export function assertSemanticInventoryBoundary(payload, relationships, receipt) {
+    const result = validateSemanticInventoryBoundary(payload, relationships, receipt);
+    if (result.errors.length > 0) {
+        throw new Error(`Proposition-complete ingestion failed: ${result.errors.join("; ")}. Run kb_semantic_advisor with the complete prose and preserve its inventory contract before retrying.`);
+    }
+}
+// implements REQ-kibi-proposition-complete-ingestion
+export async function assertLogicalGroundingClaimKeys(prolog, payload, relationships) {
+    if (stringValue(payload.type) !== "req")
+        return;
+    if (propertiesOf(payload).semantic_inventory_version !==
+        SEMANTIC_INVENTORY_VERSION)
+        return;
+    const modeledClaimKeys = inventoryOf(payload)
+        .filter(({ status }) => status === "modeled")
+        .map(({ claim_key }) => stringValue(claim_key));
+    const groundedClaimKeys = [];
+    for (const relationship of relationships) {
+        if (relationship.from !== payload.id ||
+            !LOGICAL_RELATIONSHIPS.has(stringValue(relationship.type)))
+            continue;
+        const target = stringValue(relationship.to);
+        const result = await prolog.query(`once((kb_entity('${escapeAtom(target)}', fact, _SemanticGroundProps), memberchk(claim_key=_SemanticGroundRaw, _SemanticGroundProps), normalize_term_atom(_SemanticGroundRaw, ClaimKey)))`);
+        const claimKey = result.success
+            ? stringValue(result.bindings.ClaimKey).replace(/^['"]|['"]$/g, "")
+            : "";
+        if (!claimKey) {
+            throw new Error(`Proposition-complete ingestion failed: logical grounding target '${target}' must declare a claim_key.`);
+        }
+        groundedClaimKeys.push(claimKey);
+    }
+    const duplicate = groundedClaimKeys.find((claimKey, index) => groundedClaimKeys.indexOf(claimKey) !== index);
+    if (duplicate) {
+        throw new Error(`Proposition-complete ingestion failed: claim '${duplicate}' has more than one logical grounding relationship.`);
+    }
+    if (groundedClaimKeys.length !== modeledClaimKeys.length ||
+        modeledClaimKeys.some((claimKey) => !groundedClaimKeys.includes(claimKey))) {
+        throw new Error("Proposition-complete ingestion failed: modeled proposition claim_keys must match logical grounding target claim_keys exactly.");
+    }
+}

package/dist/operations/semantic-advisor/shared.d.ts

@@ -1,10 +1,18 @@
 import type { SemanticModelingSuggestion, SemanticStrictPropertyClaim } from "./types.js";
 export type Payload = Readonly<Record<string, unknown>>;
 export type MatchGroups = Readonly<Record<string, string | undefined>>;
+export declare const SEMANTIC_INVENTORY_VERSION = "kibi.semantic-inventory.v1";
+export type SemanticSourceField = "semantic_text" | "text_ref" | "title";
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function stringValue(value: unknown): string;
 export declare function canonicalize(value: unknown): string;
 export declare function payloadHash(payload: Payload): string;
+export declare function semanticSourceOf(payload: Payload): {
+    readonly field: SemanticSourceField;
+    readonly text: string;
+};
+export declare function semanticSourceHash(text: string): string;
+export declare function semanticClausesOf(payload: Payload): readonly string[] | undefined;
 export declare function shortHash(value: string): string;
 export declare function propertiesOf(payload: Payload): Record<string, unknown>;
 export declare function statementOf(payload: Payload): string;

package/dist/operations/semantic-advisor/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAE1B,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AAGvE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CASnD;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAKpD;AAGD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtE;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGpD;AAGD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAIjD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAGD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,2BAA2B,EAClC,SAAS,EAAE,MAAM,EACjB,UAAU,SAAM,GACf,0BAA0B,CAqF5B;AAGD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,QAAQ,GAAG,MAAiB,GACrC,0BAA0B,CA+C5B"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,0BAA0B,EAE1B,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AACvE,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,UAAU,GAAG,OAAO,CAAC;AAGzE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CASnD;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAKpD;AAGD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG;IAClD,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAmBA;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,GACf,SAAS,MAAM,EAAE,GAAG,SAAS,CAO/B;AAGD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtE;AAGD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAEpD;AAGD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAIjD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAGD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,2BAA2B,EAClC,SAAS,EAAE,MAAM,EACjB,UAAU,SAAM,GACf,0BAA0B,CA0F5B;AAGD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,QAAQ,GAAG,MAAiB,GACrC,0BAA0B,CA+C5B"}

package/dist/operations/semantic-advisor/shared.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { semanticClaimKey } from "./clauses.js";
+export const SEMANTIC_INVENTORY_VERSION = "kibi.semantic-inventory.v1";
 // implements REQ-mcp-semantic-advisor-preflight
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -25,6 +26,35 @@ export function payloadHash(payload) {
     const stable = Object.fromEntries(Object.entries(payload).filter(([key]) => !key.startsWith("_")));
     return createHash("sha256").update(canonicalize(stable)).digest("hex");
 }
+// implements REQ-kibi-legacy-migration-preview-v2
+export function semanticSourceOf(payload) {
+    const properties = propertiesOf(payload);
+    const declaredField = stringValue(properties.semantic_source_field);
+    if (declaredField === "semantic_text" ||
+        declaredField === "text_ref" ||
+        declaredField === "title") {
+        return {
+            field: declaredField,
+            text: stringValue(properties[declaredField]),
+        };
+    }
+    const semanticText = stringValue(properties.semantic_text);
+    if (semanticText)
+        return { field: "semantic_text", text: semanticText };
+    const textRef = stringValue(properties.text_ref);
+    return textRef
+        ? { field: "text_ref", text: textRef }
+        : { field: "title", text: stringValue(properties.title) };
+}
+export function semanticSourceHash(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+export function semanticClausesOf(payload) {
+    const value = propertiesOf(payload).semantic_clauses;
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((clause) => typeof clause === "string" && clause.trim().length > 0);
+}
 // implements REQ-mcp-semantic-advisor-preflight
 export function shortHash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 12);
@@ -35,8 +65,7 @@ export function propertiesOf(payload) {
 }
 // implements REQ-mcp-semantic-advisor-preflight
 export function statementOf(payload) {
-    const properties = propertiesOf(payload);
-    return stringValue(properties.text_ref) || stringValue(properties.title);
+    return semanticSourceOf(payload).text;
 }
 // implements REQ-mcp-semantic-advisor-preflight
 export function sourceOf(payload) {
@@ -77,6 +106,7 @@ export function relationship(from, to, type) {
 // implements REQ-mcp-semantic-advisor-preflight
 export function strictSuggestion(payload, evidence, claim, rationale, confidence = 0.9) {
     const claimText = statementOf(payload);
+    const semanticSource = semanticSourceOf(payload);
     const reqId = stringValue(payload.id) || `REQ-SEMANTIC-${shortHash(claim.subject_key)}`;
     const subjectId = `FACT-SUBJECT-${shortHash(claim.subject_key)}`;
     const propertyId = `FACT-PROP-${shortHash(`${claim.subject_key}.${claim.property_key}.${claim.operator}.${canonicalize(claim)}`)}`;
@@ -147,7 +177,11 @@ export function strictSuggestion(payload, evidence, claim, rationale, confidence
                         "Semantic advisor requirement suggestion",
                     status: "open",
                     source,
-                    text_ref: statementOf(payload),
+                    ...(semanticSource.field === "semantic_text"
+                        ? { semantic_text: statementOf(payload) }
+                        : semanticSource.field === "text_ref"
+                            ? { text_ref: statementOf(payload) }
+                            : {}),
                     tags: ["semantic-advisor-suggestion"],
                 },
                 relationships: [

package/dist/operations/semantic-advisor/types.d.ts

@@ -137,6 +137,11 @@ export type SemanticModelingSuggestion = {
 export interface SemanticAdvisorReceipt {
     readonly version: string;
     readonly payload_hash: string;
+    readonly inventory_contract: {
+        readonly version: "kibi.semantic-inventory.v1";
+        readonly source_field: "semantic_text" | "text_ref" | "title";
+        readonly source_hash: string;
+    };
     readonly logic_readiness: SemanticAdvisorReadiness;
     readonly candidate_lane: SemanticAdvisorLane;
     readonly signals: readonly SemanticSignal[];