kibi-cli 2.0.0 → 2.1.0

package/dist/runtime/cli-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/cli-runtime.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAIV,gBAAgB,EAEhB,cAAc,EACf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,6BAA6B,CAAC;AAErC,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAOR;AA0ED,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,cAAmB,GAC3B,gBAAgB,CAgHlB"}
+{"version":3,"file":"cli-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/cli-runtime.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAKV,gBAAgB,EAEhB,cAAc,EACf,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,6BAA6B,CAAC;AAErC,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,qBAAqB,GAChC,MAAM,CAOR;AAkFD,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,cAAmB,GAC3B,gBAAgB,CAwHlB"}

package/dist/runtime/cli-runtime.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { retryAttachAfterBreakingStaleLock } from "../prolog/store-lock.js";
 import { EngineClient } from "../engine.js";
+import { CapabilityRegistryCache, ensureCapabilityRegistry, } from "../plugins/registry.js";
 import { nodeFilesystem, nodeGit, nodeNetwork, } from "../public/operations/node-ports.js";
 import { resolveBranchAttachment, } from "../utils/branch-resolver.js";
 export function attachmentFailureMessage(attachment) {
@@ -57,9 +58,18 @@ function enginePort(port, signal) {
         execute: (command, commandSignal) => execute.call(port, command, commandSignal ?? signal),
     };
 }
