kibi-plugin-builtin 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,17 +1,72 @@
 # kibi-plugin-builtin
 
+## 0.4.0
+
+### Minor Changes
+
+- db5376c: Kibi can now analyze source in Python, Go, Rust and a broader set of common programming and configuration languages, offline, while JavaScript and TypeScript keep working as before. Staged checks read source and authored knowledge from one immutable Git tree, inspect both sides of every change, and keep incomplete analysis explicit instead of treating it as proof. Large files now return an explicit analysis failure instead of a second validation error.
+  - Add the asynchronous `kibi.symbol-extractor.v2` contract with validated UTF-16 ranges, bounded inputs and host-assigned provenance, plus a ts-morph v2 adapter.
+  - Add the optional `kibi-plugin-treesitter` package with pinned WASM grammars, queries, licenses and an approved-analyzer closure verified before import.
+  - Capture staged and explicit-diff snapshots from Git objects; merge duplicate symbol-manifest records deterministically and fail conflicting authored fields with `SOURCE_DUPLICATE_CONFLICT`.
+  - Add opt-in, bounded parser-phase and Prolog round-trip timing observations that never enter result schemas.
+
+### Patch Changes
+
+- 8622782: An impact review prepared on one machine now still validates in CI, and the MCP server and the CLI agree on whether it is current. Checks only block on incomplete source analysis the author can act on: the committed side of a change never blocks, and a known analyzer limitation such as a Rust macro or a Python decorator matters only where it overlaps the changed lines. Syntax, parse, timeout and integrity problems in the staged file still block. Long-running hosts no longer grow memory with every analyzed file, and Tree-sitter analysis reuses warm workers instead of starting one per file.
+  - Identify the impact evaluator by its contract version and the canonical JSON of the schemas it consumes, instead of hashing the installed file tree and `process.version`. Identify the builtin analyzer runtime by its package identity rather than its installed tree.
+  - `kibi-runtime` bundles the CLI operations again (`kibi-cli` is a build-time dependency only); it no longer installs `kibi-cli`.
+  - Add one shared analysis gate (`analysisObligation`) used by staged checks, impact-review preparation and validation, and impact reports.
+  - Classify source paths from a single extension table in `source-classification`, with parity tests against the Tree-sitter catalog and the builtin extractor.
+  - Remove analyzed files from the ts-morph project after each v1 and v2 analysis.
+  - Add an optional `timeoutMs` budget to `SymbolExtractorV2AnalyzeInput`; the host sets it slightly below its own deadline, so providers report their own timeout. Tree-sitter uses a bounded, persistent worker pool with grammars loaded once per worker, and the host analyzes up to four changed files at a time.
+
+- Updated dependencies [db5376c]
+- Updated dependencies [8622782]
+  - kibi-plugin-sdk@0.4.0
+
+## 0.3.0
+
+### Minor Changes
+
+- 0128b56: Kibi now helps agents keep one shared vocabulary instead of letting every requirement invent its own. `kibi check` warns when two unrelated requirements state the same obligation. Units are compared in canonical form, so "30 min" matches "1800 s", and each warning names the exact facts involved. It also flags subject keys copied from a requirement ID, subject keys that don't follow `component.aspect`, predicates whose arguments read like prose, and entity files whose name doesn't match their ID. All of these are non-blocking warnings or info notes, so existing knowledge bases keep passing.
+
+  When you model a new requirement, Kibi now ranks the subjects that already exist and either reuses one or explicitly declares a new one. It also flags claims that look like possible duplicates. An intentional restatement can be recorded with the new `restates` relationship. Skills and docs now recommend naming entities by the behavior they govern (`REQ-cli-gc`) instead of a sequence number (`REQ-042`). Existing numbered IDs stay valid.
+
+  Predicate schemas can now declare the allowed values for an argument, plus the old spellings that map onto them. New facts must use those values. `kibi check` reports predicate facts that don't match any schema, and `kibi migrate` can fix the mechanical cases after you approve the plan hash. It moves a fact to the only namespace whose schema matches, and rewrites old spellings to the declared value. Everything that needs judgment stays a review item.
+  - core: new `semantic_quality.pl` (`entity-id-style`, `domain-redundancy`, `domain-implication`, `subject-key-identity`, `subject-key-shape`, `ontology-quality`) and `units.pl`. Unit canonicalization is used for comparison only, and unknown or ambiguous units such as `KB` are never equated. Adds the `restates` req→req relationship and an optional `diagnosticSeverity` in the rule registry. Adds `:- encoding(utf8)` to modules that contain non-ASCII text.
+  - cli/mcp: `restates` is wired through the extractors, schemas, and mutation paths. `entity-id-style` warnings are reported on `kb_upsert` creates and on staged added or renamed entity files. `kb_model_requirement` returns `vocabularyAlignment` (subject decision, candidates, redundancy candidates, stamps, `fallbackUsed`). Ontology-quality thresholds can be set with `KIBI_ONTOLOGY_QUALITY_MAX_SINGLETON_RATIO` / `KIBI_ONTOLOGY_QUALITY_MIN_FACTS`. `kb_compile_intent` create mode now keeps a caller-supplied `requirementId`. `kibi check --staged` now also prints its pass line when metadata-only staged changes have only advisory findings, matching the staged-symbol path.
+  - cli/mcp: `predicate_schema` facts accept `argument_constants` and `argument_aliases`, stored like `rule_ir` as JSON. `kb_upsert` / `kb_validate_upsert` reject malformed vocabularies and predicate facts that use undeclared values or aliases. `kb_suggest_predicates` binds aliases to their constant and leaves undeclared values unbound. The new advisory TypeScript rule `predicate-schema-conformance` checks predicate facts against project schemas and the built-in catalog. Its mechanical repairs become automatic `predicate_schema_alignment` migration actions that carry the exact `kb_upsert` input and re-read the fact before writing.
+  - core: `ontology-quality` findings name the prose-like arguments.
+  - plugin-sdk: new `kibi.vocabulary-alignment.v1` capability (`rankSubjects`, `compareClaims`) with result validators.
+  - plugin-builtin: deterministic offline provider (IDF-weighted subject ranking and negation- and quantity-aware claim similarity).
+  - plugin-jev: Jev-backed provider. It runs in replace, augment, or shadow mode with builtin fallback, and makes network calls only when it is activated for `kb_model_requirement`. `kb_check` never calls a provider.
+  - runtime and agent adapters: regenerated skill mirrors with the naming guidance and `restates` direction docs.
+
+### Patch Changes
+
+- e5ab646: `kibi status` and every CLI command start faster on large knowledge bases. On
+  this repository, `kibi status` for a fresh KB drops from about 3 seconds to
+  about 1.7, and a command that needs neither schema validation nor symbol
+  extraction starts about 0.5 seconds sooner.
+  - `kb_status_json` skips the full-entity stale-reason scan when the KB is
+    fresh, because a fresh verdict already rules out every stale reason.
+  - `kibi-plugin-builtin` loads ts-morph (the TypeScript compiler) on first
+    symbol analysis instead of at import time.
+  - The CLI compiles its entity and relationship JSON schemas on first use.
+
+- Updated dependencies [0128b56]
+  - kibi-plugin-sdk@0.3.0
+
 ## 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
