kibi-cli 1.0.1 → 2.1.0

package/dist/operations/proof/prune-receipts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune-receipts.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/prune-receipts.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AASjF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,uDAAuD;IAEvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAGH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAE7C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IAEzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC3C,CAAC,CAAC;AAYH;;;;;;;;;GASG;AAEH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,iBAAiB,EAAE,mBAAmB,CAAC;CACxC,CAAC,CAoED"}

package/dist/operations/proof/prune-receipts.js

@@ -0,0 +1,91 @@
+/*
+ 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 { loadEntities } from "../../public/operations/discovery-entities.js";
+import { proofReceiptHistoryErrors, } from "../../public/proof-receipt.js";
+import { projectEntityProperties } from "../mutation/entity-projection.js";
+import { executeUpsert } from "../mutation/upsert.js";
+function parseKeep(value) {
+    if (value === undefined)
+        return 1;
+    if (!Number.isSafeInteger(value) || value < 1 || value > 50) {
+        throw new Error("Proof prune failed: keep must be an integer between 1 and 50");
+    }
+    return value;
+}
+/**
+ * Shrink each test's proof_receipts history to its newest entries.
+ *
+ * Re-proving the same snapshot appends duplicate passed receipts (one block
+ * per run), and consumers previously deduped them by hand. This is the one
+ * sanctioned history-shrinking mutation: pruned histories are still ordered,
+ * structurally valid evidence, and every shrink goes through the typed upsert
+ * with the prune carve-out (append-only validation is skipped for exactly
+ * this maintenance action).
+ */
+// implements REQ-kibi-verification-evidence-contract
+export async function executePruneReceipts(args, context) {
+    if (!context.prolog)
+        throw new Error("Proof prune requires a Prolog runtime");
+    if (context.fs === undefined)
+        throw new Error("Proof prune failed: this maintenance action rewrites authored test documents and requires a filesystem-capable runtime");
+    const keep = parseKeep(args.keep);
+    const tests = await loadEntities(context.prolog, {
+        type: "test",
+        ...(args.testId === undefined ? {} : { id: args.testId }),
+    });
+    if (args.testId !== undefined && tests.length === 0) {
+        throw new Error(`Proof prune failed: test ${args.testId} was not found`);
+    }
+    const results = [];
+    for (const test of tests) {
+        const testId = String(test.id);
+        const receipts = Array.isArray(test.proof_receipts)
+            ? test.proof_receipts.filter((value) => typeof value === "object" &&
+                value !== null &&
+                !Array.isArray(value))
+            : [];
+        if (receipts.length <= keep)
+            continue;
+        const nextReceipts = receipts.slice(-keep);
+        const historyErrors = proofReceiptHistoryErrors(testId, test.verification_scope, nextReceipts);
+        if (historyErrors.length > 0) {
+            throw new Error(`Proof prune failed for ${testId}: pruned history is invalid: ${historyErrors.join("; ")}`);
+        }
+        const properties = projectEntityProperties(test);
+        properties.proof_receipts = undefined;
+        await executeUpsert({
+            type: "test",
+            id: testId,
+            properties: { ...properties, proof_receipts: nextReceipts },
+        }, context, { allowReceiptsPrune: true });
+        results.push({
+            testId,
+            before: receipts.length,
+            after: nextReceipts.length,
+            pruned: receipts.length - nextReceipts.length,
+        });
+    }
+    const pruned = results.reduce((sum, row) => sum + row.pruned, 0);
+    const summary = results.length === 0
+        ? "No test had receipts beyond the keep window."
+        : `Pruned ${pruned} receipt(s) across ${results.length} test(s).`;
+    return {
+        content: [{ type: "text", text: `Proof receipts pruned. ${summary}` }],
+        structuredContent: { pruned, tests: results },
+    };
+}

package/dist/operations/proof/receipt-document.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+export declare function removeFrontmatterBlock(content: string, key: string): string | null;
+/**
+ * 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.
+ */
+export declare function patchReceiptsIntoDocument(content: string, receipts: readonly Readonly<Record<string, unknown>>[]): string | null;
+//# sourceMappingURL=receipt-document.d.ts.map