+function resolvePluginsOption(plugins) {
+    if (plugins === undefined)
+        return undefined;
+    if (typeof plugins === "function")
+        return plugins;
+    return async () => plugins;
+}
 // implements REQ-kibi-operation-interface-parity
 export function createCliRuntime(options = {}) {
     const ownedPrologs = new WeakMap();
+    // Per-runtime cache — not a process-global singleton.
+    const pluginCache = new CapabilityRegistryCache();
     return {
         open: async (spec, invocationOptions = {}) => {
             const merged = {
@@ -70,6 +80,12 @@ export function createCliRuntime(options = {}) {
             const signal = merged.signal ?? new AbortController().signal;
             const clock = merged.clock ?? (() => new Date());
             const git = merged.git ?? nodeGit;
+            const injectedPlugins = resolvePluginsOption(merged.plugins);
+            const ensurePlugins = async () => {
+                if (injectedPlugins)
+                    return injectedPlugins();
+                return ensureCapabilityRegistry(root, { cache: pluginCache });
+            };
             const contextBase = {
                 workspaceRoot: root,
                 signal,
@@ -77,6 +93,8 @@ export function createCliRuntime(options = {}) {
                 fs: merged.fs ?? nodeFilesystem,
                 git,
                 net: merged.net ?? nodeNetwork,
+                ensurePlugins,
+                ...(merged.plugins !== undefined ? { plugins: merged.plugins } : {}),
             };
             if (!spec.requiresProlog) {
                 // Read-only operations such as status may choose to use an explicitly

package/dist/traceability/symbol-extract.d.ts

@@ -1,6 +1,10 @@
-import { Scope } from "ts-morph";
+import type { SourceAnalysisResult as SdkSourceAnalysisResult } from "kibi-plugin-sdk";
+import { isPrivateClassMember } from "../extractors/symbols-ts.js";
 import { type SymbolKind, type SymbolRole } from "../public/symbol-granularity.js";
 import type { HunkRange, StagedFile } from "./git-staged.js";
+type SourceAnalysisResult = SdkSourceAnalysisResult & {
+    providerId?: string | null;
+};
 type TraceabilityRelationship = {
     type: string;
     to: string;
@@ -25,10 +29,23 @@ export interface ManifestLookupEntry {
 }
 export type ManifestLookup = Map<string, ManifestLookupEntry>;
 export declare function createManifestLookupSentinelKey(manifestPath: string): string;
-export declare function extractSymbolsFromStagedFile(stagedFile: StagedFile, manifestLookup?: ManifestLookup): ExtractedSymbol[];
-export declare function isPrivateClassMember(member: {
-    getName?: () => string;
-    getScope?: () => Scope;
-}): boolean;
-export {};
+export type ExtractSymbolsOptions = Readonly<{
+    /**
+     * Host-owned analysis. Prefer SourceAnalysisService / capability registry.
+     * When omitted, falls back to the builtin ts-morph provider for parity.
+     */
+    analyzeText?: (filePath: string, content: string) => SourceAnalysisResult | null | Promise<SourceAnalysisResult | null>;
+}>;
+export declare function extractSymbolsFromStagedFile(stagedFile: StagedFile, manifestLookup?: ManifestLookup, options?: ExtractSymbolsOptions): ExtractedSymbol[];
+/**
+ * Async staged symbol extraction. Defaults to deterministic builtin analysis.
+ * Pass an explicit `registry` only from allowlisted async surfaces that compose
+ * replace/augment/shadow (e.g. symbol repair). Maintenance paths (`check`,
+ * impact, sync, status, proof) must omit `registry` so external extractors
+ * never participate.
+ */
+export declare function extractSymbolsFromStagedFileAsync(stagedFile: StagedFile, manifestLookup: ManifestLookup | undefined, options: ExtractSymbolsOptions & Readonly<{
+    registry?: import("../plugins/registry.js").CapabilityRegistry;
+}>): Promise<ExtractedSymbol[]>;
+export { isPrivateClassMember };
 //# sourceMappingURL=symbol-extract.d.ts.map

package/dist/traceability/symbol-extract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,EAA+B,MAAM,UAAU,CAAC;AAEvE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AAmOD,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,eAAe,EAAE,CA2SnB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,KAAK,CAAC;CACxB,GAAG,OAAO,CASV"}
+{"version":3,"file":"symbol-extract.d.ts","sourceRoot":"","sources":["../../src/traceability/symbol-extract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,IAAI,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAEvF,OAAO,EAEL,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7D,KAAK,oBAAoB,GAAG,uBAAuB,GAAG;IACpD,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAU7D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,wBAAwB,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAE9D,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAG5E;AAyND,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C;;;OAGG;IACH,WAAW,CAAC,EAAE,CACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,KACZ,oBAAoB,GAAG,IAAI,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;CACzE,CAAC,CAAC;AAWH,wBAAgB,4BAA4B,CAE1C,UAAU,EAAE,UAAU,EACtB,cAAc,CAAC,EAAE,cAAc,EAC/B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,eAAe,EAAE,CAkCnB;AAED;;;;;;GAMG;AAEH,wBAAsB,iCAAiC,CACrD,UAAU,EAAE,UAAU,EACtB,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,OAAO,EAAE,qBAAqB,GAC5B,QAAQ,CAAC;IACP,QAAQ,CAAC,EAAE,OAAO,wBAAwB,EAAE,kBAAkB,CAAC;CAChE,CAAC,GACH,OAAO,CAAC,eAAe,EAAE,CAAC,CA8B5B;AAwCD,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/traceability/symbol-extract.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { Project, Scope, ScriptKind } from "ts-morph";
 import { readManifestWithCoordinateOverlay } from "../extractors/manifest.js";
+import { createTsMorphSourceAnalysisProvider, isPrivateClassMember, } from "../extractors/symbols-ts.js";
 import { inferSymbolRole, } from "../public/symbol-granularity.js";
 const TRACEABILITY_RELATIONSHIP_TYPES = new Set([
     "implements",
@@ -122,24 +122,13 @@ function buildSymbolResult(stagedFile, name, kind, span, inlineReqLinks, manifes
     };
 }
 // Simple in-memory cache keyed by blob sha with 30s TTL
-const sourceFileCache = new Map();
+const analysisCache = new Map();
 const CACHE_TTL_MS = 30 * 1000;
-const project = new Project({ skipAddingFilesFromTsConfig: true });
 function computeContentSha(content) {
     const h = createHash("sha256");
     h.update(content);
     return h.digest("hex");
 }
-function chooseScriptKind(path) {
-    const lower = path.toLowerCase();
-    if (lower.endsWith(".tsx"))
-        return ScriptKind.TSX;
-    if (lower.endsWith(".ts") || lower.endsWith(".mts") || lower.endsWith(".cts"))
-        return ScriptKind.TS;
-    if (lower.endsWith(".jsx"))
-        return ScriptKind.JSX;
-    return ScriptKind.JS;
-}
 function parseReqDirectives(text) {
     // look for lines containing implements REQ-123 or implements: REQ-1, REQ-2
     // Stop at end-of-line and only accept IDs starting with an uppercase letter
@@ -167,210 +156,92 @@ function parseReqDirectives(text) {
 function rangesIntersect(aStart, aEnd, bStart, bEnd) {
     return aStart <= bEnd && bStart <= aEnd;
 }
+function analyzeWithBuiltinFallback(filePath, content) {
+    const provider = createTsMorphSourceAnalysisProvider();
+    if (!provider.supportsFile(filePath))
+        return null;
+    return provider.analyzeText(filePath, content);
+}
 export function extractSymbolsFromStagedFile(
 // implements REQ-008
-stagedFile, manifestLookup) {
+stagedFile, manifestLookup, options) {
     const content = stagedFile.content ?? "";
-    const sha = computeContentSha(`${content}|${stagedFile.path}`);
+    const sha = computeContentSha(`${content}|${stagedFile.path}|${options?.analyzeText ? "custom" : "builtin"}`);
     // TTL cache lookup
     const now = Date.now();
-    let cached = sourceFileCache.get(sha);
+    let cached = analysisCache.get(sha);
     if (!cached || now - cached.ts > CACHE_TTL_MS) {
-        // create or recreate SourceFile in project (in-memory)
         try {
-            const scriptKind = chooseScriptKind(stagedFile.path);
-            const sf = project.createSourceFile(`${stagedFile.path}::staged`, content, {
-                overwrite: true,
-                scriptKind,
-            });
-            cached = { tsf: sf, ts: now };
-            sourceFileCache.set(sha, cached);
+            const analyze = options?.analyzeText ?? analyzeWithBuiltinFallback;
+            const raw = analyze(stagedFile.path, content);
+            if (raw instanceof Promise) {
+                throw new Error("extractSymbolsFromStagedFile received async analyzeText; use extractSymbolsFromStagedFileAsync");
+            }
+            cached = { result: raw, ts: now };
+            analysisCache.set(sha, cached);
         }
-        catch (err) {
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes("extractSymbolsFromStagedFileAsync")) {
+                throw error;
+            }
             // on parse error, cache null to avoid retry storms briefly
-            cached = { tsf: null, ts: now };
-            sourceFileCache.set(sha, cached);
-        }
-    }
-    const sf = cached.tsf;
-    if (!sf)
-        return [];
-    const results = [];
-    // helpers to compute line spans
-    const getSpan = (startPos, endPos) => {
-        const start = sf.getLineAndColumnAtPos(startPos);
-        const end = sf.getLineAndColumnAtPos(endPos);
-        return { startLine: start.line, endLine: end.line };
-    };
-    // Functions
-    for (const fn of sf.getFunctions()) {
-        if (!fn.isExported())
-            continue;
-        try {
-            const name = fn.getName() ?? "<anonymous>";
-            const nameNode = fn.getNameNode();
-            const start = nameNode ? nameNode.getStart() : fn.getStart();
-            const end = fn.getEnd();
-            const span = getSpan(start, end);
-            const reqLinks = parseReqDirectives(`${fn.getFullText()}\n${fn
-                .getJsDocs()
-                .map((d) => d.getFullText())
-                .join("\n")}`);
-            results.push(buildSymbolResult(stagedFile, name, "function", span, reqLinks, manifestLookup));
-        }
-        catch {
-            void stagedFile.path;
+            cached = { result: null, ts: now };
+            analysisCache.set(sha, cached);
         }
     }
-    // Classes
-    for (const cls of sf.getClasses()) {
-        if (!cls.isExported())
-            continue;
+    return symbolsFromAnalysis(stagedFile, cached.result, manifestLookup);
+}
+/**
+ * Async staged symbol extraction. Defaults to deterministic builtin analysis.
+ * Pass an explicit `registry` only from allowlisted async surfaces that compose
+ * replace/augment/shadow (e.g. symbol repair). Maintenance paths (`check`,
+ * impact, sync, status, proof) must omit `registry` so external extractors
+ * never participate.
+ */
+// implements REQ-capability-plugin-activation-disclosure-v1
+export async function extractSymbolsFromStagedFileAsync(stagedFile, manifestLookup, options) {
+    const content = stagedFile.content ?? "";
+    const sha = computeContentSha(`${content}|${stagedFile.path}|async|${options.registry ? "registry" : "custom"}`);
+    const now = Date.now();
+    let cached = analysisCache.get(sha);
+    if (!cached || now - cached.ts > CACHE_TTL_MS) {
         try {
-            const name = cls.getName() ?? "<anonymous>";
-            const start = cls.getNameNode()?.getStart() ?? cls.getStart();
-            const end = cls.getEnd();
-            const span = getSpan(start, end);
-            const reqLinks = parseReqDirectives(getJsDocText(cls.getJsDocs()));
-            results.push(buildSymbolResult(stagedFile, name, "class", span, reqLinks, manifestLookup));
-        }
-        catch {
-            void stagedFile.path;
-        }
-        for (const method of typeof cls.getMethods === "function"
-            ? cls.getMethods()
-            : []) {
-            try {
-                if (isPrivateClassMember(method))
-                    continue;
-                const name = formatMethodSymbolName(cls.getName(), method.getName());
-                const start = method.getNameNode()?.getStart() ?? method.getStart();
-                const end = method.getEnd();
-                const span = getSpan(start, end);
-                const reqLinks = parseReqDirectives(`${method.getFullText()}\n${method
-                    .getJsDocs()
-                    .map((d) => d.getFullText())
-                    .join("\n")}`);
-                results.push(buildSymbolResult(stagedFile, name, "method", span, reqLinks, manifestLookup));
-            }
-            catch {
-                void stagedFile.path;
-            }
-        }
-        for (const property of typeof cls.getProperties === "function"
-            ? cls.getProperties()
-            : []) {
-            try {
-                if (isPrivateClassMember(property))
-                    continue;
-                const name = formatMethodSymbolName(cls.getName(), property.getName());
-                const start = property.getNameNode()?.getStart() ?? property.getStart();
-                const end = property.getEnd();
-                const span = getSpan(start, end);
-                const reqLinks = parseReqDirectives(`${property.getFullText()}\n${property
-                    .getJsDocs()
-                    .map((d) => d.getFullText())
-                    .join("\n")}`);
-                results.push(buildSymbolResult(stagedFile, name, "property", span, reqLinks, manifestLookup));
-            }
-            catch {
-                void stagedFile.path;
+            let analysis = null;
+            if (options.analyzeText) {
+                analysis = await options.analyzeText(stagedFile.path, content);
             }
-        }
-        for (const accessor of [
-            ...(typeof cls.getGetAccessors === "function"
-                ? cls.getGetAccessors()
-                : []),
-            ...(typeof cls.getSetAccessors === "function"
-                ? cls.getSetAccessors()
-                : []),
-        ]) {
-            try {
-                if (isPrivateClassMember(accessor))
-                    continue;
-                const name = formatMethodSymbolName(cls.getName(), accessor.getName());
-                const start = accessor.getNameNode()?.getStart() ?? accessor.getStart();
-                const end = accessor.getEnd();
-                const span = getSpan(start, end);
-                const reqLinks = parseReqDirectives(`${accessor.getFullText()}\n${accessor
-                    .getJsDocs()
-                    .map((d) => d.getFullText())
-                    .join("\n")}`);
-                results.push(buildSymbolResult(stagedFile, name, "accessor", span, reqLinks, manifestLookup));
+            else if (options.registry) {
+                const { createSourceAnalysisService } = await import("../plugins/source-analysis-service.js");
+                analysis = await createSourceAnalysisService({
+                    registry: options.registry,
+                }).analyzeText(stagedFile.path, content);
             }
-            catch {
-                void stagedFile.path;
+            else {
+                analysis = analyzeWithBuiltinFallback(stagedFile.path, content);
             }
-        }
-    }
-    // Enums
-    for (const en of sf.getEnums()) {
-        if (!en.isExported())
-            continue;
-        try {
-            const name = en.getName() ?? "<anonymous>";
-            const start = en.getNameNode()?.getStart() ?? en.getStart();
-            const end = en.getEnd();
-            const span = getSpan(start, end);
-            const reqLinks = parseReqDirectives(en.getText());
-            results.push(buildSymbolResult(stagedFile, name, "enum", span, reqLinks, manifestLookup));
-        }
-        catch {
-            void stagedFile.path;
-        }
-    }
-    for (const iface of typeof sf.getInterfaces === "function"
-        ? sf.getInterfaces()
-        : []) {
-        if (!iface.isExported())
-            continue;
-        try {
-            const name = iface.getName();
-            const start = iface.getNameNode().getStart();
-            const end = iface.getEnd();
-            const span = getSpan(start, end);
-            const reqLinks = parseReqDirectives(iface.getText());
-            results.push(buildSymbolResult(stagedFile, name, "interface", span, reqLinks, manifestLookup));
+            cached = { result: analysis, ts: now };
+            analysisCache.set(sha, cached);
         }
         catch {
-            void stagedFile.path;
+            cached = { result: null, ts: now };
+            analysisCache.set(sha, cached);
         }
     }
-    for (const alias of typeof sf.getTypeAliases === "function"
-        ? sf.getTypeAliases()
-        : []) {
-        if (!alias.isExported())
-            continue;
+    return symbolsFromAnalysis(stagedFile, cached.result, manifestLookup);
+}
+function symbolsFromAnalysis(stagedFile, analysis, manifestLookup) {
+    if (!analysis)
+        return [];
+    const results = [];
+    for (const symbol of analysis.symbols) {
         try {
-            const name = alias.getName();
-            const start = alias.getNameNode().getStart();
-            const end = alias.getEnd();
-            const span = getSpan(start, end);
-            const reqLinks = parseReqDirectives(alias.getText());
-            results.push(buildSymbolResult(stagedFile, name, "type", span, reqLinks, manifestLookup));
+            results.push(buildSymbolResult(stagedFile, symbol.name, symbol.kind, { startLine: symbol.startLine, endLine: symbol.endLine }, parseReqDirectives(symbol.directiveText ?? ""), manifestLookup));
         }
         catch {
             void stagedFile.path;
         }
     }
-    // Variable statements (exported)
-    for (const vs of sf.getVariableStatements()) {
-        if (!vs.isExported())
-            continue;
-        for (const decl of vs.getDeclarations()) {
-            try {
-                const name = decl.getName();
-                const start = decl.getNameNode()?.getStart() ?? decl.getStart();
-                const end = decl.getEnd();
-                const span = getSpan(start, end);
-                const reqLinks = parseReqDirectives(decl.getText());
-                results.push(buildSymbolResult(stagedFile, name, "variable", span, reqLinks, manifestLookup));
-            }
-            catch {
-                void stagedFile.path;
-            }
-        }
-    }
     // Filter to only include symbols that intersect with at least one hunk
     // (unless it's a new file or rename, in which case we include all)
     const shouldFilterByHunks = stagedFile.status === "M" && stagedFile.hunkRanges.length > 0;
@@ -379,22 +250,7 @@ stagedFile, manifestLookup) {
     }
     return results;
 }
-export function isPrivateClassMember(member) {
-    const name = typeof member.getName === "function" ? member.getName() : "";
-    if (name.startsWith("#")) {
-        return true;
-    }
-    if (typeof member.getScope === "function") {
-        return member.getScope() === Scope.Private;
-    }
-    return false;
-}
-function formatMethodSymbolName(className, methodName) {
-    return className ? `${className}.${methodName}` : methodName;
-}
-function getJsDocText(jsDocs) {
-    return jsDocs.map((d) => d.getFullText()).join("\n");
-}
+export { isPrivateClassMember };
 function intersectingHunks(startLine, endLine, hunks) {
     const out = [];
     for (const h of hunks) {

package/dist/utils/rule-registry.generated.d.ts

@@ -93,5 +93,10 @@ export declare const GENERATED_RULES: readonly [{
     readonly description: "Every inventoried assertive proposition is modeled or explicitly classified";
     readonly enforcementClass: "migration";
     readonly category: "integrity";
+}, {
+    readonly name: "proof-contract-symbols";
+    readonly description: "Detect unresolved required_proofs.symbol_id values, type-shape required proofs, and proof_bindings.source_file disagreement with the named symbol sourceFile";
+    readonly enforcementClass: "advisory";
+    readonly category: "integrity";
 }];
 //# sourceMappingURL=rule-registry.generated.d.ts.map

package/dist/utils/rule-registry.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmIlB,CAAC"}
+{"version":3,"file":"rule-registry.generated.d.ts","sourceRoot":"","sources":["../../src/utils/rule-registry.generated.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0IlB,CAAC"}

package/dist/utils/rule-registry.generated.js

@@ -122,4 +122,10 @@ export const GENERATED_RULES = [
         enforcementClass: "migration",
         category: "integrity",
     },
+    {
+        name: "proof-contract-symbols",
+        description: "Detect unresolved required_proofs.symbol_id values, type-shape required proofs, and proof_bindings.source_file disagreement with the named symbol sourceFile",
+        enforcementClass: "advisory",
+        category: "integrity",
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -10,14 +10,7 @@
   "bin": {
     "kibi": "bin/kibi"
   },
-  "files": [
-    "dist",
-    "bin",
-    "schema",
-    "src/schemas",
-    "src/public",
-    "templates"
-  ],
+  "files": ["dist", "bin", "schema", "src/schemas", "src/public", "templates"],
   "scripts": {
     "build": "tsc -p tsconfig.json && rm -rf dist/public/skills && mkdir -p dist/public/skills dist/report && cp -r src/public/skills/. dist/public/skills/ && cp src/report/html-report.css dist/report/html-report.css && node ../../scripts/generate-entity-schema.mjs --check",
     "test": "node ../../scripts/run-owned-engine-tests.mjs -- bun test --timeout 15000 .",
@@ -55,6 +48,10 @@
       "types": "./dist/runtime/cli-runtime.d.ts",
       "default": "./dist/runtime/cli-runtime.js"
     },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "default": "./dist/plugins/index.js"
+    },
     "./operations/node-ports": {
       "types": "./dist/public/operations/node-ports.d.ts",
       "default": "./dist/public/operations/node-ports.js"
@@ -216,6 +213,10 @@
       "types": "./dist/public/ignore-policy.d.ts",
       "import": "./dist/public/ignore-policy.js",
       "default": "./dist/public/ignore-policy.js"
+    },
+    "./env-bootstrap": {
+      "types": "./dist/env/bootstrap.d.ts",
+      "default": "./dist/env/bootstrap.js"
     }
   },
   "types": "./dist/cli.d.ts",
@@ -226,15 +227,17 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.12.0",
+    "kibi-core": "^0.13.0",
+    "kibi-plugin-builtin": "^0.2.0",
+    "kibi-plugin-sdk": "^0.2.0",
     "saxes": "^6.0.0",
-    "ts-morph": "^23.0.0",
     "ignore": "^5.3.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@types/node": "latest",
     "semver": "^7.7.4",
+    "ts-morph": "^23.0.0",
     "typescript": "^5.7.0"
   },
   "license": "AGPL-3.0-or-later",

package/src/public/extractors/symbols-coordinator.ts

@@ -18,6 +18,7 @@
 
 export {
   analyzeSourceText,
+  analyzeSourceTextWithRegistry,
   enrichSymbolCoordinates,
   type ManifestSymbolEntry,
   type AnalyzeSourceTextOptions,

package/src/public/impact/analyzer.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ExtractedSymbol } from "../../traceability/symbol-extract.js";
-import { extractSymbolsFromStagedFile } from "../../traceability/symbol-extract.js";
+import { extractSymbolsFromStagedFileAsync } from "../../traceability/symbol-extract.js";
 import {
   createSemanticReviewDiagnostics,
   createSymbolGranularityDiagnostics,
@@ -21,9 +21,9 @@ import type {
   ChangedFileImpactResult,
 } from "./types.js";
 
-export function analyzeChangedFileImpact(
+export async function analyzeChangedFileImpact(
   options: ChangedFileImpactOptions,
-): ChangedFileImpactResult {
+): Promise<ChangedFileImpactResult> {
   const workspaceRoot = path.resolve(options.workspaceRoot);
   const sourceChanges = collectSourceChanges({ ...options, workspaceRoot });
   const sourceFiles = uniqueSorted(sourceChanges.map((change) => change.file));
@@ -34,17 +34,20 @@ export function analyzeChangedFileImpact(
 
   for (const change of sourceChanges) {
     sourceContentByFile.set(change.file, change.content);
+    // Maintenance path: builtin-only (do not pass registry / workspaceRoot).
+    const extracted = await extractSymbolsFromStagedFileAsync(
+      {
+        path: change.file,
+        status: change.status,
+        hunkRanges: [...change.hunkRanges],
+        content: change.content,
+      },
+      manifestLookup,
+      {},
+    );
     symbolsByFile.set(
       change.file,
-      extractSymbolsFromStagedFile(
-        {
-          path: change.file,
-          status: change.status,
-          hunkRanges: [...change.hunkRanges],
-          content: change.content,
-        },
-        manifestLookup,
-      ).filter((symbol) => symbol.hunkRanges.length > 0),
+      extracted.filter((symbol) => symbol.hunkRanges.length > 0),
     );
   }
 

package/src/public/operations/check-executor.ts

@@ -135,7 +135,7 @@ export async function executeCheck(
     // version. `args.rules` is an invocation-time diagnostic selector only.
     const rulesAllowlist = resolveCheckRules(args);
     const hasExplicitRules = args.rules !== undefined;
-    const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
+    const impactResult = await analyzeKbCheckImpact(workspaceRoot, args);
     const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
     const maxDiagnosticsOption =
       args.maxDiagnostics !== undefined

package/src/public/operations/check-helpers.ts

@@ -144,10 +144,10 @@ export function hasImpactOptions(args: CheckInput): boolean {
 }
 
 // implements REQ-mcp-tool-check
-export function analyzeKbCheckImpact(
+export async function analyzeKbCheckImpact(
   workspaceRoot: string,
   args: CheckInput,
-): ChangedFileImpactResult | undefined {
+): Promise<ChangedFileImpactResult | undefined> {
   if (!hasImpactOptions(args)) {
     return undefined;
   }