kibi-plugin-builtin 0.2.0

package/dist/ontology/predicate-rules-product-tail.js

@@ -0,0 +1,112 @@
+import { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, } from "./predicate-rule.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export const PRODUCT_TAIL_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+throttled\s+for\s+(?<condition>.+?)\.?$/i,
+        name: "throttle_policy_rule",
+        arity: 2,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizePredicateToken(g.condition ?? ""),
+        ],
+        rationale: "Throttle-policy prose defines throttling behavior under high-frequency conditions and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>.+?)\s+initializes\s+after\s+(?:the\s+)?(?<ready>.+?)\s+is\s+ready\.?$/i,
+        name: "temporal_order",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            `${normalizeKey(g.ready ?? "")}_ready`,
+            "initializes",
+        ],
+        rationale: "Initializes-after prose defines temporal readiness ordering and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^when\s+(?<trigger>.+?),\s*(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+transitions?\s+from\s+(?<from>[a-z][a-z0-9_-]*)\s+to\s+(?<to>[a-z][a-z0-9_-]*)\.?$/i,
+        name: "state_transition",
+        arity: 4,
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizePredicateToken(g.from ?? ""),
+            normalizePredicateToken(g.to ?? ""),
+            normalizePredicateToken(g.trigger ?? ""),
+        ],
+        rationale: "State transitions have source state, target state, and trigger; model them as predicate facts.",
+    },
+    {
+        pattern: /^(?<actor>[a-z][a-z\s_-]*?)\s+(?:must\s+not|cannot|can't|is\s+forbidden\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)\.?$/i,
+        name: "permission_rule",
+        arity: 4,
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.resource ?? ""),
+            "deny",
+        ],
+        rationale: "Prohibitions are negative permission rules and should preserve deny polarity.",
+        polarity: "deny",
+    },
+    {
+        pattern: /^(?:there\s+)?(?:must|shall|should)\s+be\s+at\s+most\s+one\s+(?<subject>[a-z][a-z\s_-]*?)\s+per\s+(?<scope>.+?)\.?$/i,
+        name: "uniqueness_constraint",
+        arity: 2,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            (g.scope ?? "")
+                .split(/\s+per\s+/i)
+                .map(normalizePredicateToken)
+                .join(","),
+        ],
+        rationale: "Per-scope uniqueness is relational and should be modeled as a predicate rather than a generic count.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+defaults?\s+to\s+(?<value>[a-z][a-z0-9\s_-]*?)(?:\s+(?<property>mode|state|status))?\.?$/i,
+        name: "default_value",
+        arity: 3,
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizeKey(g.property ?? "value"),
+            normalizeKey(g.value ?? ""),
+        ],
+        rationale: "Defaults are relational product behavior and should be explicit ontology predicates.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:terminal\s+)?states\s+are\s+(?<states>.+?)\.?$/i,
+        name: "state_membership",
+        arity: 2,
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            (g.states ?? "")
+                .split(/,|\band\b|\bor\b/i)
+                .map((value) => normalizePredicateToken(value.trim()))
+                .filter(Boolean)
+                .join(","),
+        ],
+        rationale: "State sets are relational workflow constraints and should be queryable as predicate facts.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+rate\s+limited\s+to\s+(?<count>\d+)\s+(?<action>[a-z][a-z\s_-]*?)\s+per\s+(?<window>[a-z]+)\.?$/i,
+        name: "rate_limit",
+        arity: 4,
+        args: (g) => [
+            `${normalizeKey(g.subject ?? "").replace(/_requests?$/, "")}.request`,
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.window ?? ""),
+            g.count ?? "",
+        ],
+        rationale: "Rate limits are bounded action-window constraints and now map to the production rate_limit predicate.",
+    },
+    {
+        pattern: /^only\s+(?<actor>[a-z][a-z\s_-]*?)\s+can\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)(?:\s+when\s+.+)?\.?$/i,
+        name: "permission_rule",
+        arity: 4,
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizeKey(g.action ?? ""),
+            normalizeKey(g.resource ?? ""),
+            "assert",
+        ],
+        rationale: "Actor/action/resource permission prose is better represented as an ontology predicate than a scalar property.",
+    },
+];