package/dist/operations/proof/receipt-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receipt-document.d.ts","sourceRoot":"","sources":["../../../src/operations/proof/receipt-document.ts"],"names":[],"mappings":"AAoBA;;;;;;;;GAQG;AAEH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,IAAI,CA4Bf;AAED;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,GACrD,MAAM,GAAG,IAAI,CAyCf"}

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-verification-evidence-contract
+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-verification-evidence-contract
+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/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,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"}
+{"version":3,"file":"analysis-receipt.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/analysis-receipt.ts"],"names":[],"mappings":"AACA,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;AAyBpB,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,14 +1,8 @@
+import { chooseLane as chooseBuiltinLane } from "kibi-plugin-builtin";
 import { SEMANTIC_INVENTORY_VERSION, payloadHash, propertiesOf, semanticSourceHash, semanticSourceOf, } from "./shared.js";
+/** Builtin classifier is the single source of signal→lane selection. */
 function chooseLane(signals) {
-    if (signals.some(({ kind }) => kind === "numeric_cardinality" || kind === "numeric_threshold"))
-        return "strict_property";
-    if (signals.some(({ kind }) => kind === "conditional" ||
-        kind === "permission" ||
-        kind === "state_or_default"))
-        return "predicate";
-    return signals.some(({ kind }) => kind === "normative_modal")
-        ? "observation_review"
-        : "none";
+    return chooseBuiltinLane(signals);
 }
 function summary(readiness, lane) {
     if (readiness === "modeled")

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":"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;AA81BhD,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":"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;AAEhD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAI1D;AAg0BD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,oBAAoB,GAC1B,6BAA6B,CA+D/B"}

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

@@ -1,58 +1,18 @@
+import { createBuiltinOntologyPack, detectSignals as detectBuiltinSignals, } from "kibi-plugin-builtin";
 import { utf8Span, validateLogicIr, } from "../../logic/ir.js";
 import { logicRuleFactId } from "../modeling/logic-modeling.js";
 import { buildAdvisorResult } from "./analysis-receipt.js";
 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";
-import { isRecord, payloadHash, propertiesOf, relationship, semanticClausesOf, semanticSourceHash, semanticSourceOf, sourceOf, statementOf, stringValue, } from "./shared.js";
+import { predicateSuggestion as buildPredicateSuggestion, 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";
-const SIGNAL_PATTERNS = [
-    {
-        kind: "numeric_cardinality",
-        candidateLane: "strict_property",
-        confidence: 0.92,
-        pattern: /\b(?:(?:at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to|cap(?:ped)?\s+at)\s+)?(?:\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\b/i,
-    },
-    {
-        kind: "numeric_threshold",
-        candidateLane: "strict_property",
-        confidence: 0.86,
-        pattern: /\b(?:maximum|minimum|under|within|below|above|expires?|retained\s+for)\s+(?:\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\b/i,
-    },
-    {
-        kind: "conditional",
-        candidateLane: "predicate",
-        confidence: 0.82,
-        pattern: /\b(?:if|when|unless|except|only\s+if|provided\s+that)\b/i,
-    },
-    {
-        kind: "permission",
-        candidateLane: "predicate",
-        confidence: 0.8,
-        pattern: /\b(?:only|may|can|allowed|denied|forbidden|must\s+not|cannot|can't)\b/i,
-    },
-    {
-        kind: "state_or_default",
-        candidateLane: "predicate",
-        confidence: 0.74,
-        pattern: /\b(?:state|mode|defaults?\s+to|ready|disabled|enabled|terminal)\b/i,
-    },
-    {
-        kind: "normative_modal",
-        candidateLane: "observation_review",
-        confidence: 0.65,
-        // 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,
-    },
-];
+export function stringLogicClaims(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
 function proseOf(payload) {
     const properties = propertiesOf(payload);
     return [
@@ -101,22 +61,14 @@ function isModeled(payload, expectedClaimKeys) {
             types.has("requires_predicate") ||
             types.has("requires_rule")));
 }
+/** Builtin semantic classifier is the single source of signal/lane detection. */
 function detectSignals(prose) {
-    const seen = new Set();
-    return SIGNAL_PATTERNS.flatMap((candidate) => {
-        const evidence = prose.match(candidate.pattern)?.[0];
-        if (!evidence || seen.has(candidate.kind))
-            return [];
-        seen.add(candidate.kind);
-        return [
-            {
-                kind: candidate.kind,
-                evidence,
-                candidate_lane: candidate.candidateLane,
-                confidence: candidate.confidence,
-            },
-        ];
-    });
+    return detectBuiltinSignals(prose).map((signal) => ({
+        kind: signal.kind,
+        evidence: signal.evidence,
+        candidate_lane: signal.candidateLane,
+        confidence: signal.confidence,
+    }));
 }
 function ambiguitySuggestion(payload, statement) {
     const match = statement.match(/\b(?<value>\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\s+(?<resource>active\s+sessions?|sessions?)\b/i);
@@ -164,11 +116,15 @@ function ontologyGapSuggestion(payload, statement) {
     };
 }
 function predicateSuggestion(payload, statement) {
-    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));
+    // Deterministic builtin pack — never loads external plugins on sync paths.
+    const matches = createBuiltinOntologyPack().match({
+        claimKey: "",
+        statement,
+    });
+    const hit = matches[0];
+    if (!hit)
+        return null;
+    return buildPredicateSuggestion(payload, hit.evidence, hit.predicateName, hit.arguments, hit.rationale ?? "", hit.polarity);
 }
 function ruleSuggestion(payload, candidate) {
     const validation = validateLogicIr(candidate.ir);
@@ -289,8 +245,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"
@@ -309,7 +266,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,
@@ -334,9 +291,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: {
@@ -357,7 +312,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,
             },
@@ -366,14 +321,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,
@@ -387,7 +342,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,
@@ -554,12 +509,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)
@@ -582,16 +561,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`);
@@ -671,7 +642,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;AA4BD,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

@@ -46,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/plugin-orchestration.d.ts

@@ -0,0 +1,63 @@
+import type { PluginProviderStamp, SemanticClassificationDecision, SemanticClassifierInput } from "kibi-plugin-sdk";
+import { type ComposedOntologyCatalog, type StampedOntologyCandidate } from "../../plugins/compose-ontology-packs.js";
+import { type ComposedSemanticClassifierResult } from "../../plugins/compose-semantic-classifier.js";
+import type { CapabilityRegistry } from "../../plugins/registry.js";
+import type { OperationContext } from "../../public/operations/runtime-types.js";
+import type { SemanticAdvisorAnalysisResult, SemanticAdvisorInput } from "./types.js";
+export type SemanticPluginOrchestrationResult = Readonly<{
+    analysis: SemanticAdvisorAnalysisResult;
+    classification: ComposedSemanticClassifierResult | null;
+    ontologyCatalog: ComposedOntologyCatalog | null;
+    ontologyMatches: readonly StampedOntologyCandidate[];
+    ontologyShadowMatches: readonly StampedOntologyCandidate[];
+    stamps: readonly PluginProviderStamp[];
+}>;
+/**
+ * Drop sync-path builtin ontology `predicate` suggestions.
+ *
+ * `analyzeSemanticAdvisorInput` always consults the builtin pack for
+ * maintenance-safe deterministic matching. When a replace ontology pack is
+ * active, those suggestions must not survive into the public receipt —
+ * including when the replace pack abstains with a valid empty match set.
+ */
+export declare function stripSyncBuiltinOntologySuggestions(analysis: SemanticAdvisorAnalysisResult): SemanticAdvisorAnalysisResult;
+/**
+ * Host-construct advisory modeling suggestions from validated ontology matches.
+ *
+ * When `replaced` is true, matches replace any remaining claim-keyed
+ * suggestion for the matched claim (after sync builtin predicates were
+ * stripped). When false (augment/builtin), matches only fill claims that
+ * lack a suggestion.
+ */
+export declare function applyOntologyMatchSuggestions(analysis: SemanticAdvisorAnalysisResult, ontologyMatches: readonly StampedOntologyCandidate[], options?: Readonly<{
+    replaced: boolean;
+}>): SemanticAdvisorAnalysisResult;
+/**
+ * Apply host-validated classifier decisions as a bounded routing seam.
+ *
+ * Plugins may influence per-proposition routing, candidate lane, suggested
+ * next tools, and advisory ambiguity metadata. They must not delete
+ * propositions, erase assertive unresolved obligations, downgrade modeled
+ * completeness, manufacture typed grounding, or invent mutation/proof.
+ */
+export declare function applyClassificationRouting(analysis: SemanticAdvisorAnalysisResult, classification: ComposedSemanticClassifierResult, ontologyMatches?: readonly StampedOntologyCandidate[], options?: Readonly<{
+    replaced?: boolean;
+    /** True when a replace semantic classifier succeeded (not builtin fallback). */
+    classifierReplaced?: boolean;
+}>): SemanticAdvisorAnalysisResult;
+/**
+ * Async orchestration for allowlisted semantic operations.
+ * Maintenance paths must keep calling sync `analyzeSemanticAdvisorInput`.
+ */
+export declare function analyzeSemanticAdvisorInputWithPlugins(input: SemanticAdvisorInput, options: Readonly<{
+    ensurePlugins?: () => Promise<CapabilityRegistry>;
+    operationName: string;
+}>): Promise<SemanticPluginOrchestrationResult>;
+/**
+ * Run allowlisted semantic classifier composition without re-running advisor
+ * analysis.
+ */
+export declare function composeSemanticClassificationForOperation(context: OperationContext | undefined, operationName: string, input: SemanticClassifierInput): Promise<ComposedSemanticClassifierResult | null>;
+export declare function composeOntologyCatalogForOperation(context: OperationContext | undefined, operationName: string): Promise<ComposedOntologyCatalog | null>;
+export type { SemanticClassificationDecision };
+//# sourceMappingURL=plugin-orchestration.d.ts.map

package/dist/operations/semantic-advisor/plugin-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-orchestration.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/plugin-orchestration.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAEV,mBAAmB,EACnB,8BAA8B,EAC9B,uBAAuB,EAExB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAG9B,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,KAAK,gCAAgC,EAEtC,MAAM,8CAA8C,CAAC;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EAKrB,MAAM,YAAY,CAAC;AAGpB,MAAM,MAAM,iCAAiC,GAAG,QAAQ,CAAC;IACvD,QAAQ,EAAE,6BAA6B,CAAC;IACxC,cAAc,EAAE,gCAAgC,GAAG,IAAI,CAAC;IACxD,eAAe,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAChD,eAAe,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACrD,qBAAqB,EAAE,SAAS,wBAAwB,EAAE,CAAC;IAC3D,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACxC,CAAC,CAAC;AAmDH;;;;;;;GAOG;AAEH,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,6BAA6B,GACtC,6BAA6B,CAkB/B;AAED;;;;;;;GAOG;AAEH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,6BAA6B,EACvC,eAAe,EAAE,SAAS,wBAAwB,EAAE,EACpD,OAAO,GAAE,QAAQ,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAuB,GAC7D,6BAA6B,CAiG/B;AAED;;;;;;;GAOG;AAEH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,6BAA6B,EACvC,cAAc,EAAE,gCAAgC,EAChD,eAAe,GAAE,SAAS,wBAAwB,EAAO,EACzD,OAAO,GAAE,QAAQ,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAM,GACN,6BAA6B,CAqM/B;AAED;;;GAGG;AAEH,wBAAsB,sCAAsC,CAC1D,KAAK,EAAE,oBAAoB,EAC3B,OAAO,EAAE,QAAQ,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAClD,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,GACD,OAAO,CAAC,iCAAiC,CAAC,CA8H5C;AAED;;;GAGG;AAEH,wBAAsB,yCAAyC,CAC7D,OAAO,EAAE,gBAAgB,GAAG,SAAS,EACrC,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAOlD;AAGD,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,gBAAgB,GAAG,SAAS,EACrC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAOzC;AAED,YAAY,EAAE,8BAA8B,EAAE,CAAC"}