kibi-cli 0.19.0 → 2.0.0

package/dist/operations/proof/receipt-document.js

@@ -0,0 +1,117 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { dump as dumpYaml } from "js-yaml";
+/**
+ * Remove a top-level frontmatter block (`key:` plus its nested lines) from a
+ * markdown document, leaving every other byte untouched. Returns the patched
+ * content, or null when the content is not a well-formed frontmatter
+ * document the remover can safely splice.
+ *
+ * Used by proof maintenance to drop legacy `verification_receipts` blocks
+ * once a `proof_contract` exists, without canonicalizing the document.
+ */
+// implements REQ-kibi-proof-evidence-protocol
+export function removeFrontmatterBlock(content, key) {
+    const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    if (lines.length === 0 || lines[0]?.trim() !== "---")
+        return null;
+    let closingIndex = -1;
+    for (let index = 1; index < lines.length; index++) {
+        if (lines[index]?.trim() === "---") {
+            closingIndex = index;
+            break;
+        }
+    }
+    if (closingIndex === -1)
+        return null;
+    let blockStart = -1;
+    let blockEnd = closingIndex;
+    for (let index = 1; index < closingIndex; index++) {
+        if (new RegExp(`^${key}\\s*:`).test(lines[index] ?? "")) {
+            blockStart = index;
+            break;
+        }
+    }
+    if (blockStart === -1)
+        return null;
+    for (let index = blockStart + 1; index < closingIndex; index++) {
+        const line = lines[index] ?? "";
+        if (/^[A-Za-z_][A-Za-z0-9_-]*\s*:/.test(line)) {
+            blockEnd = index;
+            break;
+        }
+    }
+    return [...lines.slice(0, blockStart), ...lines.slice(blockEnd)].join("");
+}
+/**
+ * Patch the `proof_receipts` frontmatter block of an authored test document
+ * without re-rendering anything else.
+ *
+ * Receipt ingest used to route every append through the canonical entity
+ * renderer, which re-dumps the whole frontmatter: inline tag lists became
+ * block lists, timestamps gained milliseconds, and so on. Those non-receipt
+ * edits are not stripped by the workspace snapshotter, so the snapshot hash
+ * changed on the first ingest that touched a hand-authored document and every
+ * later integration in the same `kibi prove --all` run refused with
+ * "changed the tracked workspace". This patcher splices ONLY the receipts
+ * block, leaving the rest of the document byte-for-byte identical.
+ *
+ * Returns null when the content is not a well-formed frontmatter document the
+ * patcher can safely splice; the caller then falls back to the canonical
+ * render.
+ */
+// implements REQ-kibi-proof-evidence-protocol
+export function patchReceiptsIntoDocument(content, receipts) {
+    const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    if (lines.length === 0 || lines[0]?.trim() !== "---")
+        return null;
+    let closingIndex = -1;
+    for (let index = 1; index < lines.length; index++) {
+        if (lines[index]?.trim() === "---") {
+            closingIndex = index;
+            break;
+        }
+    }
+    if (closingIndex === -1)
+        return null;
+    let receiptsStart = -1;
+    let receiptsEnd = closingIndex;
+    for (let index = 1; index < closingIndex; index++) {
+        if (/^proof_receipts\s*:/.test(lines[index] ?? "")) {
+            receiptsStart = index;
+            break;
+        }
+    }
+    if (receiptsStart !== -1) {
+        for (let index = receiptsStart + 1; index < closingIndex; index++) {
+            const line = lines[index] ?? "";
+            if (/^[A-Za-z_][A-Za-z0-9_-]*\s*:/.test(line)) {
+                receiptsEnd = index;
+                break;
+            }
+        }
+    }
+    const block = dumpYaml({ proof_receipts: receipts.map((receipt) => ({ ...receipt })) }, { noRefs: true, lineWidth: -1, sortKeys: false });
+    const blockLines = block.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    const spliced = [
+        ...lines.slice(0, receiptsStart === -1 ? closingIndex : receiptsStart),
+        ...blockLines,
+        ...lines.slice(receiptsEnd),
+    ];
+    return spliced.join("");
+}

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