package/dist/ontology/predicate-rules-product.d.ts

@@ -0,0 +1,84 @@
+export declare const PRODUCT_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "release_gate_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Release-gate prose defines required gates before distribution or deployment and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "platform_consistency_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Platform consistency prose defines synchronization across platforms and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "preservation_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Preservation prose defines data preserved across deletion/removal boundaries and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "abstraction_boundary_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Abstraction-boundary prose defines renderer/vendor-neutral persistence or contract constraints and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "security_configuration_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Security-configuration prose defines explicit infrastructure or database settings and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "ordered_strategy_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Ordered-strategy prose defines a required priority order and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "refresh_policy_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Refresh-policy prose defines automatic refresh behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "scoped_authorization_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Scoped-authorization prose defines assignment/ownership-qualified authorization and should be queryable as a predicate.";
+    readonly accepts: (statement: string) => boolean;
+}, {
+    readonly pattern: RegExp;
+    readonly name: "documentation_standard_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Documentation-standard prose defines required documentation artifacts and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "warmup_policy_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Warmup-policy prose defines a required warmup trigger and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "visual_layout_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Visual-layout prose defines UI alignment requirements and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "enforcement_location_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Enforcement-location prose defines the layer where a constraint is enforced and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "reconciliation_rule";
+    readonly arity: 4;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Reconciliation prose defines trigger-based cleanup of stale records and should be queryable as a predicate.";
+}];
+//# sourceMappingURL=predicate-rules-product.d.ts.map

package/dist/ontology/predicate-rules-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-product.d.ts","sourceRoot":"","sources":["../../src/ontology/predicate-rules-product.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkLS,CAAC"}

package/dist/ontology/predicate-rules-product.js

