kibi-plugin-builtin 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,53 @@
+# kibi-plugin-builtin
+
+## 0.2.0
+
+### Minor Changes
+
+- 783cc75: Coordinate enrichment, granularity candidate collection, and private-member helpers now live in `kibi-plugin-builtin`, so the CLI can analyze TypeScript/JavaScript symbols without depending on `ts-morph` directly. Hosts that only install `kibi-cli` still get the same enrichment and staged-symbol behavior through the builtin plugin.
+
+  - Export `enrichSymbolCoordinatesWithTsMorph`, `collectGranularityCandidates`, `onlyCandidate`, and `isPrivateClassMember` from `kibi-plugin-builtin`
+  - Thin-wrap those helpers from CLI `symbols-ts`, `symbol-granularity`, and `symbol-extract`
+  - Drop `ts-morph` from `kibi-cli` runtime dependencies (kept as a test-only devDependency for AST spies)
+
+- 783cc75: Kibi ships a default capability plugin package so TypeScript symbol extraction, ontology matching, and semantic lane classification live behind the public plugin protocol instead of private CLI paths.
+
+  - Add `kibi-plugin-builtin@0.1.0` with `kibiPlugin` exporting all three capabilities
+  - Built-in ts-morph extractor, ontology pack (launcher→core→policy→product→product-tail), and sync semantic classifier
+  - CLI depends on this package and thin-wraps the extractor / ontology pack for default parity
+
+### Patch Changes
+
+- b375e8f: This maintenance update brings the affected package code and tests into line with Kibi's Biome checks while preserving runtime behavior. It also replaces MCP non-null assertions with receiver-preserving method calls.
+
+  - Format affected files, sort imports, and remove unnecessary template literals.
+  - Preserve EngineClient `this` when forwarding optional Prolog methods.
+
+- e6571b4: External classifiers stay limited to the two allowlisted operations, ontology matches keep their claim keys through host composition, and CLI predicate rule tables now re-export the builtin pack so advisor and modeling cannot drift. Lane selection from the builtin classifier also accepts host snake_case signal shapes, which unblocks typecheck/build for capability-plugin call sites.
+
+  - fix(builtin): chooseLane accepts kind-only LaneSignal (unblocks analysis-receipt typecheck)
+  - feat(cli): stamp claimKey on composed ontology match candidates
+  - refactor(cli): re-export predicate rule tables from kibi-plugin-builtin
+  - chore(builtin): export rule sets + package.json subpath
+
+- Updated dependencies [e6be0cc]
+- Updated dependencies [8985874]
+- Updated dependencies [783cc75]
+  - kibi-plugin-sdk@0.2.0
+
+## Unreleased
+
+### Minor Changes
+
+- Export TypeScript coordinate enrichment, granularity candidate collection,
+  and private-member helpers so hosts (including `kibi-cli`) can drop a direct
+  `ts-morph` dependency while keeping the same analysis behavior.
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial default capability plugin package: built-in TypeScript/JavaScript
+  symbol extractor (`ts-morph`), ontology pack (launcher → core → policy →
+  product → product-tail predicate rules), and deterministic semantic
+  classifier (signal patterns + lane choice).

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { createBuiltinOntologyPack } from "./ontology/builtin-ontology-pack.js";
+export { BuiltinOntologyPack, BUILTIN_PREDICATE_RULE_SETS, } from "./ontology/builtin-ontology-pack.js";
+export { detectPredicateRules, schemaIdFor, type PredicateRule, } from "./ontology/predicate-rule.js";
+export { CORE_PREDICATE_RULES } from "./ontology/predicate-rules-core.js";
+export { LAUNCHER_PREDICATE_RULES, exactLauncherPredicateArgs, } from "./ontology/predicate-rules-launcher.js";
+export { POLICY_PREDICATE_RULES } from "./ontology/predicate-rules-policy.js";
+export { PRODUCT_PREDICATE_RULES } from "./ontology/predicate-rules-product.js";
+export { PRODUCT_TAIL_PREDICATE_RULES } from "./ontology/predicate-rules-product-tail.js";
+export { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, commaList, } from "./ontology/normalize.js";
+export { createBuiltinSemanticClassifier, BuiltinSemanticClassifier, detectSignals, chooseLane, } from "./semantic/builtin-classifier.js";
+export { createBuiltinTsMorphSymbolExtractor, createBuiltinTsMorphSourceAnalysisProvider, } from "./symbols/ts-morph-extractor.js";
+export { enrichSymbolCoordinatesWithTsMorph, type ManifestSymbolEntry, type SymbolCoordinates, } from "./symbols/ts-morph-enrichment.js";
+export { collectGranularityCandidates, type GranularitySymbolCandidate, } from "./symbols/ts-morph-granularity.js";
+export { isPrivateClassMember, onlyCandidate, } from "./symbols/ts-morph-shared.js";
+/**
+ * Default Kibi capability plugin.
+ */
+export declare const kibiPlugin: {
+    apiVersion: "kibi.plugin.v1";
+    id: string;
+    version: string;
+    permissions: {
+        network: false;
+        metered: false;
+        secrets: never[];
+    };
+    capabilities: {
+        semanticClassifier: import("kibi-plugin-sdk").SemanticClassifierV1;
+        ontologyPack: import("kibi-plugin-sdk").OntologyPackV1;
+        symbolExtractor: import("kibi-plugin-sdk").SymbolExtractorV1;
+    };
+};
+export default kibiPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,OAAO,EACL,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,KAAK,aAAa,GACnB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE1E,OAAO,EACL,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,wCAAwC,CAAC;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAE9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAEhF,OAAO,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAC;AAE1F,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,WAAW,EACX,SAAS,GACV,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,aAAa,EACb,UAAU,GACX,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,mCAAmC,EACnC,0CAA0C,GAC3C,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,kCAAkC,EAClC,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,GACvB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,4BAA4B,EAC5B,KAAK,0BAA0B,GAChC,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,oBAAoB,EACpB,aAAa,GACd,MAAM,8BAA8B,CAAC;AAEtC;;GAEG;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;CAcrB,CAAC;AAGH,eAAe,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,72 @@
+/*
+ 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 { createRequire } from "node:module";
+import { KIBI_PLUGIN_API_VERSION, defineKibiPlugin } from "kibi-plugin-sdk";
+import { createBuiltinOntologyPack } from "./ontology/builtin-ontology-pack.js";
+import { createBuiltinSemanticClassifier } from "./semantic/builtin-classifier.js";
+import { createBuiltinTsMorphSymbolExtractor } from "./symbols/ts-morph-extractor.js";
+const packageJson = createRequire(import.meta.url)("../package.json");
+// implements REQ-capability-plugin-builtin-parity-v1
+export { createBuiltinOntologyPack } from "./ontology/builtin-ontology-pack.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { BuiltinOntologyPack, BUILTIN_PREDICATE_RULE_SETS, } from "./ontology/builtin-ontology-pack.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { detectPredicateRules, schemaIdFor, } from "./ontology/predicate-rule.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { CORE_PREDICATE_RULES } from "./ontology/predicate-rules-core.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { LAUNCHER_PREDICATE_RULES, exactLauncherPredicateArgs, } from "./ontology/predicate-rules-launcher.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { POLICY_PREDICATE_RULES } from "./ontology/predicate-rules-policy.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { PRODUCT_PREDICATE_RULES } from "./ontology/predicate-rules-product.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { PRODUCT_TAIL_PREDICATE_RULES } from "./ontology/predicate-rules-product-tail.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, commaList, } from "./ontology/normalize.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { createBuiltinSemanticClassifier, BuiltinSemanticClassifier, detectSignals, chooseLane, } from "./semantic/builtin-classifier.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { createBuiltinTsMorphSymbolExtractor, createBuiltinTsMorphSourceAnalysisProvider, } from "./symbols/ts-morph-extractor.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { enrichSymbolCoordinatesWithTsMorph, } from "./symbols/ts-morph-enrichment.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { collectGranularityCandidates, } from "./symbols/ts-morph-granularity.js";
+// implements REQ-capability-plugin-builtin-parity-v1
+export { isPrivateClassMember, onlyCandidate, } from "./symbols/ts-morph-shared.js";
+/**
+ * Default Kibi capability plugin.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+export const kibiPlugin = defineKibiPlugin({
+    apiVersion: KIBI_PLUGIN_API_VERSION,
+    id: "kibi-plugin-builtin",
+    version: packageJson.version,
+    permissions: {
+        network: false,
+        metered: false,
+        secrets: [],
+    },
+    capabilities: {
+        semanticClassifier: createBuiltinSemanticClassifier(),
+        ontologyPack: createBuiltinOntologyPack(),
+        symbolExtractor: createBuiltinTsMorphSymbolExtractor(),
+    },
+});
+// implements REQ-capability-plugin-builtin-parity-v1
+export default kibiPlugin;

package/dist/ontology/builtin-ontology-pack.d.ts

@@ -0,0 +1,11 @@
+import type { OntologyMatchCandidate, OntologyMatchContext, OntologyPackV1, PredicateSchemaDefinition } from "kibi-plugin-sdk";
+import { type PredicateRule } from "./predicate-rule.js";
+/** Same evaluation order as CLI analyze-prose predicate detection. */
+export declare const BUILTIN_PREDICATE_RULE_SETS: readonly (readonly PredicateRule[])[];
+export declare class BuiltinOntologyPack implements OntologyPackV1 {
+    readonly id = "kibi-plugin-builtin.ontology";
+    schemas(): readonly PredicateSchemaDefinition[];
+    match(input: OntologyMatchContext): readonly OntologyMatchCandidate[];
+}
+export declare function createBuiltinOntologyPack(): OntologyPackV1;
+//# sourceMappingURL=builtin-ontology-pack.d.ts.map