@@ -19,12 +74,10 @@
 ### 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

package/dist/index.d.ts

@@ -8,10 +8,11 @@ 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 { createBuiltinTsMorphSymbolExtractor, createBuiltinTsMorphSymbolExtractorV2, 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";
+export { BUILTIN_CLAIM_SIMILARITY_THRESHOLD, BUILTIN_SUBJECT_REUSE_THRESHOLD, BuiltinVocabularyAlignment, builtinSubjectDecision, claimSimilarity, createBuiltinVocabularyAlignment, rankSubjectCandidates, vocabularyTokens, type SubjectVocabularyEntry, } from "./vocabulary/builtin-vocabulary-alignment.js";
 /**
  * Default Kibi capability plugin.
  */
@@ -28,6 +29,8 @@ export declare const kibiPlugin: {
         semanticClassifier: import("kibi-plugin-sdk").SemanticClassifierV1;
         ontologyPack: import("kibi-plugin-sdk").OntologyPackV1;
         symbolExtractor: import("kibi-plugin-sdk").SymbolExtractorV1;
+        symbolExtractorV2: import("kibi-plugin-sdk").SymbolExtractorV2;
+        vocabularyAlignment: import("./index.js").BuiltinVocabularyAlignment;
     };
 };
 export default kibiPlugin;

package/dist/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiCA,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,qCAAqC,EACrC,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;AAGtC,OAAO,EACL,kCAAkC,EAClC,+BAA+B,EAC/B,0BAA0B,EAC1B,sBAAsB,EACtB,eAAe,EACf,gCAAgC,EAChC,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,sBAAsB,GAC5B,MAAM,8CAA8C,CAAC;AAEtD;;GAEG;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;CAgBrB,CAAC;AAGH,eAAe,UAAU,CAAC"}

package/dist/index.js

@@ -19,7 +19,8 @@ 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";
+import { createBuiltinTsMorphSymbolExtractor, createBuiltinTsMorphSymbolExtractorV2, } from "./symbols/ts-morph-extractor.js";
+import { createBuiltinVocabularyAlignment } from "./vocabulary/builtin-vocabulary-alignment.js";
 const packageJson = createRequire(import.meta.url)("../package.json");
 // implements REQ-capability-plugin-builtin-parity-v1
 export { createBuiltinOntologyPack } from "./ontology/builtin-ontology-pack.js";
