kibi-plugin-builtin 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # kibi-plugin-builtin
 
+## 0.4.1
+
+### Patch Changes
+
+- d25a626: Kibi now answers questions on a CI checkout or any detached commit, compiles a cold knowledge base minutes faster, and can stop a runaway read before it blocks other agents. On a bare SHA, search, query, status, check, coverage and graph read a snapshot of that checkout and say so in every answer, while writes are refused with the command that fixes it. A cold `kibi sync` of the Kibi repository went from about 4 min 23 s to 19 s, and `--refresh-symbol-coordinates` from about 5 min 55 s to 26 s, with byte-identical results.
+
+  - Detached HEAD with zero or several local branches at HEAD: read-only operations (CLI routes, human commands, MCP tools) attach a read-only snapshot store (`kibi-internal/detached-head-snapshot`) compiled incrementally from the checkout's tracked sources, and add a `detached_head_read_only` warning diagnostic with the commit, branches at HEAD, store path and `writes: "refused"`. Write operations and `kibi sync` refuse with an actionable message (`git switch <branch>`, `git switch -c <branch>`, or `KIBI_BRANCH`). One branch at HEAD still attaches that branch exactly; no branch KB is ever guessed or written. `kibi engine stop/status` address the snapshot daemon, and `kibi gc` keeps the snapshot while it is in use.
+  - Sync: source-owned entity lookups before retracts run in batches of 200 instead of one engine round trip per path candidate; the Prolog client wakes on the answer frame instead of a 50 ms poll; TypeScript coordinate enrichment adds every source file before the first export check, so the type checker program is built once instead of once per file.
+  - Engine read limits: `KIBI_ENGINE_READ_TIME_LIMIT_MS` and `KIBI_ENGINE_READ_INFERENCE_LIMIT` (opt-in, unset by default) bound each read-only engine request with `call_with_time_limit/2` and `call_with_inference_limit/3`. A read that hits its limit fails with `QUERY_LIMIT_EXCEEDED` and `error.details.limitExceeded` (`kind`, `limit`) on the CLI and MCP envelopes, never with a partial answer; write requests, module loads and sync compilation are never bounded, while the read-only queries a write operation such as `kb_upsert` runs before writing count as reads and can stop it before anything is written.
+  - A CLI JSON route whose runtime cannot open (a detached HEAD refusing a write, no branch to attach) now prints an `OPERATION_FAILED` error envelope on stdout, not just a message on stderr.
+
+## 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
@@ -46,7 +82,6 @@
   - 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

package/dist/index.d.ts

@@ -8,7 +8,7 @@ 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";
@@ -29,6 +29,7 @@ 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;
     };
 };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA8BA,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;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;;;;;;;;;;;;;;;CAerB,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,7 @@ 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
@@ -43,7 +43,7 @@ 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
@@ -69,6 +69,7 @@ export const kibiPlugin = defineKibiPlugin({
         semanticClassifier: createBuiltinSemanticClassifier(),
         ontologyPack: createBuiltinOntologyPack(),
         symbolExtractor: createBuiltinTsMorphSymbolExtractor(),
+        symbolExtractorV2: createBuiltinTsMorphSymbolExtractorV2(),
         vocabularyAlignment: createBuiltinVocabularyAlignment(),
     },
 });

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

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

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

@@ -25,10 +25,32 @@ export async function enrichSymbolCoordinatesWithTsMorph(entries, workspaceRoot)
         skipAddingFilesFromTsConfig: true,
     });
     const sourceFileCache = new Map();
-    const enriched = [];
+    // Add every source file before the first declaration lookup. Export checks
+    // consult the type checker, and adding a file discards the program, so
+    // interleaving adds with lookups rebuilt the whole program (and its module
+    // resolution) once per newly seen file. A declaration's own symbol does
+    // not depend on which other root files are present, so the coordinates are
+    // unchanged; only the repeated program construction disappears.
+    const resolvedPaths = [];
     for (const entry of entries) {
         try {
             const absolutePath = await resolveSourcePath(entry.sourceFile, workspaceRoot);
+            if (absolutePath) {
+                getOrAddSourceFile(project, sourceFileCache, absolutePath);
+            }
+            resolvedPaths.push({ ok: true, absolutePath });
+        }
+        catch (error) {
+            resolvedPaths.push({ ok: false, error });
+        }
+    }
+    const enriched = [];
+    for (const [index, entry] of entries.entries()) {
+        try {
+            const resolved = resolvedPaths[index];
+            if (resolved !== undefined && !resolved.ok)
+                throw resolved.error;
+            const absolutePath = resolved?.absolutePath ?? null;
             if (!absolutePath) {
                 enriched.push(entry);
                 continue;

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,CAsCvE;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

@@ -20,6 +20,34 @@ import { toSourceAnalysisProvider } from "kibi-plugin-sdk";
 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.
@@ -43,41 +71,175 @@ export function createBuiltinTsMorphSymbolExtractor() {
                 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.
@@ -86,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(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.
             }
         }
     }
@@ -164,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);
@@ -174,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()
@@ -182,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"
@@ -192,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,
@@ -218,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-plugin-builtin",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Default Kibi capability plugins: TS symbol extraction, ontology pack, and semantic classifier",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,7 +12,10 @@
     },
     "./package.json": "./package.json"
   },
-  "files": ["dist", "CHANGELOG.md"],
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -32,7 +35,7 @@
     "access": "public"
   },
   "dependencies": {
-    "kibi-plugin-sdk": "^0.3.0",
+    "kibi-plugin-sdk": "^0.4.0",
     "ts-morph": "^23.0.0"
   },
   "devDependencies": {