package/dist/ontology/builtin-ontology-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-ontology-pack.d.ts","sourceRoot":"","sources":["../../src/ontology/builtin-ontology-pack.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EACV,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAC;AAO7B,sEAAsE;AAEtE,eAAO,MAAM,2BAA2B,EAAE,SAAS,CAAC,SAAS,aAAa,EAAE,CAAC,EAO1E,CAAC;AAiCJ,qBAAa,mBAAoB,YAAW,cAAc;IACxD,QAAQ,CAAC,EAAE,kCAAkC;IAE7C,OAAO,IAAI,SAAS,yBAAyB,EAAE;IAI/C,KAAK,CAAC,KAAK,EAAE,oBAAoB,GAAG,SAAS,sBAAsB,EAAE;CAStE;AAGD,wBAAgB,yBAAyB,IAAI,cAAc,CAE1D"}

package/dist/ontology/builtin-ontology-pack.js

@@ -0,0 +1,78 @@
+/*
+ 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 { detectPredicateRules, schemaIdFor, } 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";
+/** Same evaluation order as CLI analyze-prose predicate detection. */
+// implements REQ-capability-plugin-builtin-parity-v1
+export const BUILTIN_PREDICATE_RULE_SETS = [
+    LAUNCHER_PREDICATE_RULES,
+    CORE_PREDICATE_RULES,
+    POLICY_PREDICATE_RULES,
+    PRODUCT_PREDICATE_RULES,
+    PRODUCT_TAIL_PREDICATE_RULES,
+];
+function deriveSchemas(ruleSets) {
+    const byId = new Map();
+    for (const rules of ruleSets) {
+        for (const rule of rules) {
+            const schemaId = rule.catalogSchemaId ?? schemaIdFor(rule.name, rule.arity);
+            if (byId.has(schemaId))
+                continue;
+            const argumentNames = rule.argumentNames ??
+                Array.from({ length: rule.arity }, (_, i) => `arg${i}`);
+            const argumentTypes = rule.argumentTypes ??
+                Array.from({ length: rule.arity }, () => "string");
+            byId.set(schemaId, {
+                schemaId,
+                predicateName: rule.name,
+                argumentNames,
+                argumentTypes,
+                title: rule.name,
+                description: rule.rationale,
+            });
+        }
+    }
+    return [...byId.values()];
+}
+const BUILTIN_SCHEMAS = deriveSchemas(BUILTIN_PREDICATE_RULE_SETS);
+// implements REQ-capability-plugin-builtin-parity-v1
+export class BuiltinOntologyPack {
+    id = "kibi-plugin-builtin.ontology";
+    schemas() {
+        return BUILTIN_SCHEMAS;
+    }
+    match(input) {
+        const statement = input.statement.trim();
+        if (!statement)
+            return [];
+        for (const rules of BUILTIN_PREDICATE_RULE_SETS) {
+            const hits = detectPredicateRules(statement, rules);
+            if (hits.length > 0)
+                return hits;
+        }
+        return [];
+    }
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function createBuiltinOntologyPack() {
+    return new BuiltinOntologyPack();
+}

package/dist/ontology/normalize.d.ts

@@ -0,0 +1,7 @@
+/** Copied from CLI semantic-advisor shared helpers — do not import from kibi-cli. */
+export declare function normalizeKey(value: string): string;
+export declare function normalizePredicateToken(value: string): string;
+export declare function singularize(value: string): string;
+export declare function normalizeSubjectKey(value: string): string;
+export declare function commaList(value: string, separator?: RegExp): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/ontology/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/ontology/normalize.ts"],"names":[],"mappings":"AAkBA,qFAAqF;AAGrF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlD;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAGD,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAqB,GAC/B,MAAM,CAMR"}

package/dist/ontology/normalize.js

@@ -0,0 +1,55 @@
+/*
+ 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/>.
+*/
+/** Copied from CLI semantic-advisor shared helpers — do not import from kibi-cli. */
+// implements REQ-capability-plugin-builtin-parity-v1
+export function normalizeKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['’]/g, "")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function normalizePredicateToken(value) {
+    return value
+        .trim()
+        .replace(/\b(?:a|an|the)\b\s*/gi, "")
+        .replace(/['’]/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function singularize(value) {
+    if (["status", "results"].includes(value))
+        return value;
+    return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function normalizeSubjectKey(value) {
+    return normalizeKey(value).split("_").map(singularize).join(".");
+}
+// implements REQ-capability-plugin-builtin-parity-v1
+export function commaList(value, separator = /,|\band\b/i) {
+    return value
+        .split(separator)
+        .map((part) => normalizeKey(part.trim()))
+        .filter(Boolean)
+        .join(",");
+}

package/dist/ontology/predicate-rule.d.ts

@@ -0,0 +1,26 @@
+import type { OntologyMatchCandidate } from "kibi-plugin-sdk";
+import { commaList, normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize } from "./normalize.js";
+export { commaList, normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, };
+export type MatchGroups = Readonly<Record<string, string | undefined>>;
+export interface PredicateRule {
+    readonly pattern: RegExp;
+    readonly name: string;
+    readonly args: (groups: MatchGroups) => readonly string[];
+    readonly rationale: string;
+    /** Declared argument count; must match args() length. Do not probe via args({}). */
+    readonly arity: number;
+    readonly argumentNames?: readonly string[];
+    readonly argumentTypes?: readonly string[];
+    /** Optional rich catalog schema id (e.g. FACT-SCHEMA-GUARD). */
+    readonly catalogSchemaId?: string;
+    readonly polarity?: "assert" | "deny";
+    readonly accepts?: (statement: string) => boolean;
+}
+export declare const BUILTIN_PREDICATE_CONFIDENCE = 0.84;
+export declare function schemaIdFor(predicateName: string, arity: number): string;
+/**
+ * First-match semantics (identical to CLI detectPredicateRules): return at most
+ * one candidate from the given rule set.
+ */
+export declare function detectPredicateRules(statement: string, rules: readonly PredicateRule[]): OntologyMatchCandidate[];
+//# sourceMappingURL=predicate-rule.d.ts.map

package/dist/ontology/predicate-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rule.d.ts","sourceRoot":"","sources":["../../src/ontology/predicate-rule.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EACL,SAAS,EACT,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,WAAW,EACZ,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,SAAS,EACT,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,WAAW,GACZ,CAAC;AAGF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;AAGvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACnD;AAGD,eAAO,MAAM,4BAA4B,OAAO,CAAC;AAGjD,wBAAgB,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAExE;AAED;;;GAGG;AAEH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,aAAa,EAAE,GAC9B,sBAAsB,EAAE,CAwB1B"}

package/dist/ontology/predicate-rule.js

@@ -0,0 +1,55 @@
+/*
+ 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 { commaList, normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, } from "./normalize.js";
+export { commaList, normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, };
+// implements REQ-capability-plugin-builtin-parity-v1
+export const BUILTIN_PREDICATE_CONFIDENCE = 0.84;
+// implements REQ-capability-plugin-builtin-parity-v1
+export function schemaIdFor(predicateName, arity) {
+    return `builtin.${predicateName}.${arity}`;
+}
+/**
+ * First-match semantics (identical to CLI detectPredicateRules): return at most
+ * one candidate from the given rule set.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+export function detectPredicateRules(statement, rules) {
+    for (const rule of rules) {
+        if (rule.accepts && !rule.accepts(statement))
+            continue;
+        const match = statement.match(rule.pattern);
+        if (!match?.groups)
+            continue;
+        const args = rule.args(match.groups);
+        if (args.length !== rule.arity) {
+            throw new Error(`Predicate rule '${rule.name}' arity mismatch: declared ${rule.arity}, args() returned ${args.length}`);
+        }
+        return [
+            {
+                schemaId: rule.catalogSchemaId ?? schemaIdFor(rule.name, rule.arity),
+                predicateName: rule.name,
+                arguments: args,
+                polarity: rule.polarity ?? "assert",
+                confidence: BUILTIN_PREDICATE_CONFIDENCE,
+                evidence: match[0],
+                rationale: rule.rationale,
+            },
+        ];
+    }
+    return [];
+}

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

@@ -0,0 +1,94 @@
+import { commaList } from "./predicate-rule.js";
+export declare const CORE_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "guard";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Disabled-until prose defines a condition that guards behavior availability and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "temporal_order";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Before/after ordering is relational temporal logic and should be modeled as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "conditional_behavior";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "If/then requirement prose is conditional behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "conditional_behavior";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "When/must prose is conditional behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "exception_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Unless/except prose defines an explicit exception to required behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "mutual_exclusion";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Mutual-exclusion prose is a relational constraint and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "dependency_rule";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Requires-before prose defines a prerequisite relationship and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "ownership_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Ownership prose assigns responsibility for a resource or behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "merge_policy";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Same-slot merge prose defines ontology-lite merge behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "retry_policy";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Retry prose defines bounded recovery behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "escalation_rule";
+    readonly arity: 4;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Escalation prose defines delayed handoff behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "availability_sla";
+    readonly arity: 4;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Availability SLA prose defines a service target over a window and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "notification_route";
+    readonly arity: 3;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Notification routing prose defines a recipient and channel and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "idempotency_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Idempotency prose defines deduplication behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "idempotency_rule";
+    readonly arity: 2;
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Deduplication prose defines idempotent handling of repeated or concurrent operations and should be queryable as a predicate.";
+}];
+export { commaList };
+//# sourceMappingURL=predicate-rules-core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-core.d.ts","sourceRoot":"","sources":["../../src/ontology/predicate-rules-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAKV,MAAM,qBAAqB,CAAC;AAG7B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsLY,CAAC;AAE9C,OAAO,EAAE,SAAS,EAAE,CAAC"}