@@ -42,13 +43,15 @@ export { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize
 // 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";
+export { createBuiltinTsMorphSymbolExtractor, createBuiltinTsMorphSymbolExtractorV2, 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";
+// implements REQ-kibi-vocabulary-alignment-capability
+export { BUILTIN_CLAIM_SIMILARITY_THRESHOLD, BUILTIN_SUBJECT_REUSE_THRESHOLD, BuiltinVocabularyAlignment, builtinSubjectDecision, claimSimilarity, createBuiltinVocabularyAlignment, rankSubjectCandidates, vocabularyTokens, } from "./vocabulary/builtin-vocabulary-alignment.js";
 /**
  * Default Kibi capability plugin.
  */
@@ -66,6 +69,8 @@ export const kibiPlugin = defineKibiPlugin({
         semanticClassifier: createBuiltinSemanticClassifier(),
         ontologyPack: createBuiltinOntologyPack(),
         symbolExtractor: createBuiltinTsMorphSymbolExtractor(),
+        symbolExtractorV2: createBuiltinTsMorphSymbolExtractorV2(),
+        vocabularyAlignment: createBuiltinVocabularyAlignment(),
     },
 });
 // implements REQ-capability-plugin-builtin-parity-v1

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

@@ -17,11 +17,11 @@
 */
 import { access, readFile } from "node:fs/promises";
 import * as path from "node:path";
-import { Project, SyntaxKind, } from "ts-morph";
+import { tsMorph } from "./ts-morph-runtime.js";
 import { SUPPORTED_SOURCE_EXTENSIONS, onlyCandidate, } from "./ts-morph-shared.js";
 // implements REQ-capability-plugin-builtin-parity-v1
 export async function enrichSymbolCoordinatesWithTsMorph(entries, workspaceRoot) {
-    const project = new Project({
+    const project = new (tsMorph().Project)({
         skipAddingFilesFromTsConfig: true,
     });
     const sourceFileCache = new Map();
@@ -146,7 +146,7 @@ function findNamedDeclaration(sourceFile, title) {
             for (const declaration of statement.getDeclarations()) {
                 if (declaration.getName() !== qualifiedMethod.className)
                     continue;
-                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                const classExpression = declaration.getInitializerIfKind(tsMorph().SyntaxKind.ClassExpression);
                 const match = classExpression
                     ? findClassMember(classExpression, qualifiedMethod.methodName)
                     : null;
@@ -248,7 +248,7 @@ function findNamedDeclaration(sourceFile, title) {
             if (!statement.isExported())
                 continue;
             for (const declaration of statement.getDeclarations()) {
-                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                const classExpression = declaration.getInitializerIfKind(tsMorph().SyntaxKind.ClassExpression);
                 if (!classExpression)
                     continue;
                 for (const method of classExpression.getMethods()) {
@@ -294,7 +294,7 @@ function findNamedDeclaration(sourceFile, title) {
             if (!statement.isExported())
                 continue;
             for (const declaration of statement.getDeclarations()) {
-                const classExpression = declaration.getInitializerIfKind(SyntaxKind.ClassExpression);
+                const classExpression = declaration.getInitializerIfKind(tsMorph().SyntaxKind.ClassExpression);
                 if (!classExpression)
                     continue;
                 for (const property of classExpression.getProperties()) {

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

@@ -1,8 +1,10 @@
-import type { SourceAnalysisProvider, SymbolExtractorV1 } from "kibi-plugin-sdk";
+import type { SourceAnalysisProvider, SymbolExtractorV1, SymbolExtractorV2 } from "kibi-plugin-sdk";
 /**
  * Built-in ts-morph symbol extractor. Behavior matches the historical CLI
  * `createTsMorphSourceAnalysisProvider` analysis path.
  */
 export declare function createBuiltinTsMorphSymbolExtractor(): SymbolExtractorV1;
+/** Built-in asynchronous ts-morph extractor for the source-bound v2 contract. */
+export declare function createBuiltinTsMorphSymbolExtractorV2(): SymbolExtractorV2;
 export declare function createBuiltinTsMorphSourceAnalysisProvider(): SourceAnalysisProvider;
 //# sourceMappingURL=ts-morph-extractor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ts-morph-extractor.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-extractor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,sBAAsB,EAItB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAmBzB;;;GAGG;AAEH,wBAAgB,mCAAmC,IAAI,iBAAiB,CA8BvE;AAGD,wBAAgB,0CAA0C,IAAI,sBAAsB,CAEnF"}
+{"version":3,"file":"ts-morph-extractor.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-extractor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,sBAAsB,EAMtB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAsDzB;;;GAGG;AAEH,wBAAgB,mCAAmC,IAAI,iBAAiB,CA4CvE;AAED,iFAAiF;AAEjF,wBAAgB,qCAAqC,IAAI,iBAAiB,CAqHzE;AA+BD,wBAAgB,0CAA0C,IAAI,sBAAsB,CAEnF"}

package/dist/symbols/ts-morph-extractor.js

@@ -17,63 +17,229 @@
 */
 import * as path from "node:path";
 import { toSourceAnalysisProvider } from "kibi-plugin-sdk";
-import { Project, SyntaxKind, } from "ts-morph";
+import { tsMorph } from "./ts-morph-runtime.js";
 import { SUPPORTED_SOURCE_EXTENSIONS, chooseScriptKind, formatMethodSymbolName, isPrivateClassMember, } from "./ts-morph-shared.js";
 const EXTRACTOR_ID = "kibi-plugin-builtin.ts-morph";
+function normalizeV2ScriptLanguage(language) {
+    const normalized = language?.trim().toLowerCase();
+    if (["javascript", "js", "node", "nodejs"].includes(normalized ?? "")) {
+        return "javascript";
+    }
+    if (["typescript", "ts"].includes(normalized ?? "")) {
+        return "typescript";
+    }
+    return undefined;
+}
+function v2ScriptKind(filePath, languageHint) {
+    const extension = path.extname(filePath).toLowerCase();
+    const language = normalizeV2ScriptLanguage(languageHint);
+    if (SUPPORTED_SOURCE_EXTENSIONS.has(extension)) {
+        if (languageHint !== undefined && language === undefined)
+            return undefined;
+        if (language !== undefined && language !== inferSourceLanguage(filePath)) {
+            return undefined;
+        }
+        return chooseScriptKind(filePath);
+    }
+    if (extension === "" && language !== undefined) {
+        return language === "typescript"
+            ? tsMorph().ScriptKind.TS
+            : tsMorph().ScriptKind.JS;
+    }
+    return undefined;
+}
 /**
  * Built-in ts-morph symbol extractor. Behavior matches the historical CLI
  * `createTsMorphSourceAnalysisProvider` analysis path.
  */
 // implements REQ-capability-plugin-builtin-parity-v1
 export function createBuiltinTsMorphSymbolExtractor() {
-    const project = new Project({
-        skipAddingFilesFromTsConfig: true,
-    });
+    // Plugin registration creates the extractor on every CLI start; the project
+    // (and the TypeScript compiler behind it) is built on the first analysis.
+    let project;
+    const getProject = () => {
+        project ??= new (tsMorph().Project)({ skipAddingFilesFromTsConfig: true });
+        return project;
+    };
     return {
         id: EXTRACTOR_ID,
         supports(input) {
             return SUPPORTED_SOURCE_EXTENSIONS.has(path.extname(input.path).toLowerCase());
         },
         analyze(input) {
-            const sourceFile = project.createSourceFile(input.path, input.content, {
+            const sourceFile = getProject().createSourceFile(input.path, input.content, {
                 overwrite: true,
                 scriptKind: chooseScriptKind(input.path),
             });
-            return {
-                sourceFile: input.path,
-                language: inferSourceLanguage(input.path),
-                module: {
-                    title: inferModuleTitle(input.path),
+            try {
+                return {
+                    sourceFile: input.path,
                     language: inferSourceLanguage(input.path),
-                    analysisMode: "parser",
-                },
-                symbols: collectSourceSymbols(sourceFile),
+                    module: {
+                        title: inferModuleTitle(input.path),
+                        language: inferSourceLanguage(input.path),
+                        analysisMode: "parser",
+                    },
+                    symbols: collectSourceSymbols(sourceFile),
+                };
+            }
+            finally {
+                // Analysis is per file and purely syntactic; keeping files would grow
+                // the project without bound in a long-running daemon.
+                getProject().removeSourceFile(sourceFile);
+            }
+        },
+    };
+}
+/** Built-in asynchronous ts-morph extractor for the source-bound v2 contract. */
+// implements REQ-capability-plugin-builtin-parity-v1
+export function createBuiltinTsMorphSymbolExtractorV2() {
+    // Like the v1 extractor, build the project (and load the TypeScript
+    // compiler) on the first analysis rather than at plugin registration.
+    let project;
+    const getProject = () => {
+        project ??= new (tsMorph().Project)({ skipAddingFilesFromTsConfig: true });
+        return project;
+    };
+    return {
+        id: `${EXTRACTOR_ID}.v2`,
+        supports(input) {
+            return v2ScriptKind(input.path, input.language) !== undefined;
+        },
+        async analyze(input) {
+            const extension = path.extname(input.path).toLowerCase();
+            const language = normalizeV2ScriptLanguage(input.language) ??
+                (input.language?.trim() ||
+                    (SUPPORTED_SOURCE_EXTENSIONS.has(extension)
+                        ? inferSourceLanguage(input.path)
+                        : "unknown"));
+            const module = {
+                title: inferModuleTitle(input.path),
+                language,
+                analysisMode: "parser",
             };
+            const scriptKind = v2ScriptKind(input.path, input.language);
+            if (scriptKind === undefined) {
+                return {
+                    contractVersion: "kibi.symbol-extractor.v2",
+                    status: "unsupported",
+                    sourceFile: input.path,
+                    language,
+                    module,
+                    symbols: [],
+                    diagnostics: [
+                        {
+                            code: "UNSUPPORTED_SOURCE_TYPE",
+                            message: `The built-in ts-morph extractor does not support '${path.extname(input.path) || "extensionless"}' files`,
+                        },
+                    ],
+                    uncoveredRanges: [],
+                };
+            }
+            let sourceFile;
+            try {
+                sourceFile = getProject().createSourceFile(input.path, input.content, {
+                    overwrite: true,
+                    scriptKind,
+                });
+                const analyzed = sourceFile;
+                const diagnostics = analyzed
+                    .getProject()
+                    .getProgram()
+                    .getSyntacticDiagnostics(analyzed)
+                    .map((diagnostic) => {
+                    const start = diagnostic.getStart();
+                    const length = diagnostic.getLength();
+                    const range = start === undefined
+                        ? wholeSourceRange(analyzed, input.content)
+                        : sourceRangeAtOffsets(analyzed, input.content, start, start + (length ?? 0));
+                    const message = diagnostic.getMessageText();
+                    return {
+                        code: `TS${diagnostic.getCode()}`,
+                        message: typeof message === "string"
+                            ? message
+                            : message.getMessageText(),
+                        range,
+                    };
+                });
+                const result = {
+                    contractVersion: "kibi.symbol-extractor.v2",
+                    status: diagnostics.length > 0 ? "partial" : "ok",
+                    sourceFile: input.path,
+                    language,
+                    module,
+                    symbols: collectSourceSymbols(analyzed, true),
+                    diagnostics,
+                    uncoveredRanges: diagnostics.map(({ range, code }) => ({
+                        ...range,
+                        reason: `The TypeScript parser reported ${code} at this source span.`,
+                    })),
+                };
+                return result;
+            }
+            catch (error) {
+                return {
+                    contractVersion: "kibi.symbol-extractor.v2",
+                    status: "failed",
+                    sourceFile: input.path,
+                    language,
+                    module,
+                    symbols: [],
+                    diagnostics: [
+                        {
+                            code: "SOURCE_ANALYSIS_FAILED",
+                            message: error instanceof Error
+                                ? error.message
+                                : "The built-in ts-morph extractor failed",
+                        },
+                    ],
+                    uncoveredRanges: [],
+                };
+            }
+            finally {
+                if (sourceFile)
+                    getProject().removeSourceFile(sourceFile);
+            }
         },
     };
 }
+function sourceRangeAtOffsets(sourceFile, content, startOffset, endOffset) {
+    const boundedStart = Math.min(Math.max(startOffset, 0), content.length);
+    const boundedEnd = Math.min(Math.max(endOffset, boundedStart), content.length);
+    const start = sourceFile.getLineAndColumnAtPos(boundedStart);
+    const end = sourceFile.getLineAndColumnAtPos(boundedEnd);
+    return {
+        startLine: start.line,
+        startColumn: Math.max(0, start.column - 1),
+        endLine: end.line,
+        endColumn: Math.max(0, end.column - 1),
+    };
+}
+function wholeSourceRange(sourceFile, content) {
+    return sourceRangeAtOffsets(sourceFile, content, 0, content.length);
+}
 // implements REQ-capability-plugin-builtin-parity-v1
 export function createBuiltinTsMorphSourceAnalysisProvider() {
     return toSourceAnalysisProvider(createBuiltinTsMorphSymbolExtractor());
 }
-function collectSourceSymbols(sourceFile) {
+function collectSourceSymbols(sourceFile, includeV2Fields = false) {
     const symbols = [];
     for (const decl of sourceFile.getFunctions()) {
         if (!decl.isExported())
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "function", decl.getNameNode() ?? decl, decl, 
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "function", decl.getNameNode() ?? decl, decl, 
         // Functions: leading trivia via getFullText + JSDoc (historical CLI).
-        fullTextWithJsDocs(decl)));
+        fullTextWithJsDocs(decl), includeV2Fields));
     }
     for (const decl of sourceFile.getClasses()) {
         if (!decl.isExported())
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "class", decl.getNameNode() ?? decl, decl, 
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "class", decl.getNameNode() ?? decl, decl, 
         // Leading comments + JSDoc only — never the class body (method
         // `// implements` must stay on the method symbol).
-        leadingCommentsAndJsDocs(sourceFile, decl)));
+        leadingCommentsAndJsDocs(sourceFile, decl), includeV2Fields));
         try {
-            appendClassMembers(sourceFile, decl, decl.getName(), symbols);
+            appendClassMembers(sourceFile, decl, decl.getName(), symbols, includeV2Fields);
         }
         catch {
             // Skip malformed class member walks; keep the class symbol.
@@ -82,42 +248,44 @@ function collectSourceSymbols(sourceFile) {
     for (const decl of sourceFile.getInterfaces()) {
         if (!decl.isExported())
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "interface", decl.getNameNode() ?? decl, decl, 
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "interface", decl.getNameNode() ?? decl, decl, 
         // Historical CLI used getText(); keep calling it so characterization
         // mocks that throw from getText still isolate the failure.
-        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`, includeV2Fields));
     }
     for (const decl of sourceFile.getTypeAliases()) {
         if (!decl.isExported())
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "type", decl.getNameNode() ?? decl, decl, `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "type", decl.getNameNode() ?? decl, decl, `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`, includeV2Fields));
     }
     for (const decl of sourceFile.getEnums()) {
         if (!decl.isExported())
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "enum", decl.getNameNode() ?? decl, decl, 
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, decl.getName() ?? "<anonymous>", "enum", decl.getNameNode() ?? decl, decl, 
         // Enums historically used getText(); prefer leading comments when the
         // real AST is available, else getText for test doubles.
-        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`));
+        `${leadingCommentsAndJsDocs(sourceFile, decl)}\n${safeGetText(decl)}`, includeV2Fields));
     }
     for (const statement of sourceFile.getVariableStatements()) {
         if (!statement.isExported())
             continue;
         for (const declaration of statement.getDeclarations()) {
-            pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, declaration.getName(), "variable", declaration.getNameNode() ?? declaration, declaration, 
+            pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, declaration.getName(), "variable", declaration.getNameNode() ?? declaration, declaration, 
             // Statement carries leading `// implements`; declaration text is the
             // historical fallback when only getText is stubbed in tests.
-            `${safeFullText(statement)}\n${safeGetText(declaration)}`));
+            `${safeFullText(statement)}\n${safeGetText(declaration)}`, includeV2Fields));
             try {
                 const classExpression = typeof declaration.getInitializerIfKind === "function"
-                    ? declaration.getInitializerIfKind(SyntaxKind.ClassExpression)
+                    ? declaration.getInitializerIfKind(tsMorph().SyntaxKind.ClassExpression)
                     : undefined;
                 if (classExpression) {
-                    appendClassMembers(sourceFile, classExpression, declaration.getName(), symbols);
+                    appendClassMembers(sourceFile, classExpression, declaration.getName(), symbols, includeV2Fields);
                 }
             }
-            catch {
-                // Skip malformed class-expression members; keep the variable symbol.
+            catch (error) {
+                if (includeV2Fields)
+                    throw error;
+                // Preserve legacy v1 class-expression recovery.
             }
         }
     }
@@ -160,7 +328,7 @@ function safeFullText(node) {
 function safeGetText(node) {
     return typeof node.getText === "function" ? node.getText() : "";
 }
-function appendClassMembers(sourceFile, declaration, className, symbols) {
+function appendClassMembers(sourceFile, declaration, className, symbols, includeV2Fields) {
     // Inherit class *leading* ownership comments onto members (not the class
     // body). Method-local `// implements` stay on the method via getFullText.
     const classLeading = leadingCommentsAndJsDocs(sourceFile, declaration);
@@ -170,7 +338,7 @@ function appendClassMembers(sourceFile, declaration, className, symbols) {
     for (const method of methods) {
         if (isPrivateClassMember(method))
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, method.getName()), "method", method.getNameNode() ?? method, method, `${classLeading}\n${fullTextWithJsDocs(method)}`));
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, method.getName()), "method", method.getNameNode() ?? method, method, `${classLeading}\n${fullTextWithJsDocs(method)}`, includeV2Fields, className));
     }
     const properties = typeof declaration.getProperties === "function"
         ? declaration.getProperties()
@@ -178,7 +346,7 @@ function appendClassMembers(sourceFile, declaration, className, symbols) {
     for (const property of properties) {
         if (isPrivateClassMember(property))
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, property.getName()), "property", property.getNameNode() ?? property, property, `${classLeading}\n${fullTextWithJsDocs(property)}`));
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, property.getName()), "property", property.getNameNode() ?? property, property, `${classLeading}\n${fullTextWithJsDocs(property)}`, includeV2Fields, className));
     }
     const accessors = [
         ...(typeof declaration.getGetAccessors === "function"
@@ -188,24 +356,47 @@ function appendClassMembers(sourceFile, declaration, className, symbols) {
             ? declaration.getSetAccessors()
             : []),
     ];
+    const pairedAccessors = new Set();
     for (const accessor of accessors) {
         if (isPrivateClassMember(accessor))
             continue;
-        pushSymbol(symbols, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, accessor.getName()), "accessor", accessor.getNameNode() ?? accessor, accessor, `${classLeading}\n${fullTextWithJsDocs(accessor)}`));
+        if (pairedAccessors.has(accessor))
+            continue;
+        if (includeV2Fields) {
+            const candidates = accessors.filter((candidate) => candidate.getName() === accessor.getName() &&
+                candidate.isStatic() === accessor.isStatic());
+            const other = candidates.find((candidate) => candidate !== accessor);
+            if (candidates.length === 2 &&
+                other &&
+                other.getKind() !== accessor.getKind()) {
+                const first = accessor.getStart() < other.getStart() ? accessor : other;
+                const last = first === accessor ? other : accessor;
+                // A complementary getter/setter pair is one authored property. Keep
+                // both bodies in its span without assigning the same ID twice.
+                const symbol = toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, accessor.getName()), "accessor", first.getNameNode() ?? first, last, `${classLeading}\n${fullTextWithJsDocs(first)}\n${fullTextWithJsDocs(last)}`, true, className);
+                symbols.push({ ...symbol, nativeKind: "AccessorPair" });
+                pairedAccessors.add(accessor);
+                pairedAccessors.add(other);
+                continue;
+            }
+        }
+        pushSymbol(symbols, includeV2Fields, () => toSourceSymbolAnalysis(sourceFile, formatMethodSymbolName(className, accessor.getName()), "accessor", accessor.getNameNode() ?? accessor, accessor, `${classLeading}\n${fullTextWithJsDocs(accessor)}`, includeV2Fields, className));
     }
 }