@@ -0,0 +1,147 @@
+import { commaList, normalizeKey, normalizePredicateToken, } from "./predicate-rule.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export const PRODUCT_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+pass\s+(?<gate>.+?)\s+before\s+(?<target>.+?)\.?$/i,
+        name: "release_gate_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizePredicateToken(g.gate ?? "gate"),
+            normalizeKey(g.target ?? ""),
+        ],
+        rationale: "Release-gate prose defines required gates before distribution or deployment and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:app store|build|deployment|distribution|release|testflight)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+synchronize\s+across\s+(?<platforms>.+?)\.?$/i,
+        name: "platform_consistency_rule",
+        arity: 2,
+        args: (g) => [normalizeKey(g.subject ?? ""), commaList(g.platforms ?? "")],
+        rationale: "Platform consistency prose defines synchronization across platforms and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+preserve\s+(?<preserved>.+?)\s+when\s+(?:the\s+)?(?<condition>.+?)\.?$/i,
+        name: "preservation_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.preserved ?? "preserved"),
+            normalizePredicateToken(g.condition ?? ""),
+        ],
+        rationale: "Preservation prose defines data preserved across deletion/removal boundaries and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+persisted\s+as\s+(?<contract>.+?)\.?$/i,
+        name: "abstraction_boundary_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "persisted_as",
+            normalizePredicateToken(g.contract ?? ""),
+        ],
+        rationale: "Abstraction-boundary prose defines renderer/vendor-neutral persistence or contract constraints and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:neutral|contract|renderer|runtime|vendor)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+have\s+explicit\s+(?<setting>[A-Za-z0-9_.-]+)\s+(?<value>[A-Za-z0-9_.-]+)\.?$/i,
+        name: "security_configuration_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.setting ?? ""),
+            normalizeKey(g.value ?? ""),
+        ],
+        rationale: "Security-configuration prose defines explicit infrastructure or database settings and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:database|deployment|function|rpc|search_path|security|trigger)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+use\s+(?<kind>.+?)\s+in\s+priority\s+order\s+(?<values>.+?)\.?$/i,
+        name: "ordered_strategy_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.kind ?? "strategy"),
+            (g.values ?? "")
+                .split(/,|>/)
+                .map(normalizePredicateToken)
+                .filter(Boolean)
+                .join(","),
+        ],
+        rationale: "Ordered-strategy prose defines a required priority order and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+automatically\s+refresh\s+(?<target>.+?)\s+without\s+requiring\s+manual\s+page\s+reload\.?$/i,
+        name: "refresh_policy_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.target ?? ""),
+            "automatic",
+        ],
+        rationale: "Refresh-policy prose defines automatic refresh behavior and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<actor>.+?)\s+(?:must|shall|should)\s+be\s+denied\s+(?<action>.+?)\.?$/i,
+        name: "scoped_authorization_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.actor ?? ""),
+            normalizeKey(g.action ?? ""),
+            "deny",
+        ],
+        rationale: "Scoped-authorization prose defines assignment/ownership-qualified authorization and should be queryable as a predicate.",
+        accepts: (statement) => /\b(?:assigned|unassigned|owner|member|scoped)\b/i.test(statement),
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+documented\s+in\s+(?<artifact>.+?)\.?$/i,
+        name: "documentation_standard_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "documented_in",
+            normalizeKey(g.artifact ?? ""),
+        ],
+        rationale: "Documentation-standard prose defines required documentation artifacts and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>.+?)\s+(?:must|shall|should)\s+warm\s+up\s+on\s+(?<trigger>.+?)\.?$/i,
+        name: "warmup_policy_rule",
+        arity: 2,
+        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.trigger ?? "")],
+        rationale: "Warmup-policy prose defines a required warmup trigger and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+remain\s+visually\s+aligned\s+with\s+(?<target>.+?)\.?$/i,
+        name: "visual_layout_rule",
+        arity: 3,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            "aligned_with",
+            normalizeKey(g.target ?? ""),
+        ],
+        rationale: "Visual-layout prose defines UI alignment requirements and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+enforced\s+at\s+(?<location>.+?)\.?$/i,
+        name: "enforcement_location_rule",
+        arity: 2,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.location ?? ""),
+        ],
+        rationale: "Enforcement-location prose defines the layer where a constraint is enforced and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^on\s+(?<trigger>.+?),\s*(?<subject>.+?)\s+(?:must|shall|should)\s+reconcile\s+(?<target>.+?)\s+and\s+(?<action>clear\s+stale\s+.+?)\.?$/i,
+        name: "reconciliation_rule",
+        arity: 4,
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizeKey(g.trigger ?? "trigger"),
+            normalizeKey(g.target ?? ""),
+            normalizeKey(g.action ?? "action"),
+        ],
+        rationale: "Reconciliation prose defines trigger-based cleanup of stale records and should be queryable as a predicate.",
+    },
+];

package/dist/semantic/builtin-classifier.d.ts

@@ -0,0 +1,22 @@
+import type { SemanticClassifierInput, SemanticClassifierResult, SemanticClassifierV1, SemanticLane, SemanticSignalKind } from "kibi-plugin-sdk";
+interface DetectedSignal {
+    readonly kind: SemanticSignalKind;
+    readonly evidence: string;
+    readonly candidateLane: SemanticLane;
+    readonly confidence: number;
+}
+export declare function detectSignals(prose: string): readonly DetectedSignal[];
+/**
+ * Lane selection shared with the host analysis receipt.
+ * Host snake_case receipts may omit candidateLane; only `kind` is required.
+ */
+export declare function chooseLane(signals: readonly {
+    readonly kind: SemanticSignalKind;
+}[]): SemanticLane;
+export declare class BuiltinSemanticClassifier implements SemanticClassifierV1 {
+    readonly id = "kibi-plugin-builtin.classifier";
+    classify(input: SemanticClassifierInput): SemanticClassifierResult;
+}
+export declare function createBuiltinSemanticClassifier(): SemanticClassifierV1;
+export {};
+//# sourceMappingURL=builtin-classifier.d.ts.map

