gitnexus 1.6.9-rc.20 → 1.6.9-rc.22

package/dist/core/group/extractors/http-patterns/java.js

@@ -1,7 +1,7 @@
 import Java from 'tree-sitter-java';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
-import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, } from '../../../ingestion/route-extractors/spring-shared.js';
-import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, joinPath, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
+import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, joinPath, } from '../../../ingestion/route-extractors/spring-shared.js';
+import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
 import { extractStaticPathExpression, inferOkHttpMethod, inferHttpClientMethod, okHttpUrlRootsAtBuilder, httpClientUriRootsAtNewBuilder, httpClientChainHasUriCall, } from './java-static-path.js';
 /**
  * Java HTTP plugin. Handles:
@@ -579,12 +579,13 @@ export const JAVA_HTTP_PLUGIN = {
     // ingestion does NOT emit a Route node for (1) a method-level array route
     // nested under a class-level array-form `@RequestMapping` (ingestion suppresses
     // it rather than drop the prefix; bare/scalar-prefixed array methods ARE now
-    // emitted — see #2280), (2) interface-inherited Spring routes, or (3) the 2nd
-    // verb of a same-URL GET+POST pair (Route nodes are URL-keyed). Declaring
-    // 'complete' here would let the parse-skip drop those group-only providers.
+    // emitted — see #2280), or (2) the 2nd verb of a same-URL GET+POST pair (Route
+    // nodes are URL-keyed). Interface-inherited Spring routes ARE now emitted by
+    // ingestion (#2288), so they are no longer a coverage gap. Declaring 'complete'
+    // here would let the parse-skip drop those remaining group-only providers.
     // Java flips to 'complete' only once ingestion provider extraction matches this
-    // scan (a follow-up: class-level array-form prefix support + interface-
-    // inheritance emission + per-verb Route identity — tracked in #2280).
+    // scan (a follow-up: class-level array-form prefix support + per-verb Route
+    // identity — tracked in #2280).
     // `hasConsumerSignals` below is kept ready for that flip.
     // Consumer signals this plugin's scan() can detect: RestTemplate / WebClient /
     // OkHttp / Java-HttpClient / Apache-HttpClient call sites, OpenFeign

package/dist/core/group/extractors/http-patterns/kotlin.js

@@ -1,7 +1,7 @@
 import { requireVendoredGrammar } from '../../../tree-sitter/vendored-grammars.js';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
-import { METHOD_ANNOTATION_TO_HTTP, findEnclosingClass, } from '../../../ingestion/route-extractors/spring-shared.js';
-import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, joinPath, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
+import { METHOD_ANNOTATION_TO_HTTP, findEnclosingClass, joinPath, } from '../../../ingestion/route-extractors/spring-shared.js';
+import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
 /**
  * Kotlin HTTP plugin (Spring providers + consumers).
  *

package/dist/core/group/extractors/http-patterns/spring-consumer-shared.d.ts

@@ -15,6 +15,7 @@
  * the group layer beside the plugins that use it.
  */
 import type { HttpFileDetections } from './types.js';
+import { type SharedSpringType } from '../../../ingestion/route-extractors/spring-shared.js';
 /**
  * RestTemplate method-name → HTTP verb. Source-scan only: the receiver must be
  * named exactly `restTemplate` (the per-language query enforces that).
@@ -84,54 +85,13 @@ export declare function parseRequestLine(raw: string): {
     path: string;
 } | null;
 /**
- * Join a class/interface-level prefix and a method-level path into a single
- * URL path: strip leading/trailing slashes on the prefix and leading slashes
- * on the method path, then ensure exactly one slash between them.
- */
-export declare function joinPath(prefix: string, methodPath: string): string;
-/**
- * Join a controller's own class prefix with a route inherited from an interface
- * (interface-based controllers, #1743). The inherited path already has the
- * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
- * controller repeats that same prefix we must NOT prepend it twice (#2057).
- * Shared by both plugins' `scanProject` so Java and Kotlin agree.
- */
-export declare function joinInheritedSpringPath(controllerPrefix: string, inheritedPath: string, inheritedOwnerPrefix?: string): string;
-/**
- * Language-agnostic view of a Spring class/interface that each plugin's
- * grammar-specific collector produces. The interface-based-controller
- * inheritance algorithm (`scanSpringInheritanceProject`) operates only on this
- * shape, so the Java and Kotlin plugins share one algorithm and cannot drift.
- *
- * `methods[].routes` carry only `{ method, path }` — the interface's own class
- * prefix is applied *inside* `scanSpringInheritanceProject` (it is not part of
- * the collector's output).
- */
-export interface SharedSpringType {
-    filePath: string;
-    kind: 'class' | 'interface';
-    name: string;
-    /** Class-level `@RequestMapping` prefixes — one per array element. */
-    classPrefixes: string[];
-    implementedInterfaces: string[];
-    isController: boolean;
-    methods: Array<{
-        name: string;
-        routes: Array<{
-            method: string;
-            path: string;
-        }>;
-    }>;
-}
-/**
- * Resolve interface-based-controller provider routes (#1743): a concrete
+ * Resolve interface-based-controller provider *detections* (#1743): a concrete
  * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
- * declared on the interface it implements. Shared by the Java and Kotlin plugins
- * so both emit byte-identical provider contracts.
- *
- * An interface name that resolves to two distinct interfaces is ambiguous and
- * its routes are dropped (the `null` marker). The controller's own class
- * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
- * avoids doubling a prefix the interface already baked in (#2057).
+ * declared on the interface it implements. Thin group-layer adapter over the
+ * shared, language-agnostic `resolveInheritedSpringRoutes` (in
+ * `ingestion/route-extractors/spring-shared.ts`) — it maps each inherited route
+ * to a provider `HttpDetection`. Shared by the Java and Kotlin plugins so both
+ * emit byte-identical provider contracts; the ingestion route extractor calls
+ * the same underlying algorithm so all three stay in parity.
  */
 export declare function scanSpringInheritanceProject(types: SharedSpringType[]): HttpFileDetections[];

package/dist/core/group/extractors/http-patterns/spring-consumer-shared.js

@@ -14,6 +14,7 @@
  * route extractor). This module is the consumer-side counterpart and lives in
  * the group layer beside the plugins that use it.
  */