-function pushSymbol(symbols, build) {
+function pushSymbol(symbols, strict, build) {
     try {
         symbols.push(build());
     }
-    catch {
-        // Skip malformed declarations; keep sibling symbols.
+    catch (error) {
+        if (strict)
+            throw error;
+        // Preserve legacy v1 recovery; v2 must expose extraction failure.
     }
 }
-function toSourceSymbolAnalysis(sourceFile, name, kind, startNode, endNode, directiveText) {
+function toSourceSymbolAnalysis(sourceFile, name, kind, startNode, endNode, directiveText, includeV2Fields = false, containerName) {
     const start = sourceFile.getLineAndColumnAtPos(startNode.getStart());
     const end = sourceFile.getLineAndColumnAtPos(endNode.getEnd());
-    return {
+    const result = {
         name,
         kind,
         startLine: start.line,
@@ -214,6 +405,35 @@ function toSourceSymbolAnalysis(sourceFile, name, kind, startNode, endNode, dire
         endColumn: Math.max(0, end.column - 1),
         directiveText,
     };
+    if (!includeV2Fields)
+        return result;
+    const nameKind = startNode.getKindName();
+    const hasNameNode = [
+        "Identifier",
+        "PrivateIdentifier",
+        "StringLiteral",
+        "NumericLiteral",
+        "NoSubstitutionTemplateLiteral",
+        "ComputedPropertyName",
+    ].includes(nameKind);
+    const nameRangeStart = sourceFile.getLineAndColumnAtPos(startNode.getStart());
+    const nameRangeEnd = sourceFile.getLineAndColumnAtPos(startNode.getEnd());
+    return {
+        ...result,
+        qualifiedName: name,
+        ...(containerName ? { containerName } : {}),
+        nativeKind: endNode.getKindName(),
+        ...(hasNameNode
+            ? {
+                nameRange: {
+                    startLine: nameRangeStart.line,
+                    startColumn: Math.max(0, nameRangeStart.column - 1),
+                    endLine: nameRangeEnd.line,
+                    endColumn: Math.max(0, nameRangeEnd.column - 1),
+                },
+            }
+            : {}),
+    };
 }
 function inferSourceLanguage(filePath) {
     const extension = path.extname(filePath).toLowerCase();

package/dist/symbols/ts-morph-granularity.js

@@ -15,7 +15,7 @@
  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 { Project } from "ts-morph";
+import { tsMorph } from "./ts-morph-runtime.js";
 import { chooseScriptKind, isPrivateClassMember } from "./ts-morph-shared.js";
 /**
  * Collect exported (and unique bare method) symbol candidates used by
@@ -23,7 +23,7 @@ import { chooseScriptKind, isPrivateClassMember } from "./ts-morph-shared.js";
  */
 // implements REQ-capability-plugin-builtin-parity-v1
 export function collectGranularityCandidates(filePath, content) {
-    const source = new Project({
+    const source = new (tsMorph().Project)({
         skipAddingFilesFromTsConfig: true,
     }).createSourceFile(`${filePath}::granularity`, content, {
         overwrite: true,

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

@@ -0,0 +1,10 @@
+import type * as TsMorph from "ts-morph";
+/**
+ * ts-morph loads the full TypeScript compiler (~150 ms). Consumers import this
+ * package for its predicate rules and plugin registry on every CLI command, so
+ * the compiler is loaded on first use by a symbol extractor instead of at
+ * import time. ts-morph is this package's own dependency, so resolving it from
+ * here always finds the declared version.
+ */
+export declare function tsMorph(): typeof TsMorph;
+//# sourceMappingURL=ts-morph-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ts-morph-runtime.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-runtime.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,OAAO,MAAM,UAAU,CAAC;AAIzC;;;;;;GAMG;AACH,wBAAgB,OAAO,IAAI,OAAO,OAAO,CAGxC"}

package/dist/symbols/ts-morph-runtime.js

@@ -0,0 +1,31 @@
+/*
+ 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/>.
+*/
+// implements REQ-capability-plugin-builtin-parity-v1
+import { createRequire } from "node:module";
+let loaded;
+/**
+ * ts-morph loads the full TypeScript compiler (~150 ms). Consumers import this
+ * package for its predicate rules and plugin registry on every CLI command, so
+ * the compiler is loaded on first use by a symbol extractor instead of at
+ * import time. ts-morph is this package's own dependency, so resolving it from
+ * here always finds the declared version.
+ */
+export function tsMorph() {
+    loaded ??= createRequire(import.meta.url)("ts-morph");
+    return loaded;
+}

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

@@ -1,4 +1,4 @@
-import { Scope, ScriptKind, SyntaxKind } from "ts-morph";
+import type { Scope, ScriptKind, SyntaxKind } from "ts-morph";
 export declare const SUPPORTED_SOURCE_EXTENSIONS: Set<string>;
 export declare function chooseScriptKind(filePath: string): ScriptKind;
 export declare function formatMethodSymbolName(className: string | undefined, methodName: string): string;

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

@@ -1 +1 @@
-{"version":3,"file":"ts-morph-shared.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-shared.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGzD,eAAO,MAAM,2BAA2B,aAStC,CAAC;AAGH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAY7D;AAGD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED;;;GAGG;AAEH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,MAAM,CAAC;IACvB,WAAW,CAAC,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CAC1C,GAAG,OAAO,CAYV;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAGxE"}
+{"version":3,"file":"ts-morph-shared.d.ts","sourceRoot":"","sources":["../../src/symbols/ts-morph-shared.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI9D,eAAO,MAAM,2BAA2B,aAStC,CAAC;AAGH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAY7D;AAGD,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED;;;GAGG;AAEH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,MAAM,CAAC;IACvB,WAAW,CAAC,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;CAC1C,GAAG,OAAO,CAYV;AAGD,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAGxE"}

package/dist/symbols/ts-morph-shared.js

@@ -15,7 +15,7 @@
  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 { Scope, ScriptKind, SyntaxKind } from "ts-morph";
+import { tsMorph } from "./ts-morph-runtime.js";
 // implements REQ-capability-plugin-builtin-parity-v1
 export const SUPPORTED_SOURCE_EXTENSIONS = new Set([
     ".ts",
@@ -31,15 +31,15 @@ export const SUPPORTED_SOURCE_EXTENSIONS = new Set([
 export function chooseScriptKind(filePath) {
     const lower = filePath.toLowerCase();
     if (lower.endsWith(".tsx"))
-        return ScriptKind.TSX;
+        return tsMorph().ScriptKind.TSX;
     if (lower.endsWith(".ts") ||
         lower.endsWith(".mts") ||
         lower.endsWith(".cts")) {
-        return ScriptKind.TS;
+        return tsMorph().ScriptKind.TS;
     }
     if (lower.endsWith(".jsx"))
-        return ScriptKind.JSX;
-    return ScriptKind.JS;
+        return tsMorph().ScriptKind.JSX;
+    return tsMorph().ScriptKind.JS;
 }
 // implements REQ-capability-plugin-builtin-parity-v1
 export function formatMethodSymbolName(className, methodName) {
@@ -56,10 +56,10 @@ export function isPrivateClassMember(member) {
         return true;
     }
     if (typeof member.hasModifier === "function") {
-        return member.hasModifier(SyntaxKind.PrivateKeyword);
+        return member.hasModifier(tsMorph().SyntaxKind.PrivateKeyword);
     }
     if (typeof member.getScope === "function") {
-        return member.getScope() === Scope.Private;
+        return member.getScope() === tsMorph().Scope.Private;
     }
     return false;
 }

package/dist/vocabulary/builtin-vocabulary-alignment.d.ts

@@ -0,0 +1,47 @@
+import { type CompareClaimsInput, type CompareClaimsResult, type RankSubjectsInput, type RankSubjectsResult, type SubjectCandidate, type SubjectRankingDecision, type VocabularyAlignmentV1 } from "kibi-plugin-sdk";
+/** Minimum builtin score for reusing an existing subject instead of a new one. */
+export declare const BUILTIN_SUBJECT_REUSE_THRESHOLD = 0.4;
+/** Conservative token-similarity bar for flagging a possible duplicate claim. */
+export declare const BUILTIN_CLAIM_SIMILARITY_THRESHOLD = 0.75;
+/** One existing subject fact as read from the KB. */
+export type SubjectVocabularyEntry = Readonly<{
+    subjectKey: string;
+    title?: string;
+    factId?: string;
+    requirements?: readonly Readonly<{
+        id: string;
+        title?: string;
+    }>[];
+}>;
+/**
+ * Deterministic content tokens: lowercase alphanumeric words, stopwords
+ * removed, simple plural folding. Dots and underscores split subject keys.
+ */
+export declare function vocabularyTokens(text: string): string[];
+/**
+ * Rank existing subjects for one clause. Score = 0.5 * subject-key match +
+ * 0.3 * subject-title match + 0.2 * best constraining-requirement-title match,
+ * where a match is the IDF-weighted Tversky index over the vocabulary (tokens shared
+ * by every subject, such as a product name, weigh little).
+ * Ties break by subject key, so the ranking is fully deterministic.
+ */
+export declare function rankSubjectCandidates(clauseText: string, vocabulary: readonly SubjectVocabularyEntry[], options?: Readonly<{
+    limit?: number;
+}>): SubjectCandidate[];
+/**
+ * Dice similarity over content tokens. Claims whose negation differs are never
+ * similar ("must expire" vs "must not expire"), and neither are claims whose
+ * quantities differ ("15 minutes" vs "60 minutes"): token overlap cannot tell
+ * which of two different bounds is meant, so the builtin stays conservative and
+ * leaves unit-converted paraphrases to Prolog canonicalization or a provider.
+ */
+export declare function claimSimilarity(left: string, right: string): number;
+export declare function builtinSubjectDecision(clause: RankSubjectsInput["clauses"][number]): SubjectRankingDecision;
+/** Deterministic, offline vocabulary-alignment provider. */
+export declare class BuiltinVocabularyAlignment implements VocabularyAlignmentV1 {
+    readonly id = "kibi-plugin-builtin.vocabulary-alignment";
+    rankSubjects(input: RankSubjectsInput): RankSubjectsResult;
+    compareClaims(input: CompareClaimsInput): CompareClaimsResult;
+}
+export declare function createBuiltinVocabularyAlignment(): BuiltinVocabularyAlignment;
+//# sourceMappingURL=builtin-vocabulary-alignment.d.ts.map

package/dist/vocabulary/builtin-vocabulary-alignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-vocabulary-alignment.d.ts","sourceRoot":"","sources":["../../src/vocabulary/builtin-vocabulary-alignment.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAExB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAGzB,kFAAkF;AAElF,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD,iFAAiF;AAEjF,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAEvD,qDAAqD;AAErD,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,SAAS,QAAQ,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CACpE,CAAC,CAAC;AA8CH;;;GAGG;AAEH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOvD;AA6CD;;;;;;GAMG;AAEH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,SAAS,sBAAsB,EAAE,EAC7C,OAAO,GAAE,QAAQ,CAAC;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAM,GACzC,gBAAgB,EAAE,CAoDpB;AAYD;;;;;;GAMG;AAEH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWnE;AAcD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GAC3C,sBAAsB,CA4BxB;AAED,4DAA4D;AAE5D,qBAAa,0BAA2B,YAAW,qBAAqB;IACtE,QAAQ,CAAC,EAAE,8CAA8C;IAEzD,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB;IAI1D,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB;CAc9D;AAGD,wBAAgB,gCAAgC,IAAI,0BAA0B,CAE7E"}

package/dist/vocabulary/builtin-vocabulary-alignment.js

@@ -0,0 +1,261 @@
+/*
+ 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 { NEW_SUBJECT_CHOICE, } from "kibi-plugin-sdk";
+import { singularize } from "../ontology/normalize.js";
+/** Minimum builtin score for reusing an existing subject instead of a new one. */
+// implements REQ-kibi-vocabulary-alignment-capability
+export const BUILTIN_SUBJECT_REUSE_THRESHOLD = 0.4;
+/** Conservative token-similarity bar for flagging a possible duplicate claim. */
+// implements REQ-kibi-vocabulary-alignment-capability
+export const BUILTIN_CLAIM_SIMILARITY_THRESHOLD = 0.75;
+const STOPWORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "by",
+    "can",
+    "for",
+    "from",
+    "has",
+    "have",
+    "in",
+    "into",
+    "is",
+    "it",
+    "its",
+    "may",
+    "must",
+    "of",
+    "on",
+    "or",
+    "shall",
+    "should",
+    "so",
+    "than",
+    "that",
+    "the",
+    "their",
+    "then",
+    "this",
+    "to",
+    "was",
+    "when",
+    "which",
+    "while",
+    "will",
+    "with",
+]);
+const NEGATIONS = new Set(["not", "never", "no", "without", "forbid"]);
+/**
+ * Deterministic content tokens: lowercase alphanumeric words, stopwords
+ * removed, simple plural folding. Dots and underscores split subject keys.
+ */
+// implements REQ-kibi-vocabulary-alignment-capability
+export function vocabularyTokens(text) {
+    return text
+        .toLowerCase()
+        .replace(/['’]/g, "")
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 0 && !STOPWORDS.has(token))
+        .map((token) => singularize(token));
+}
+function tokenSet(text) {
+    return new Set(vocabularyTokens(text));
+}
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+/** Weight of clause tokens the subject does not explain (Tversky beta). */
+const UNEXPLAINED_CLAUSE_WEIGHT = 0.2;
+/**
+ * IDF-weighted Tversky index between the clause and one target token set.
+ * Target tokens the clause misses count fully; clause tokens the target does
+ * not explain count lightly, because a subject names a component rather than
+ * the whole clause. A specific subject that matches more of the clause
+ * therefore beats a short generic one that happens to be fully covered.
+ */
+function weightedMatch(clause, target, weight) {
+    let matched = 0;
+    let missedTarget = 0;
+    for (const token of target) {
+        const w = weight(token);
+        if (clause.has(token))
+            matched += w;
+        else
+            missedTarget += w;
+    }
+    if (matched === 0)
+        return 0;
+    let unexplainedClause = 0;
+    for (const token of clause) {
+        if (!target.has(token))
+            unexplainedClause += weight(token);
+    }
+    return (matched /
+        (matched + missedTarget + UNEXPLAINED_CLAUSE_WEIGHT * unexplainedClause));
+}
+/**
+ * Rank existing subjects for one clause. Score = 0.5 * subject-key match +
+ * 0.3 * subject-title match + 0.2 * best constraining-requirement-title match,
+ * where a match is the IDF-weighted Tversky index over the vocabulary (tokens shared
+ * by every subject, such as a product name, weigh little).
+ * Ties break by subject key, so the ranking is fully deterministic.
+ */
+// implements REQ-kibi-vocabulary-alignment-capability
+export function rankSubjectCandidates(clauseText, vocabulary, options = {}) {
+    const clause = tokenSet(clauseText);
+    if (clause.size === 0 || vocabulary.length === 0)
+        return [];
+    const documents = vocabulary.map((entry) => ({
+        entry,
+        key: tokenSet(entry.subjectKey),
+        title: tokenSet(entry.title ?? ""),
+        requirements: (entry.requirements ?? []).map((requirement) => tokenSet(requirement.title ?? "")),
+    }));
+    const documentFrequency = new Map();
+    for (const document of documents) {
+        const tokens = new Set([
+            ...document.key,
+            ...document.title,
+            ...document.requirements.flatMap((set) => [...set]),
+        ]);
+        for (const token of tokens) {
+            documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
+        }
+    }
+    const weight = (token) => Math.log(1 + documents.length / (documentFrequency.get(token) ?? 1));
+    const candidates = documents.map((document) => {
+        const keyScore = weightedMatch(clause, document.key, weight);
+        const titleScore = weightedMatch(clause, document.title, weight);
+        const requirementScore = Math.max(0, ...document.requirements.map((set) => weightedMatch(clause, set, weight)));
+        const requirementTitles = (document.entry.requirements ?? [])
+            .map((requirement) => requirement.title)
+            .filter((title) => typeof title === "string");
+        return {
+            subjectKey: document.entry.subjectKey,
+            score: round3(0.5 * keyScore + 0.3 * titleScore + 0.2 * requirementScore),
+            ...(document.entry.title !== undefined
+                ? { title: document.entry.title }
+                : {}),
+            ...(requirementTitles.length > 0 ? { requirementTitles } : {}),
+        };
+    });
+    return candidates
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score ||
+        left.subjectKey.localeCompare(right.subjectKey))
+        .slice(0, options.limit ?? 5);
+}
+/**
+ * Quantities as written: number plus the unit symbol that follows it, with the
+ * unit's case preserved (3 MB and 3 Mb are different quantities).
+ */
+function quantities(text) {
+    return [...text.matchAll(/(\d+(?:\.\d+)?)\s*([A-Za-z%]+)?/g)]
+        .map((match) => `${Number(match[1])}|${match[2] ?? ""}`)
+        .sort();
+}
+/**
+ * Dice similarity over content tokens. Claims whose negation differs are never
+ * similar ("must expire" vs "must not expire"), and neither are claims whose
+ * quantities differ ("15 minutes" vs "60 minutes"): token overlap cannot tell
+ * which of two different bounds is meant, so the builtin stays conservative and
+ * leaves unit-converted paraphrases to Prolog canonicalization or a provider.
+ */
+// implements REQ-kibi-vocabulary-alignment-capability
+export function claimSimilarity(left, right) {
+    const a = tokenSet(left);
+    const b = tokenSet(right);
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    if (quantities(left).join(" ") !== quantities(right).join(" "))
+        return 0;
+    const negatedA = [...a].some((token) => NEGATIONS.has(token));
+    const negatedB = [...b].some((token) => NEGATIONS.has(token));
+    if (negatedA !== negatedB)
+        return 0;
+    let shared = 0;
+    for (const token of a)
+        if (b.has(token))
+            shared += 1;
+    return round3((2 * shared) / (a.size + b.size));
+}
+function normalizedKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[\\/]+/g, ".")
+        .replace(/[^a-z0-9.]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/\.+/g, ".")
+        .replace(/(^[._]+|[._]+$)/g, "");
+}
+// implements REQ-kibi-vocabulary-alignment-capability
+export function builtinSubjectDecision(clause) {
+    const proposed = clause.proposedSubjectKey !== undefined
+        ? normalizedKey(clause.proposedSubjectKey)
+        : undefined;
+    const exact = clause.candidates.find((candidate) => candidate.subjectKey === proposed);
+    if (exact) {
+        return {
+            claimKey: clause.claimKey,
+            choice: exact.subjectKey,
+            confidence: 1,
+        };
+    }
+    const best = clause.candidates[0];
+    if (best && best.score >= BUILTIN_SUBJECT_REUSE_THRESHOLD) {
+        return {
+            claimKey: clause.claimKey,
+            choice: best.subjectKey,
+            confidence: best.score,
+        };
+    }
+    return {
+        claimKey: clause.claimKey,
+        choice: NEW_SUBJECT_CHOICE,
+        confidence: round3(1 - (best?.score ?? 0)),
+    };
+}
+/** Deterministic, offline vocabulary-alignment provider. */
+// implements REQ-kibi-vocabulary-alignment-capability
+export class BuiltinVocabularyAlignment {
+    id = "kibi-plugin-builtin.vocabulary-alignment";
+    rankSubjects(input) {
+        return { decisions: input.clauses.map(builtinSubjectDecision) };
+    }
+    compareClaims(input) {
+        const judgments = input.pairs.map((pair) => {
+            const similarity = claimSimilarity(pair.left.claimText, pair.right.claimText);
+            return {
+                pairKey: pair.pairKey,
+                sameObligation: similarity >= BUILTIN_CLAIM_SIMILARITY_THRESHOLD,
+                confidence: similarity,
+            };
+        });
+        return { judgments };
+    }
+}
+// implements REQ-kibi-vocabulary-alignment-capability
+export function createBuiltinVocabularyAlignment() {
+    return new BuiltinVocabularyAlignment();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-plugin-builtin",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Default Kibi capability plugins: TS symbol extraction, ontology pack, and semantic classifier",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "kibi-plugin-sdk": "^0.2.0",
+    "kibi-plugin-sdk": "^0.4.0",
     "ts-morph": "^23.0.0"
   },
   "devDependencies": {