@@ -1,5 +1,6 @@
 import type { SemanticAdvisorAnalysisResult, SemanticAdvisorInput } from "./types.js";
 export declare const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
 export { semanticClaimKey } from "./clauses.js";
+export declare function stringLogicClaims(value: unknown): string[];
 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":"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"}
+{"version":3,"file":"analyze-prose.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analyze-prose.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAWrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,wBAAwB,wBAAwB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEhD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAI1D;AAo3BD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CA+D/B"}

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

@@ -5,6 +5,7 @@ import { extractSemanticClauses, semanticClaimKey, } from "./clauses.js";
 import { observationPlan } from "./observation-plan.js";
 import { detectPredicateRules } from "./predicate-rule.js";
 import { CORE_PREDICATE_RULES } from "./predicate-rules-core.js";
+import { LAUNCHER_PREDICATE_RULES } from "./predicate-rules-launcher.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";
@@ -12,6 +13,11 @@ import { isRecord, payloadHash, propertiesOf, relationship, semanticClausesOf, s
 import { detectStrictSuggestion } from "./strict-rules.js";
 export const SEMANTIC_ADVISOR_VERSION = "semantic-advisor-v2";
 export { semanticClaimKey } from "./clauses.js";
+export function stringLogicClaims(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
 const SIGNAL_PATTERNS = [
     {
         kind: "numeric_cardinality",
@@ -47,7 +53,9 @@ const SIGNAL_PATTERNS = [
         kind: "normative_modal",
         candidateLane: "observation_review",
         confidence: 0.65,
-        pattern: /\b(?:must|shall|should|may|must\s+not|cannot|can't)\b/i,
+        // Modal-free validity, rejection, prohibition, and failure-outcome
+        // assertions are normative even when they omit must/shall.
+        pattern: /\b(?:must|shall|should|may|must\s+not|cannot|can't|invalid|unresolved|reject(?:ed|ion)?|prohibited|forbidden|fail(?:s|ed|ure)?\s+(?:clearly|explicitly|with)|required\s+outcome)\b/i,
     },
 ];
 function proseOf(payload) {
@@ -161,7 +169,8 @@ function ontologyGapSuggestion(payload, statement) {
     };
 }
 function predicateSuggestion(payload, statement) {
-    return (detectPredicateRules(payload, statement, CORE_PREDICATE_RULES) ??
+    return (detectPredicateRules(payload, statement, LAUNCHER_PREDICATE_RULES) ??
+        detectPredicateRules(payload, statement, CORE_PREDICATE_RULES) ??
         detectPredicateRules(payload, statement, POLICY_PREDICATE_RULES) ??
         detectPredicateRules(payload, statement, PRODUCT_PREDICATE_RULES) ??
         detectPredicateRules(payload, statement, PRODUCT_TAIL_PREDICATE_RULES));
@@ -285,8 +294,9 @@ function modelingSuggestions(payload, modeled, clauses, interpretations) {
     return suggestions;
 }
 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 clauseLocation = propositionSpan(statement, clause, 0);
+    const clauseText = clauseLocation.sourceText;
+    const clauseSpan = clauseLocation.span;
     const status = suggestion.kind === "ambiguity_observation"
         ? "ambiguous"
         : suggestion.kind === "ontology_gap"
@@ -305,7 +315,7 @@ function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, st
                 : "missing";
         return {
             claim_key: entry.claim_key,
-            claim_text: entry.text,
+            claim_text: located.sourceText,
             role,
             status: entryStatus,
             span: located.span,
@@ -330,9 +340,7 @@ function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, st
         if (properties === null)
             return step;
         if (step.type === "req") {
-            const existing = Array.isArray(properties.logic_claims)
-                ? properties.logic_claims.filter((value) => typeof value === "string")
-                : [];
+            const existing = stringLogicClaims(properties.logic_claims);
             return {
                 ...step,
                 properties: {
@@ -353,7 +361,7 @@ function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, st
             properties: {
                 ...properties,
                 claim_key: clause.claim_key,
-                claim_text: clause.text,
+                claim_text: clauseText,
                 claim_span_start: clauseSpan.start,
                 claim_span_end: clauseSpan.end,
             },
@@ -362,14 +370,14 @@ function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, st
     return {
         ...suggestion,
         claim_key: clause.claim_key,
-        claim_text: clause.text,
+        claim_text: clauseText,
         applyPlan,
         ...(suggestion.kind === "predicate" && suggestion.relationshipPlan !== null
             ? {
                 relationshipPlan: {
                     ...suggestion.relationshipPlan,
                     claimKey: clause.claim_key,
-                    claimText: clause.text,
+                    claimText: clauseText,
                     logicClaims: expectedClaimKeys,
                     semanticClauses: clauses.map(({ text }) => text),
                     semanticInventory,
@@ -383,7 +391,7 @@ function withClauseProvenance(suggestion, clause, clauses, expectedClaimKeys, st
                 relationshipPlan: {
                     ...suggestion.relationshipPlan,
                     claimKey: clause.claim_key,
-                    claimText: clause.text,
+                    claimText: clauseText,
                     logicClaims: expectedClaimKeys,
                     semanticClauses: clauses.map(({ text }) => text),
                     semanticInventory,
@@ -550,12 +558,36 @@ function shadowAnalysis(text, interpretations) {
     }));
 }
 function propositionSpan(text, clause, cursor) {
-    const exact = text.indexOf(clause.text, cursor);
+    const located = locateSourceText(text, clause.text, cursor);
+    return {
+        span: utf8Span(text, located.start, located.end),
+        next: Math.max(cursor, located.end),
+        sourceText: text.slice(located.start, located.end),
+    };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Locate canonical claim text while accepting source-only whitespace layout.
+ * The caller receives the authored slice so strict ingestion can compare the
+ * span with the claim text without rewriting the source document.
+ */
+function locateSourceText(source, claimText, cursor) {
+    const canonicalPattern = escapeRegExp(claimText).replace(/\s+/g, "\\s+");
+    const match = new RegExp(canonicalPattern).exec(source.slice(cursor));
+    if (match?.index !== undefined) {
+        const start = cursor + match.index;
+        return { start, end: start + match[0].length };
+    }
+    const exact = source.indexOf(claimText, cursor);
     const start = exact >= 0 ? exact : cursor;
-    const end = exact >= 0
-        ? exact + clause.text.length
-        : Math.min(text.length, start + clause.text.length);
-    return { span: utf8Span(text, start, end), next: Math.max(cursor, end) };
+    return {
+        start,
+        end: exact >= 0
+            ? exact + claimText.length
+            : Math.min(source.length, start + claimText.length),
+    };
 }
 function interpretationResults(interpretations, clauses, statement) {
     if (interpretations === undefined)
@@ -578,16 +610,8 @@ function interpretationResults(interpretations, clauses, statement) {
             (candidate.span.start < 0 || candidate.span.end < candidate.span.start))
             errors.push("interpretation span is invalid");
         if (clause && candidate.span) {
-            const candidateStart = statement.indexOf(candidate.claim_text);
-            const clauseStart = statement.indexOf(clause.text);
-            const sourceStart = candidateStart >= 0 ? candidateStart : clauseStart;
-            const sourceEnd = sourceStart >= 0
-                ? sourceStart +
-                    (candidateStart >= 0
-                        ? candidate.claim_text.length
-                        : clause.text.length)
-                : 0;
-            const expectedSpan = utf8Span(statement, Math.max(0, sourceStart), Math.max(0, sourceEnd));
+            const candidateLocation = locateSourceText(statement, candidate.claim_text, 0);
+            const expectedSpan = utf8Span(statement, candidateLocation.start, candidateLocation.end);
             if (candidate.span.start !== expectedSpan.start ||
                 candidate.span.end !== expectedSpan.end)
                 errors.push(`interpretation span for ${candidate.claim_key} does not match the exact UTF-8 proposition span`);
@@ -667,7 +691,7 @@ function propositionInventory(statement, clauses, suggestions, interpretations,
         }
         return {
             claim_key: clause.claim_key,
-            claim_text: clause.text,
+            claim_text: located.sourceText,
             role,
             status,
             span: located.span,

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;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"}
+{"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;AA4BD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,GAClC,SAAS,cAAc,EAAE,CA4B3B"}

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

@@ -1,5 +1,5 @@
 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;
+const NORMATIVE_PATTERN = /\b(?:must|shall|should|required|requires?|may\s+only|may\s+(?:have\s+)?(?:at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to)|only\s+.+?\s+(?:may|can)|must\s+not|shall\s+not|cannot|can't|denied|forbidden|prohibited|(?:is|are|be|become|becomes|remain|remains)\s+(?:invalid|rejected|prohibited|forbidden)|(?:reject|rejects|rejected|rejection)\s+(?:invalid|unresolved|ambiguous)|fail(?:s|ed)?\s+(?:clearly|explicitly|with)|expires?\s+(?:after|within|in)|failure\s+(?:behavior|policy|outcome)|error\s+(?:handling|behavior|policy|outcome)|required\s+outcome|defaults?\s+to|before|unless|when|if)\b/i;
 export function normalizeSemanticClause(value) {
     return (value
         .replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "")
@@ -21,7 +21,20 @@ function detectedClauses(text) {
         .flatMap((sentence) => {
         if (/\bmutually\s+exclusive\b/i.test(sentence))
             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);
+        // Package-resolution lists often join two noun phrases with "and"
+        // before the actual exception clause. Keep this launcher contract
+        // atomic so "exports-restricted and pnpm-style layouts" is not
+        // mistaken for a second proposition.
+        if (/\bconsumer-scoped\s+Node\s+package\s+semantics\b/i.test(sentence))
+            return [sentence];
+        const conjunctionParts = sentence.split(/\s+(?:,\s*)?and\s+(?=(?:the\s+)?[a-z][^.!?]{0,140}\b(?:must|shall|should|requires?|cannot|can't|expire|default|transition|states?\s+are|invalid|unresolved|reject(?:ed|ion)?\s+(?:invalid|unresolved|ambiguous)|fail(?:s|ed)?\s+(?:clearly|explicitly|with)|failure\s+(?:behavior|policy|outcome)|error\s+(?:handling|behavior|policy|outcome)|prohibited|forbidden|required\s+outcome)\b)/i);
+        // A coordinated subject such as "Analytics and Sentry must..." is one
+        // proposition. Split only when every resulting fragment independently
+        // carries normative or validity intent.
+        return conjunctionParts.length > 1 &&
+            conjunctionParts.every((part) => NORMATIVE_PATTERN.test(part))
+            ? conjunctionParts
+            : [sentence];
     })
         .map(normalizeSemanticClause)
         .filter(Boolean);
@@ -33,11 +46,24 @@ export function extractSemanticClauses(text, suppliedClauses) {
     if (suppliedClauses !== undefined && normalized.length === 0) {
         throw new Error("Semantic advisor clauses must contain at least one non-empty atomic claim");
     }
-    return normalized.map((clause, index) => ({
-        claim_key: semanticClaimKey(clause),
-        text: clause,
-        index,
-        normative: NORMATIVE_PATTERN.test(clause),
-        source,
-    }));
+    // A repeated sentence has one logical identity. Keep the first source
+    // occurrence for its source span and provenance; retaining repeated claim
+    // keys would make the inventory impossible to persist because logic_claims
+    // is a set-like manifest and grounding is one-to-one.
+    const seen = new Set();
+    return normalized.flatMap((clause, index) => {
+        const identity = clause.toLowerCase();
+        if (seen.has(identity))
+            return [];
+        seen.add(identity);
+        return [
+            {
+                claim_key: semanticClaimKey(clause),
+                text: clause,
+                index,
+                normative: NORMATIVE_PATTERN.test(clause),
+                source,
+            },
+        ];
+    });
 }

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

@@ -1 +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"}
+{"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,CA0IjC;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

@@ -118,10 +118,14 @@ export function validateSemanticInventoryBoundary(payload, relationships, receip
         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;
+    const groundingRelationships = relationships.filter((relationship) => relationship.from === payload.id &&
+        LOGICAL_RELATIONSHIPS.has(stringValue(relationship.type)));
+    const groundingCount = groundingRelationships.length;
     if (modeledCount !== groundingCount) {
-        errors.push(`modeled semantic_inventory entries (${modeledCount}) must equal logical grounding relationships (${groundingCount})`);
+        const groundingTargets = groundingRelationships
+            .map((relationship) => `${stringValue(relationship.type)}->${stringValue(relationship.to)}`)
+            .join(", ");
+        errors.push(`modeled semantic_inventory entries (${modeledCount}) must equal logical grounding relationships (${groundingCount})${groundingTargets ? ` [${groundingTargets}]` : ""}`);
     }
     return { applicable, errors, sourceHash };
 }

package/dist/operations/semantic-advisor/predicate-rules-launcher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Launcher contracts are deliberately matched as complete, domain-specific
+ * propositions. Generic words such as "error" or "workspace" are not enough
+ * to route a requirement into this family.
+ */
+export declare const LAUNCHER_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "dependency_resolution_policy";
+    readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Consumer-local dependency resolution and acquisition restrictions are a reusable launcher policy predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "ordered_resolution_strategy";
+    readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "An ordered workspace candidate list with a validated cwd fallback is a deterministic resolution strategy.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "resolution_failure_policy";
+    readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Invalid unresolved placeholders are an explicit resolution failure condition.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "resolution_failure_policy";
+    readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Ambiguous usable roots require a deterministic, clearly reported resolution failure.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "exception_rule";
+    readonly args: () => string[];
+    readonly rationale: "Consumer-scoped package resolution with an explicitly authorized package-manager exception is an exception policy.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "process_delegation_contract";
+    readonly args: () => string[];
+    readonly rationale: "Executable, cwd, environment, stdio, and termination propagation form a reusable process delegation contract.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "failure_behavior";
+    readonly args: () => string[];
+    readonly rationale: "A missing project-local dependency with an actionable error is a reusable launcher failure behavior.";
+}];
+/**
+ * Return the reviewed argument tuple for an exact launcher proposition.
+ *
+ * The modeling route uses this same rule table as the semantic advisor so an
+ * inferred apply plan cannot silently drift from the canonical ontology
+ * interpretation. Non-exact prose deliberately returns null and must remain
+ * reviewable through explicit argument bindings.
+ */
+export declare function exactLauncherPredicateArgs(predicateName: string, text: string): readonly string[] | null;
+//# sourceMappingURL=predicate-rules-launcher.d.ts.map

package/dist/operations/semantic-advisor/predicate-rules-launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-launcher.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-launcher.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFQ,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GACX,SAAS,MAAM,EAAE,GAAG,IAAI,CAO1B"}

package/dist/operations/semantic-advisor/predicate-rules-launcher.js

@@ -0,0 +1,96 @@
+import { normalizeKey, normalizePredicateToken, } from "./predicate-rule.js";
+/**
+ * Launcher contracts are deliberately matched as complete, domain-specific
+ * propositions. Generic words such as "error" or "workspace" are not enough
+ * to route a requirement into this family.
+ */
+export const LAUNCHER_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+must\s+resolve\s+and\s+execute\s+the\s+(?<dependency>.+?)\s+without\s+downloading\s+packages\s+or\s+using\s+a\s+global\s+or\s+plugin-local\s+runtime\.?$/i,
+        name: "dependency_resolution_policy",
+        args: (groups) => [
+            normalizeKey(groups.subject ?? ""),
+            normalizePredicateToken(groups.dependency ?? "dependency"),
+            "consumer_local",
+            "no_download",
+        ],
+        rationale: "Consumer-local dependency resolution and acquisition restrictions are a reusable launcher policy predicate.",
+    },
+    {
+        pattern: /^it\s+must\s+resolve\s+the\s+consumer\s+workspace\s+in\s+deterministic\s+order:\s*(?<sources>.+?)\s+then\s+cwd\s+only\s+when\s+(?<condition>.+?)\.?$/i,
+        name: "ordered_resolution_strategy",
+        args: (groups) => [
+            "launcher",
+            normalizePredicateToken(groups.sources ?? "ordered_sources"),
+            normalizePredicateToken(groups.condition ?? "cwd_requires_validation"),
+        ],
+        rationale: "An ordered workspace candidate list with a validated cwd fallback is a deterministic resolution strategy.",
+    },
+    {
+        pattern: /^(?<condition>unresolved\s+placeholders?)\s+are\s+invalid\.?$/i,
+        name: "resolution_failure_policy",
+        args: (groups) => [
+            "launcher",
+            normalizePredicateToken(groups.condition ?? "invalid_placeholder"),
+            "reject_input",
+        ],
+        rationale: "Invalid unresolved placeholders are an explicit resolution failure condition.",
+    },
+    {
+        pattern: /^(?<condition>ambiguous\s+(?:multiple\s+)?usable\s+roots?)\s+fail\s+clearly\.?$/i,
+        name: "resolution_failure_policy",
+        args: (groups) => [
+            "launcher",
+            normalizePredicateToken(groups.condition ?? "ambiguous_root"),
+            "clear_error",
+        ],
+        rationale: "Ambiguous usable roots require a deterministic, clearly reported resolution failure.",
+    },
+    {
+        pattern: /^(?<subject>the\s+launcher)\s+must\s+resolve\s+kibi-mcp\s+through\s+consumer-scoped\s+node\s+package\s+semantics\s+including\s+exports-restricted\s+and\s+pnpm-style\s+layouts,\s+and\s+reject\s+packages\s+outside\s+consumer\s+scope\s+unless\s+active\s+package-manager\s+semantics\s+authorize\s+it\.?$/i,
+        name: "exception_rule",
+        args: () => [
+            "launcher",
+            "consumer_scoped_node_package_semantics",
+            "active_package_manager_semantics",
+        ],
+        rationale: "Consumer-scoped package resolution with an explicitly authorized package-manager exception is an exception policy.",
+    },
+    {
+        pattern: /^(?<subject>it)\s+must\s+spawn\s+the\s+declared\s+kibi-mcp\s+bin\s+with\s+cwd\s+and\s+kibi_workspace\s+set\s+to\s+the\s+consumer\s+workspace,\s+preserve\s+stdio,\s+and\s+propagate\s+child\s+exit\s+codes\s+and\s+termination\s+signals\.?$/i,
+        name: "process_delegation_contract",
+        args: () => [
+            "launcher",
+            "resolved_executable",
+            "consumer_cwd",
+            "consumer_workspace_environment",
+            "inherited_stdio",
+            "propagate_exit_and_termination",
+        ],
+        rationale: "Executable, cwd, environment, stdio, and termination propagation form a reusable process delegation contract.",
+    },
+    {
+        pattern: /^(?<subject>missing)\s+project-local\s+kibi-mcp\s+must\s+produce\s+a\s+concise\s+actionable\s+error\.?$/i,
+        name: "failure_behavior",
+        args: () => ["launcher", "missing_dependency", "actionable_error"],
+        rationale: "A missing project-local dependency with an actionable error is a reusable launcher failure behavior.",
+    },
+];
+/**
+ * Return the reviewed argument tuple for an exact launcher proposition.
+ *
+ * The modeling route uses this same rule table as the semantic advisor so an
+ * inferred apply plan cannot silently drift from the canonical ontology
+ * interpretation. Non-exact prose deliberately returns null and must remain
+ * reviewable through explicit argument bindings.
+ */
+export function exactLauncherPredicateArgs(predicateName, text) {
+    for (const rule of LAUNCHER_PREDICATE_RULES) {
+        if (rule.name !== predicateName)
+            continue;
+        const match = text.match(rule.pattern);
+        if (match)
+            return [...rule.args(match.groups ?? {})];
+    }
+    return null;
+}

package/dist/operations/semantic-advisor/strict-count-rules.d.ts

@@ -1,4 +1,6 @@
 import { type Payload } from "./shared.js";
 import type { SemanticModelingSuggestion } from "./types.js";
+export declare function numberToken(value: string): number | null;
+export declare function whenParsedNumber<T>(value: number | null, then: (value: number) => T): T | null;
 export declare function detectCountStrictSuggestion(payload: Payload, statement: string): SemanticModelingSuggestion | null;
 //# sourceMappingURL=strict-count-rules.d.ts.map

package/dist/operations/semantic-advisor/strict-count-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-count-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-count-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAuB7D,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CA4DnC"}
+{"version":3,"file":"strict-count-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-count-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAgB7D,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIxD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,GACzB,CAAC,GAAG,IAAI,CAGV;AAGD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CAsEnC"}