package/dist/semantic/builtin-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-classifier.d.ts","sourceRoot":"","sources":["../../src/semantic/builtin-classifier.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAEV,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AAwDzB,UAAU,cAAc;IACtB,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAGD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,cAAc,EAAE,CAetE;AAED;;;GAGG;AAEH,wBAAgB,UAAU,CACxB,OAAO,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,EAAE,GACxD,YAAY,CAoBd;AA4BD,qBAAa,yBAA0B,YAAW,oBAAoB;IACpE,QAAQ,CAAC,EAAE,oCAAoC;IAE/C,QAAQ,CAAC,KAAK,EAAE,uBAAuB,GAAG,wBAAwB;CAqBnE;AAGD,wBAAgB,+BAA+B,IAAI,oBAAoB,CAEtE"}

package/dist/semantic/builtin-classifier.js

@@ -0,0 +1,134 @@
+/*
+ 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/>.
+*/
+/** Same patterns as CLI analyze-prose SIGNAL_PATTERNS. */
+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,
+    },
+];
+// implements REQ-capability-plugin-builtin-parity-v1
+export 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,
+                candidateLane: candidate.candidateLane,
+                confidence: candidate.confidence,
+            },
+        ];
+    });
+}
+/**
+ * Lane selection shared with the host analysis receipt.
+ * Host snake_case receipts may omit candidateLane; only `kind` is required.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+export 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";
+}
+function confidenceForLane(lane, signals) {
+    if (lane === "none" || signals.length === 0)
+        return 0;
+    const relevant = lane === "strict_property"
+        ? signals.filter(({ kind }) => kind === "numeric_cardinality" || kind === "numeric_threshold")
+        : lane === "predicate"
+            ? signals.filter(({ kind }) => kind === "conditional" ||
+                kind === "permission" ||
+                kind === "state_or_default")
+            : lane === "observation_review"
+                ? signals.filter(({ kind }) => kind === "normative_modal")
+                : signals;
+    const pool = relevant.length > 0 ? relevant : signals;
+    return Math.max(...pool.map((signal) => signal.confidence));
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export class BuiltinSemanticClassifier {
+    id = "kibi-plugin-builtin.classifier";
+    classify(input) {
+        const decisions = input.propositions.map((proposition) => {
+            const signals = detectSignals(proposition.statement);
+            const lane = chooseLane(signals);
+            const decision = {
+                claimKey: proposition.claimKey,
+                lane,
+                confidence: confidenceForLane(lane, signals),
+            };
+            if (signals.length > 0) {
+                return {
+                    ...decision,
+                    signals: signals.map((signal) => signal.kind),
+                };
+            }
+            return decision;
+        });
+        return { decisions };
+    }
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function createBuiltinSemanticClassifier() {
+    return new BuiltinSemanticClassifier();
+}

package/dist/symbols/ts-morph-enrichment.d.ts

@@ -0,0 +1,21 @@
+export interface SymbolCoordinates {
+    sourceLine: number;
+    sourceColumn: number;
+    sourceEndLine: number;
+    sourceEndColumn: number;
+    coordinatesGeneratedAt: string;
+}
+export interface ManifestSymbolEntry {
+    id: string;
+    title: string;
+    sourceFile?: string;
+    sourceLine?: number;
+    sourceColumn?: number;
+    sourceEndLine?: number;
+    sourceEndColumn?: number;
+    coordinatesGeneratedAt?: string;
+    links?: string[];
+    [key: string]: unknown;
+}
+export declare function enrichSymbolCoordinatesWithTsMorph(entries: ManifestSymbolEntry[], workspaceRoot: string): Promise<ManifestSymbolEntry[]>;
+//# sourceMappingURL=ts-morph-enrichment.d.ts.map

package/dist/symbols/ts-morph-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-enrichment.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-enrichment.ts"],"names":[],"mappings":"AAmCA,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAGD,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAKD,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,mBAAmB,EAAE,EAC9B,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAsEhC"}