+import { resolveInheritedSpringRoutes, } from '../../../ingestion/route-extractors/spring-shared.js';
 /**
  * RestTemplate method-name → HTTP verb. Source-scan only: the receiver must be
  * named exactly `restTemplate` (the per-language query enforces that).
@@ -117,111 +118,28 @@ export function parseRequestLine(raw) {
     return { method: verb.toUpperCase(), path: pathOnly };
 }
 /**
- * Join a class/interface-level prefix and a method-level path into a single
- * URL path: strip leading/trailing slashes on the prefix and leading slashes
- * on the method path, then ensure exactly one slash between them.
- */
-export function joinPath(prefix, methodPath) {
-    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanSub = methodPath.replace(/^\/+/, '');
-    if (!cleanPrefix)
-        return `/${cleanSub}`;
-    return `/${cleanPrefix}/${cleanSub}`;
-}
-/**
- * Join a controller's own class prefix with a route inherited from an interface
- * (interface-based controllers, #1743). The inherited path already has the
- * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
- * controller repeats that same prefix we must NOT prepend it twice (#2057).
- * Shared by both plugins' `scanProject` so Java and Kotlin agree.
- */
-export function joinInheritedSpringPath(controllerPrefix, inheritedPath, inheritedOwnerPrefix = '') {
-    const joined = joinPath(controllerPrefix, inheritedPath);
-    const cleanPrefix = controllerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanOwnerPrefix = inheritedOwnerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
-    const cleanInherited = inheritedPath.replace(/^\/+/, '');
-    if (!cleanPrefix)
-        return joined;
-    if (cleanPrefix === cleanOwnerPrefix &&
-        (cleanInherited === cleanPrefix || cleanInherited.startsWith(`${cleanPrefix}/`))) {
-        return `/${cleanInherited}`;
-    }
-    return joined;
-}
-/**
- * Resolve interface-based-controller provider routes (#1743): a concrete
+ * Resolve interface-based-controller provider *detections* (#1743): a concrete
  * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
- * declared on the interface it implements. Shared by the Java and Kotlin plugins
- * so both emit byte-identical provider contracts.
- *
- * An interface name that resolves to two distinct interfaces is ambiguous and
- * its routes are dropped (the `null` marker). The controller's own class
- * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
- * avoids doubling a prefix the interface already baked in (#2057).
+ * declared on the interface it implements. Thin group-layer adapter over the
+ * shared, language-agnostic `resolveInheritedSpringRoutes` (in
+ * `ingestion/route-extractors/spring-shared.ts`) — it maps each inherited route
+ * to a provider `HttpDetection`. Shared by the Java and Kotlin plugins so both
+ * emit byte-identical provider contracts; the ingestion route extractor calls
+ * the same underlying algorithm so all three stay in parity.
  */
 export function scanSpringInheritanceProject(types) {
-    const interfaceRoutes = new Map();
-    for (const type of types) {
-        if (type.kind !== 'interface')
-            continue;
-        if (interfaceRoutes.has(type.name)) {
-            interfaceRoutes.set(type.name, null);
-            continue;
-        }
-        const prefixes = type.classPrefixes.length ? type.classPrefixes : [''];
-        const methodMap = new Map();
-        for (const method of type.methods) {
-            // Cross-product the interface's class prefixes with each method route, so a
-            // multi-element `@RequestMapping(["/a","/b"])` interface yields N bindings.
-            const routes = method.routes.flatMap((route) => prefixes.map((prefix) => ({
-                method: route.method,
-                path: prefix ? joinPath(prefix, route.path) : route.path,
-                ownerPrefix: prefix,
-            })));
-            if (routes.length > 0)
-                methodMap.set(method.name, routes);
-        }
-        interfaceRoutes.set(type.name, methodMap);
-    }
     const detectionsByFile = new Map();
-    for (const type of types) {
-        if (type.kind !== 'class' || !type.isController)
-            continue;
-        // Cross-product the controller's own class prefixes with each inherited
-        // route; `['']` keeps the common no-prefix controller emitting the
-        // interface path unchanged.
-        const controllerPrefixes = type.classPrefixes.length ? type.classPrefixes : [''];
-        for (const method of type.methods) {
-            if (method.routes.length > 0)
-                continue; // own @*Mapping → already a provider via scan()
-            const inherited = type.implementedInterfaces.flatMap((iface) => {
-                const routeMap = interfaceRoutes.get(iface);
-                if (!routeMap)
-                    return [];
-                const routes = routeMap.get(method.name) ?? [];
-                return routes.flatMap((route) => controllerPrefixes.map((controllerPrefix) => ({
-                    method: route.method,
-                    path: joinInheritedSpringPath(controllerPrefix, route.path, route.ownerPrefix),
-                })));
-            });
-            const seen = new Set();
-            for (const route of inherited) {
-                const key = `${route.method} ${route.path}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const detections = detectionsByFile.get(type.filePath) ?? [];
-                detections.push({
-                    role: 'provider',
-                    framework: 'spring',
-                    method: route.method,
-                    path: route.path,
-                    name: method.name,
-                    confidence: 0.8,
-                });
-                detectionsByFile.set(type.filePath, detections);
-            }
-        }
+    for (const route of resolveInheritedSpringRoutes(types)) {
+        const detections = detectionsByFile.get(route.filePath) ?? [];
+        detections.push({
+            role: 'provider',
+            framework: 'spring',
+            method: route.method,
+            path: route.path,
+            name: route.methodName,
+            confidence: 0.8,
+        });
+        detectionsByFile.set(route.filePath, detections);
     }
     return [...detectionsByFile.entries()].map(([filePath, detections]) => ({
         filePath,

package/dist/core/ingestion/language-provider.d.ts

@@ -22,6 +22,7 @@ import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { CfgVisitor } from './cfg/types.js';
 import type { NodeLabel } from '../../_shared/index.js';
 import type { ExtractedRoute } from './route-extractors/laravel.js';
+import type { SharedSpringType } from './route-extractors/spring-shared.js';
 import type Parser from 'tree-sitter';
 import type { ExtractedDecoratorRoute } from './workers/parse-worker.js';
 /** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
@@ -226,6 +227,19 @@ interface LanguageProviderConfig {
      * Default: undefined (no language-specific decorator route extraction).
      */
     readonly extractDecoratorRoutes?: (tree: Parser.Tree, filePath: string, lineOffset: number) => ExtractedDecoratorRoute[];
+    /**
+     * Collect a project-wide, language-agnostic view of route-defining
+     * class/interface declarations (`SharedSpringType`) from a parsed file.
+     *
+     * When defined, the parse worker calls this per file and the parse phase
+     * aggregates the results, then runs a cross-file pass that resolves
+     * interface-inherited routes (a concrete controller inherits the `@*Mapping`s
+     * its interfaces declare) and appends them to `decoratorRoutes`. Separate from
+     * `extractDecoratorRoutes` because inheritance needs all files, not one.
+     *
+     * Default: undefined (no interface-inheritance route resolution).
+     */
+    readonly extractRouteInheritanceTypes?: (tree: Parser.Tree, filePath: string) => SharedSpringType[];
     /** Built-in/stdlib names that should be filtered from the call graph for this language.
      *  Default: undefined (no language-specific filtering). */
     readonly builtInNames?: ReadonlySet<string>;

package/dist/core/ingestion/languages/java.js

@@ -12,7 +12,7 @@ import { javaClassConfig } from '../class-extractors/configs/jvm.js';
 import { defineLanguage } from '../language-provider.js';
 import { createLeadingDocDescriptionExtractor } from '../utils/ast-helpers.js';
 import { javaTypeConfig } from '../type-extractors/jvm.js';
-import { extractSpringRoutes } from '../route-extractors/spring.js';
+import { extractSpringRoutes, extractSpringTypes } from '../route-extractors/spring.js';
 import { javaExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { javaImportConfig } from '../import-resolvers/configs/jvm.js';
@@ -112,4 +112,5 @@ export const javaProvider = defineLanguage({
     orderSameNameTypeCandidates: orderJavaSameNameTypeCandidates,
     // ── Route extraction ──
     extractDecoratorRoutes: extractSpringRoutes,
+    extractRouteInheritanceTypes: extractSpringTypes,
 });

package/dist/core/ingestion/parsing-processor.d.ts

@@ -5,6 +5,7 @@ import type { ParsedFile } from '../../_shared/index.js';
 import { WorkerPool } from './workers/worker-pool.js';
 import type { ParseWorkerResult, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
 import type { ExtractedRouterImport, ExtractedRouterInclude, ExtractedRouterModuleAlias } from './route-extractors/fastapi-router-bindings.js';
+import type { SharedSpringType } from './route-extractors/spring-shared.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     routes: ExtractedRoute[];
@@ -16,6 +17,8 @@ export interface WorkerExtractedData {
     routerModuleAliases: ExtractedRouterModuleAlias[];
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];
+    /** Project-wide Spring class/interface views for the #2288 inheritance pass. */
+    springTypes: SharedSpringType[];
     fileScopeBindings: FileScopeBindings[];
     /**
      * Per-file `ParsedFile` artifacts from the new scope-based resolution

package/dist/core/ingestion/parsing-processor.js

@@ -23,6 +23,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
     const allRouterIncludes = [];
     const allRouterImports = [];
     const allRouterModuleAliases = [];
+    const allSpringTypes = [];
     const allToolDefs = [];
     const allORMQueries = [];
     const fileScopeBindingsByFile = [];
@@ -71,6 +72,8 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
             allRouterImports.push(item);
         for (const item of result.routerModuleAliases ?? [])
             allRouterModuleAliases.push(item);
+        for (const item of result.springTypes ?? [])
+            allSpringTypes.push(item);
         for (const item of result.toolDefs)
             allToolDefs.push(item);
         if (result.ormQueries)
@@ -93,6 +96,7 @@ export const mergeChunkResults = (graph, symbolTable, chunkResults, exportedType
         routerModuleAliases: allRouterModuleAliases,
         toolDefs: allToolDefs,
         ormQueries: allORMQueries,
+        springTypes: allSpringTypes,
         fileScopeBindings: fileScopeBindingsByFile,
         parsedFiles: allParsedFiles,
     };

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -27,6 +27,7 @@ import { isLanguageAvailable, isGrammarRuntimeSkipped, createParserForLanguage,
 import { parseSourceSafe } from '../../tree-sitter/safe-parse.js';
 import { getProvider, providers } from '../languages/index.js';
 import { createWorkerPool, workerPoolDisabledByEnv, resolveAutoPoolSize, WorkerPoolInitializationError, WorkerPoolDisabledError, } from '../workers/worker-pool.js';
+import { resolveInheritedSpringRoutes, } from '../route-extractors/spring-shared.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -461,6 +462,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
     const allRouterIncludes = [];
     const allRouterImports = [];
     const allRouterModuleAliases = [];
+    const allSpringTypes = [];
     const allToolDefs = [];
     const allORMQueries = [];
     // Aggregated per-file ParsedFile artifacts produced by workers' calls
@@ -601,6 +603,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     for (const item of chunkWorkerData.routerModuleAliases)
                         allRouterModuleAliases.push(item);
                 }
+                if (chunkWorkerData.springTypes?.length) {
+                    for (const item of chunkWorkerData.springTypes)
+                        allSpringTypes.push(item);
+                }
                 if (chunkWorkerData.toolDefs?.length) {
                     for (const item of chunkWorkerData.toolDefs)
                         allToolDefs.push(item);
@@ -1047,6 +1053,25 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 allDecoratorRoutes.push(dr);
         }
     }
+    // Cross-file Spring interface-inheritance pass (#2288): a concrete
+    // `@RestController` inherits the `@*Mapping`s declared on the interfaces it
+    // implements. The per-file `SharedSpringType` views collected by the Java
+    // provider's `extractRouteInheritanceTypes` hook are resolved here, project-
+    // wide, into decorator routes attributed to the implementing controller (the
+    // interface's own per-file routes were suppressed at extraction). Mirrors the
+    // group layer via the shared `resolveInheritedSpringRoutes` so both agree.
+    if (allSpringTypes.length > 0) {
+        for (const inherited of resolveInheritedSpringRoutes(allSpringTypes)) {
+            allDecoratorRoutes.push({
+                filePath: inherited.filePath,
+                routePath: inherited.path,
+                httpMethod: inherited.method,
+                decoratorName: 'inherited-mapping',
+                lineNumber: 0,
+                handlerName: inherited.methodName,
+            });
+        }
+    }
     logHeapProbe('parse-impl-return', `exportedTypeMap=${exportedTypeMap.size} parsedFiles=${allParsedFiles.length} nodes=${graph.nodeCount}`);
     // Part 2 (#2138): resolve each route's handler to a real symbol UID now that
     // the model is fully populated and decorator-route prefixes are finalized.

package/dist/core/ingestion/route-extractors/spring-shared.d.ts

@@ -38,6 +38,16 @@ export declare function isRouteMemberKey(keyNode: Parser.SyntaxNode | undefined)
  * at a time.
  */
 export declare function findEnclosingClass(node: Parser.SyntaxNode): Parser.SyntaxNode | null;
+/**
+ * Find the nearest enclosing Java type declaration (class OR interface) for a
+ * node, reporting its kind. Used by the ingestion route extractor to tell an
+ * interface-declared `@*Mapping` (handled by the cross-file inheritance pass,
+ * #2288) apart from a concrete class route, and by the type collector.
+ */
+export declare function findEnclosingType(node: Parser.SyntaxNode): {
+    node: Parser.SyntaxNode;
+    kind: 'class' | 'interface';
+} | null;
 /**
  * Strip enclosing quotes from a tree-sitter string-literal node's text.
  * Handles single / double / template (backtick) quotes and triple-quoted
@@ -48,3 +58,71 @@ export declare function findEnclosingClass(node: Parser.SyntaxNode): Parser.Synt
  * content without quotes already).
  */
 export declare function unquoteSpringLiteral(raw: string): string | null;
+/**
+ * Join a class/interface-level prefix and a method-level path into a single
+ * URL path: strip leading/trailing slashes on the prefix and leading slashes
+ * on the method path, then ensure exactly one slash between them.
+ *
+ * Lives here (the lower shared layer) so the ingestion route extractor and the
+ * group-layer Spring/Kotlin plugins join prefixes identically; the group
+ * `spring-consumer-shared.ts` re-exports it for its existing importers.
+ */
+export declare function joinPath(prefix: string, methodPath: string): string;
+/**
+ * Join a controller's own class prefix with a route inherited from an interface
+ * (interface-based controllers, #1743). The inherited path already has the
+ * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
+ * controller repeats that same prefix we must NOT prepend it twice (#2057).
+ */
+export declare function joinInheritedSpringPath(controllerPrefix: string, inheritedPath: string, inheritedOwnerPrefix?: string): string;
+/**
+ * Language-agnostic view of a Spring class/interface that each extractor's
+ * grammar-specific collector produces. The interface-based-controller
+ * inheritance algorithm (`resolveInheritedSpringRoutes`) operates only on this
+ * shape, so the ingestion route extractor and the group Java/Kotlin plugins
+ * share one algorithm and cannot drift.
+ *
+ * `methods[].routes` carry only `{ method, path }` — the interface's own class
+ * prefix is applied *inside* `resolveInheritedSpringRoutes` (it is not part of
+ * the collector's output).
+ */
+export interface SharedSpringType {
+    filePath: string;
+    kind: 'class' | 'interface';
+    name: string;
+    /** Class-level `@RequestMapping` prefixes — one per array element. */
+    classPrefixes: string[];
+    implementedInterfaces: string[];
+    isController: boolean;
+    methods: Array<{
+        name: string;
+        routes: Array<{
+            method: string;
+            path: string;
+        }>;
+    }>;
+}
+/** One provider route a concrete controller inherits from an interface. */
+interface InheritedSpringRoute {
+    /** File of the implementing controller (where the route should be attributed). */
+    filePath: string;
+    /** Name of the controller method that inherits the route. */
+    methodName: string;
+    method: string;
+    path: string;
+}
+/**
+ * Resolve interface-based-controller provider routes (#1743): a concrete
+ * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
+ * declared on the interface it implements. Pure and language-agnostic — shared
+ * by the ingestion route extractor and the group Java/Kotlin plugins so all
+ * three emit the same inherited routes.
+ *
+ * An interface name that resolves to two distinct interfaces is ambiguous and
+ * its routes are dropped (the `null` marker). The controller's own class
+ * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
+ * avoids doubling a prefix the interface already baked in (#2057). Duplicate
+ * `(method, path)` results per controller method are de-duped.
+ */
+export declare function resolveInheritedSpringRoutes(types: SharedSpringType[]): InheritedSpringRoute[];
+export {};

package/dist/core/ingestion/route-extractors/spring-shared.js

@@ -55,6 +55,23 @@ export function findEnclosingClass(node) {
     }
     return null;
 }
+/**
+ * Find the nearest enclosing Java type declaration (class OR interface) for a
+ * node, reporting its kind. Used by the ingestion route extractor to tell an
+ * interface-declared `@*Mapping` (handled by the cross-file inheritance pass,
+ * #2288) apart from a concrete class route, and by the type collector.
+ */
+export function findEnclosingType(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return { node: cur, kind: 'class' };
+        if (cur.type === 'interface_declaration')
+            return { node: cur, kind: 'interface' };
+        cur = cur.parent;
+    }
+    return null;
+}
 /**
  * Strip enclosing quotes from a tree-sitter string-literal node's text.
  * Handles single / double / template (backtick) quotes and triple-quoted
@@ -78,3 +95,115 @@ export function unquoteSpringLiteral(raw) {
     }
     return raw;
 }
+/**
+ * Join a class/interface-level prefix and a method-level path into a single
+ * URL path: strip leading/trailing slashes on the prefix and leading slashes
+ * on the method path, then ensure exactly one slash between them.
+ *
+ * Lives here (the lower shared layer) so the ingestion route extractor and the
+ * group-layer Spring/Kotlin plugins join prefixes identically; the group
+ * `spring-consumer-shared.ts` re-exports it for its existing importers.
+ */
+export function joinPath(prefix, methodPath) {
+    const cleanPrefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanSub = methodPath.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return `/${cleanSub}`;
+    return `/${cleanPrefix}/${cleanSub}`;
+}
+/**
+ * Join a controller's own class prefix with a route inherited from an interface
+ * (interface-based controllers, #1743). The inherited path already has the
+ * interface's own class prefix (`inheritedOwnerPrefix`) baked in; when the
+ * controller repeats that same prefix we must NOT prepend it twice (#2057).
+ */
+export function joinInheritedSpringPath(controllerPrefix, inheritedPath, inheritedOwnerPrefix = '') {
+    const joined = joinPath(controllerPrefix, inheritedPath);
+    const cleanPrefix = controllerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanOwnerPrefix = inheritedOwnerPrefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    const cleanInherited = inheritedPath.replace(/^\/+/, '');
+    if (!cleanPrefix)
+        return joined;
+    if (cleanPrefix === cleanOwnerPrefix &&
+        (cleanInherited === cleanPrefix || cleanInherited.startsWith(`${cleanPrefix}/`))) {
+        return `/${cleanInherited}`;
+    }
+    return joined;
+}
+/**
+ * Resolve interface-based-controller provider routes (#1743): a concrete
+ * `@RestController`/`@Controller` class inherits the `@(Get|...)Mapping` routes
+ * declared on the interface it implements. Pure and language-agnostic — shared
+ * by the ingestion route extractor and the group Java/Kotlin plugins so all
+ * three emit the same inherited routes.
+ *
+ * An interface name that resolves to two distinct interfaces is ambiguous and
+ * its routes are dropped (the `null` marker). The controller's own class
+ * prefix(es) cross-product the inherited routes; `joinInheritedSpringPath`
+ * avoids doubling a prefix the interface already baked in (#2057). Duplicate
+ * `(method, path)` results per controller method are de-duped.
+ */
+export function resolveInheritedSpringRoutes(types) {
+    // interface name → (method name → routes). `null` marks an ambiguous
+    // (duplicated) interface name. `IntermediateRoute` is declared at module scope.
+    const interfaceRoutes = new Map();
+    for (const type of types) {
+        if (type.kind !== 'interface')
+            continue;
+        if (interfaceRoutes.has(type.name)) {
+            interfaceRoutes.set(type.name, null);
+            continue;
+        }
+        const prefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        const methodMap = new Map();
+        for (const method of type.methods) {
+            // Cross-product the interface's class prefixes with each method route, so a
+            // multi-element `@RequestMapping(["/a","/b"])` interface yields N bindings.
+            const routes = method.routes.flatMap((route) => prefixes.map((prefix) => ({
+                method: route.method,
+                path: prefix ? joinPath(prefix, route.path) : route.path,
+                ownerPrefix: prefix,
+            })));
+            if (routes.length > 0)
+                methodMap.set(method.name, routes);
+        }
+        interfaceRoutes.set(type.name, methodMap);
+    }
+    const out = [];
+    for (const type of types) {
+        if (type.kind !== 'class' || !type.isController)
+            continue;
+        // Cross-product the controller's own class prefixes with each inherited
+        // route; `['']` keeps the common no-prefix controller emitting the
+        // interface path unchanged.
+        const controllerPrefixes = type.classPrefixes.length ? type.classPrefixes : [''];
+        for (const method of type.methods) {
+            if (method.routes.length > 0)
+                continue; // own @*Mapping → already a provider
+            const inherited = type.implementedInterfaces.flatMap((iface) => {
+                const routeMap = interfaceRoutes.get(iface);
+                if (!routeMap)
+                    return [];
+                const routes = routeMap.get(method.name) ?? [];
+                return routes.flatMap((route) => controllerPrefixes.map((controllerPrefix) => ({
+                    method: route.method,
+                    path: joinInheritedSpringPath(controllerPrefix, route.path, route.ownerPrefix),
+                })));
+            });
+            const seen = new Set();
+            for (const route of inherited) {
+                const key = `${route.method} ${route.path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({
+                    filePath: type.filePath,
+                    methodName: method.name,
+                    method: route.method,
+                    path: route.path,
+                });
+            }
+        }
+    }
+    return out;
+}

package/dist/core/ingestion/route-extractors/spring.d.ts

@@ -20,6 +20,7 @@
  */
 import Parser from 'tree-sitter';
 import type { ExtractedDecoratorRoute } from '../workers/parse-worker.js';
+import { type SharedSpringType } from './spring-shared.js';
 /**
  * Extract Spring route annotations from a parsed Java file.
  *
@@ -33,3 +34,15 @@ import type { ExtractedDecoratorRoute } from '../workers/parse-worker.js';
  * @returns Decorator routes with prefix already set per-class
  */
 export declare function extractSpringRoutes(tree: Parser.Tree, filePath: string, lineOffset?: number): ExtractedDecoratorRoute[];
+/**
+ * Build the project-wide `SharedSpringType` view for one Java file: every class
+ * and interface with its class prefixes, implemented interfaces, controller
+ * flag, and per-method route annotations. The cross-file inheritance pass
+ * (#2288) feeds these into the shared `resolveInheritedSpringRoutes` so a
+ * concrete controller inherits the `@*Mapping`s declared on its interfaces.
+ *
+ * This is the ingestion counterpart of the group layer's `collectSpringTypes`
+ * (`group/extractors/http-patterns/java.ts`); both produce the same neutral
+ * shape so the two layers resolve inheritance identically (#2078 parity).
+ */
+export declare function extractSpringTypes(tree: Parser.Tree, filePath: string): SharedSpringType[];

package/dist/core/ingestion/route-extractors/spring.js

@@ -20,7 +20,7 @@
  */
 import Parser from 'tree-sitter';
 import Java from 'tree-sitter-java';
-import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, unquoteSpringLiteral, } from './spring-shared.js';
+import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingType, unquoteSpringLiteral, } from './spring-shared.js';
 /**
  * Single predicate-free tree-sitter query that captures all route annotations
  * on classes and methods. Discrimination by annotation name and node type
@@ -150,7 +150,15 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         const routePath = unquoteSpringLiteral(valueNode.text);
         if (routePath === null)
             continue;
-        const enclosingClass = findEnclosingClass(node);
+        const enclosingType = findEnclosingType(node);
+        // Interface-declared `@*Mapping`s are not concrete routes on their own — the
+        // implementing controller inherits them. Skip here; the cross-file
+        // inheritance pass (#2288) re-emits them attributed to the controller, with
+        // both the interface's and the controller's class prefixes resolved. Emitting
+        // the interface route directly would be wrong (unprefixed, wrong owner).
+        if (enclosingType?.kind === 'interface')
+            continue;
+        const enclosingClass = enclosingType?.kind === 'class' ? enclosingType.node : null;
         // Suppress a method-level *array-form* route nested under a class-level
         // array-form @RequestMapping. The class prefix is one of several values that
         // cannot be resolved to a single string here, so emitting the route would
@@ -179,3 +187,163 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
     }
     return routes;
 }
+/**
+ * Tree-sitter query capturing every Java type declaration (class + interface),
+ * used by `extractSpringTypes` to build the project-wide `SharedSpringType`
+ * view the cross-file interface-inheritance pass consumes (#2288).
+ */
+const TYPE_DECLARATION_QUERY = new Parser.Query(Java, `[(class_declaration) @type (interface_declaration) @type]`);
+/** Direct annotations on a type/method declaration (reads its `modifiers` child). */
+function declarationAnnotations(node) {
+    // `modifiers` is a NAMED CHILD of the declaration (not a named field) in
+    // tree-sitter-java — matching the group layer's `hasAnnotation`.
+    const modifiers = node.namedChildren.find((c) => c.type === 'modifiers');
+    if (!modifiers)
+        return [];
+    return modifiers.namedChildren.filter((c) => c.type === 'annotation' || c.type === 'marker_annotation');
+}
+const annotationName = (ann) => {
+    // Trailing segment of a possibly fully-qualified annotation name
+    // (`org.springframework.web.bind.annotation.GetMapping` → `GetMapping`), so a
+    // FQN annotation is classified the same as its simple form — matching the
+    // group layer's `simpleName` normalization. A simple name maps to itself.
+    const text = ann.childForFieldName('name')?.text;
+    return text?.split('.').pop() ?? text;
+};
+/**
+ * Collect the route path(s) carried by an annotation's argument list, honoring
+ * both positional and `path =`/`value =` named arguments and both the bare
+ * string and array forms. Non-route named args (`consumes`, `produces`, …) are
+ * dropped via `isRouteMemberKey`. Returns one entry per string element.
+ */
+function annotationRoutePaths(ann) {
+    const args = ann.childForFieldName('arguments');
+    if (!args)
+        return [];
+    const out = [];
+    const pushLiteral = (lit) => {
+        const v = unquoteSpringLiteral(lit.text);
+        if (v !== null)
+            out.push(v);
+    };
+    const pushFromValue = (valueNode) => {
+        if (valueNode.type === 'string_literal')
+            pushLiteral(valueNode);
+        else if (valueNode.type === 'element_value_array_initializer') {
+            for (const el of valueNode.namedChildren)
+                if (el.type === 'string_literal')
+                    pushLiteral(el);
+        }
+    };
+    for (const child of args.namedChildren) {
+        if (child.type === 'string_literal' || child.type === 'element_value_array_initializer') {
+            pushFromValue(child); // positional
+        }
+        else if (child.type === 'element_value_pair') {
+            const key = child.childForFieldName('key');
+            if (!isRouteMemberKey(key ?? undefined))
+                continue;
+            const value = child.childForFieldName('value');
+            if (value)
+                pushFromValue(value);
+        }
+    }
+    return out;
+}
+/** Class-level `@RequestMapping` prefixes for a type (array-aware; may be []). */
+function typeClassPrefixes(typeNode) {
+    const prefixes = [];
+    for (const ann of declarationAnnotations(typeNode)) {
+        if (annotationName(ann) === 'RequestMapping')
+            prefixes.push(...annotationRoutePaths(ann));
+    }
+    return prefixes;
+}
+/** The simple names of the interfaces a class declares via `implements`. */
+function implementedInterfaceNames(typeNode) {
+    const interfacesNode = typeNode.childForFieldName('interfaces');
+    if (!interfacesNode)
+        return [];
+    const out = [];
+    const visit = (node) => {
+        if (node.type === 'type_identifier' || node.type === 'scoped_type_identifier') {
+            out.push(node.text.split('.').pop() ?? node.text);
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(interfacesNode);
+    return out;
+}
+/** Direct `method_declaration` children of a type (not methods of nested types). */
+function directMethods(typeNode) {
+    const out = [];
+    const visit = (node) => {
+        for (const child of node.namedChildren) {
+            if (child.type === 'method_declaration') {
+                out.push(child);
+                continue;
+            }
+            // Don't descend into a nested type — its methods aren't this type's.
+            if (child !== typeNode &&
+                (child.type === 'class_declaration' || child.type === 'interface_declaration')) {
+                continue;
+            }
+            visit(child);
+        }
+    };
+    visit(typeNode);
+    return out;
+}
+/**
+ * Build the project-wide `SharedSpringType` view for one Java file: every class
+ * and interface with its class prefixes, implemented interfaces, controller
+ * flag, and per-method route annotations. The cross-file inheritance pass
+ * (#2288) feeds these into the shared `resolveInheritedSpringRoutes` so a
+ * concrete controller inherits the `@*Mapping`s declared on its interfaces.
+ *
+ * This is the ingestion counterpart of the group layer's `collectSpringTypes`
+ * (`group/extractors/http-patterns/java.ts`); both produce the same neutral
+ * shape so the two layers resolve inheritance identically (#2078 parity).
+ */
+export function extractSpringTypes(tree, filePath) {
+    const out = [];
+    for (const match of TYPE_DECLARATION_QUERY.matches(tree.rootNode)) {
+        const typeNode = match.captures.find((c) => c.name === 'type')?.node;
+        if (!typeNode)
+            continue;
+        const name = typeNode.childForFieldName('name')?.text;
+        if (!name)
+            continue;
+        const kind = typeNode.type === 'interface_declaration' ? 'interface' : 'class';
+        const annNames = declarationAnnotations(typeNode).map(annotationName);
+        const isController = kind === 'class' && (annNames.includes('RestController') || annNames.includes('Controller'));
+        const methods = directMethods(typeNode)
+            .map((methodNode) => {
+            const methodName = methodNode.childForFieldName('name')?.text;
+            if (!methodName)
+                return null;
+            const routes = [];
+            for (const ann of declarationAnnotations(methodNode)) {
+                const verb = METHOD_ANNOTATION_TO_HTTP[annotationName(ann) ?? ''];
+                if (!verb)
+                    continue;
+                for (const path of annotationRoutePaths(ann))
+                    routes.push({ method: verb, path });
+            }
+            return { name: methodName, routes };
+        })
+            .filter((m) => m !== null);
+        out.push({
+            filePath,
+            kind,
+            name,
+            classPrefixes: typeClassPrefixes(typeNode),
+            implementedInterfaces: kind === 'class' ? implementedInterfaceNames(typeNode) : [],
+            isController,
+            methods,
+        });
+    }
+    return out;
+}

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -6,6 +6,7 @@ import type { ConstructorBinding } from '../type-env.js';
 import type { NodeLabel, ParameterTypeClass } from '../../../_shared/index.js';
 import type { ParsedFile } from '../../../_shared/index.js';
 import { type ExtractedRoute } from '../route-extractors/laravel.js';
+import type { SharedSpringType } from '../route-extractors/spring-shared.js';
 import { type CfgSkipCounts } from '../cfg/collect.js';
 export type { ExtractedRoute } from '../route-extractors/laravel.js';
 interface ParsedNode {
@@ -190,6 +191,15 @@ export interface ParseWorkerResult {
     decoratorRoutes: ExtractedDecoratorRoute[];
     routerIncludes: ExtractedRouterInclude[];
     routerImports: ExtractedRouterImport[];
+    /**
+     * Optional. Project-wide `SharedSpringType` view of route-defining
+     * class/interface declarations, produced by the provider's
+     * `extractRouteInheritanceTypes` hook (Java/Spring). parse-impl aggregates
+     * these and runs a cross-file pass that resolves interface-inherited routes
+     * into additional `decoratorRoutes` (#2288). Optional for cache backward
+     * compatibility; consumers must guard with `?? []`.
+     */
+    springTypes?: SharedSpringType[];
     /**
      * Optional. `from <pkg> import <module>` records from Python files
      * where `<module>` is later used as a Shape-A include receiver

package/dist/core/ingestion/workers/parse-worker.js

@@ -1832,6 +1832,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             for (const r of frameworkRoutes)
                 result.decoratorRoutes.push(r);
         }
+        // Project-wide route-inheritance type collection via provider hook (#2288).
+        // The per-file SharedSpringType views are aggregated by the parse phase,
+        // which then resolves interface-inherited routes cross-file.
+        if (provider.extractRouteInheritanceTypes) {
+            const springTypes = provider.extractRouteInheritanceTypes(tree, file.path);
+            if (springTypes.length > 0)
+                (result.springTypes ??= []).push(...springTypes);
+        }
         // Vue: emit CALLS edges for components used in <template>
         if (language === SupportedLanguages.Vue) {
             const templateComponents = extractTemplateComponents(file.content);

package/dist/core/ingestion/workers/result-merge.js

@@ -28,6 +28,10 @@ export const mergeResult = (target, src) => {
         target.routerModuleAliases ??= [];
         appendAll(target.routerModuleAliases, src.routerModuleAliases);
     }
+    if (src.springTypes) {
+        target.springTypes ??= [];
+        appendAll(target.springTypes, src.springTypes);
+    }
     appendAll(target.toolDefs, src.toolDefs);
     appendAll(target.ormQueries, src.ormQueries);
     appendAll(target.constructorBindings, src.constructorBindings);

package/dist/core/run-analyze.js

@@ -353,6 +353,20 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         }
         try {
             await initLbug(lbugPath);
+            // Gate on FTS availability BEFORE touching any index. createSearchFTSIndexes
+            // now DROPs each index before recreating it (so schema changes reach existing
+            // DBs); if the extension were unavailable, the drops would run and leave the
+            // DB index-less, only failing at the create step. Fail loudly first — mirrors
+            // the analyze path's `if (ftsAvailable)` gate below — so an unavailable
+            // extension never destroys the existing indexes.
+            const repairFtsAvailable = await loadFTSExtension(undefined, {
+                policy: resolveAnalyzeInstallPolicy(),
+            });
+            if (!repairFtsAvailable) {
+                throw new Error('Cannot repair FTS indexes: the LadybugDB FTS extension is unavailable ' +
+                    '(not pre-installed and could not be installed on this machine). ' +
+                    'Run `gitnexus doctor` to install it, then retry `--repair-fts`.');
+            }
             progress('fts', 85, 'Repairing search indexes...');
             await createSearchFTSIndexes({
                 onIndexStart: options.verbose

package/dist/core/search/fts-indexes.js

@@ -1,32 +1,48 @@
-import { createFTSIndex } from '../lbug/lbug-adapter.js';
+import { createFTSIndex, dropFTSIndex } from '../lbug/lbug-adapter.js';
 import { FTS_INDEXES } from './fts-schema.js';
 export async function createSearchFTSIndexes(options) {
     for (const { table, indexName, properties } of FTS_INDEXES) {
         options?.onIndexStart?.(table, indexName);
+        // Drop first so the live `properties` always win. `createFTSIndex` is
+        // idempotent-by-name (skips when the index already exists), so without the
+        // drop a schema change — e.g. adding `description` (#2299) — would never
+        // reach an existing `.lbug` DB on an incremental re-analyze or `--repair-fts`;
+        // the old name+content index would silently persist. `dropFTSIndex` no-ops
+        // when the index is absent (first-ever analyze) and clears the per-connection
+        // memo so the create below actually runs.
+        // ponytail: this rebuilds every FTS index on every analyze instead of
+        // skipping when present; FTS build is proportional to symbol-table size and
+        // runs inside the existing FTS phase. Gate on a stored schema fingerprint if
+        // this rebuild cost ever shows up in analyze profiles.
+        await dropFTSIndex(table, indexName);
         await createFTSIndex(table, indexName, [...properties]);
         options?.onIndexReady?.(table, indexName);
     }
 }
 export async function verifySearchFTSIndexes(executeQuery) {
-    const safeIdentifier = (value) => {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
-            throw new Error(`Invalid FTS identifier: ${value}`);
-        }
-        return value;
-    };
+    // Read the catalog once and check each configured index both EXISTS and
+    // covers its expected columns. A queryability-only probe (CALL QUERY_FTS_INDEX
+    // ... catch) is not enough: a stale `name+content`-only index left on a
+    // pre-#2299 DB stays queryable yet silently misses `description`, so the probe
+    // would pass while doc-comment search is still broken (#2299). SHOW_INDEXES
+    // exposes `property_names` (STRING[]) per index, so we assert coverage directly.
+    const rows = await executeQuery('CALL SHOW_INDEXES() RETURN *');
+    const propsByIndex = new Map();
+    for (const row of rows) {
+        if (typeof row !== 'object' || row === null)
+            continue;
+        const record = row;
+        const indexName = record.index_name;
+        const propertyNames = record.property_names;
+        if (typeof indexName !== 'string' || !Array.isArray(propertyNames))
+            continue;
+        propsByIndex.set(indexName, propertyNames.filter((p) => typeof p === 'string'));
+    }
     const missing = [];
-    for (const { table, indexName } of FTS_INDEXES) {
-        const safeTable = safeIdentifier(table);
-        const safeIndex = safeIdentifier(indexName);
-        const probe = `
-      CALL QUERY_FTS_INDEX('${safeTable}', '${safeIndex}', '__gitnexus_fts_probe__', conjunctive := false)
-      RETURN score
-      LIMIT 1
-    `;
-        try {
-            await executeQuery(probe);
-        }
-        catch {
+    for (const { table, indexName, properties } of FTS_INDEXES) {
+        const actual = propsByIndex.get(indexName);
+        // Absent from the catalog, or present but not covering every expected column.
+        if (!actual || !properties.every((p) => actual.includes(p))) {
             missing.push(`${table}.${indexName}`);
         }
     }

package/dist/core/search/fts-schema.js

@@ -1,7 +1,40 @@
+// Shared by both index creation (`createSearchFTSIndexes`) and querying
+// (`searchFTSFromLbug` / `verifySearchFTSIndexes`) — the single source of truth
+// for which tables/columns are full-text searchable. Adding `description` here
+// makes doc comments (Javadoc/KDoc/JSDoc/Doxygen/godoc/RDoc) keyword-searchable
+// once they are populated by `descriptionExtractor` (#2270/#2286, issue #2299).
+//
+// IMPORTANT: every property must be a real column on its table (see
+// `core/lbug/schema.ts`). `File` has no `description` column, so it stays
+// name+content. All other entries below carry a `description` column.
+//
+// Tables beyond the original 5 mirror `EMBEDDABLE_LABELS` (embeddings/types.ts):
+// indexing the same set keeps a symbol's doc comment both keyword- and
+// semantically-searchable.
+const FTS_PROPERTIES = ['name', 'content', 'description'];
 export const FTS_INDEXES = [
+    // File has no `description` column — keep it name+content only.
     { table: 'File', indexName: 'file_fts', properties: ['name', 'content'] },
-    { table: 'Function', indexName: 'function_fts', properties: ['name', 'content'] },
-    { table: 'Class', indexName: 'class_fts', properties: ['name', 'content'] },
-    { table: 'Method', indexName: 'method_fts', properties: ['name', 'content'] },
-    { table: 'Interface', indexName: 'interface_fts', properties: ['name', 'content'] },
+    // Original 5 (minus File) gain `description`.
+    { table: 'Function', indexName: 'function_fts', properties: FTS_PROPERTIES },
+    { table: 'Class', indexName: 'class_fts', properties: FTS_PROPERTIES },
+    { table: 'Method', indexName: 'method_fts', properties: FTS_PROPERTIES },
+    { table: 'Interface', indexName: 'interface_fts', properties: FTS_PROPERTIES },
+    // Remaining EMBEDDABLE_LABELS symbol tables — all CODE_ELEMENT_BASE-shaped
+    // (or a superset), so all carry name + content + description columns.
+    { table: 'Constructor', indexName: 'constructor_fts', properties: FTS_PROPERTIES },
+    { table: 'Struct', indexName: 'struct_fts', properties: FTS_PROPERTIES },
+    { table: 'Enum', indexName: 'enum_fts', properties: FTS_PROPERTIES },
+    { table: 'Trait', indexName: 'trait_fts', properties: FTS_PROPERTIES },
+    { table: 'Impl', indexName: 'impl_fts', properties: FTS_PROPERTIES },
+    { table: 'Macro', indexName: 'macro_fts', properties: FTS_PROPERTIES },
+    { table: 'Namespace', indexName: 'namespace_fts', properties: FTS_PROPERTIES },
+    { table: 'TypeAlias', indexName: 'type_alias_fts', properties: FTS_PROPERTIES },
+    { table: 'Typedef', indexName: 'typedef_fts', properties: FTS_PROPERTIES },
+    { table: 'Const', indexName: 'const_fts', properties: FTS_PROPERTIES },
+    { table: 'Property', indexName: 'property_fts', properties: FTS_PROPERTIES },
+    { table: 'Record', indexName: 'record_fts', properties: FTS_PROPERTIES },
+    { table: 'Union', indexName: 'union_fts', properties: FTS_PROPERTIES },
+    { table: 'Static', indexName: 'static_fts', properties: FTS_PROPERTIES },
+    { table: 'Variable', indexName: 'variable_fts', properties: FTS_PROPERTIES },
 ];

package/dist/storage/parse-cache.js

@@ -52,7 +52,7 @@ import { fileURLToPath } from 'url';
 // the main thread (the #1983 OOM). Because the two stores share this version,
 // any future change to the `ParsedFile` serialization shape MUST bump
 // SCHEMA_BUMP so both invalidate in lockstep.
-const SCHEMA_BUMP = 7; // #2138 Part 2: ExtractedDecoratorRoute gained `handlerName` (route handler symbol resolution)
+const SCHEMA_BUMP = 8; // #2288: ParseWorkerResult gained `springTypes` (Spring interface-inheritance) + `decoratorRoutes` semantics changed (interface routes suppressed at extraction, inherited routes appended in parse-impl)
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.9-rc.20",
+  "version": "1.6.9-rc.22",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -70,6 +70,7 @@ const LBUG_NATIVE = [
   'test/integration/local-backend-calltool.test.ts',
   'test/integration/search-core.test.ts',
   'test/integration/search-pool.test.ts',
+  'test/integration/fts-description-search.test.ts',
   'test/integration/staleness-and-stability.test.ts',
   'test/integration/analyze-wal-checkpoint-failure.test.ts',
 ];