gitnexus 1.6.10-rc.219 → 1.6.10-rc.220

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

@@ -28,6 +28,20 @@ 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). */
 export type CaptureMap = Record<string, SyntaxNode | undefined>;
+export interface DefinitionPropertiesContext {
+    readonly nodeLabel: NodeLabel;
+    readonly nodeName: string;
+    readonly definitionNode: SyntaxNode;
+    readonly parsedImports: readonly ParsedImport[];
+    readonly isExported: boolean;
+}
+export type DefinitionPropertiesExtractor = (context: DefinitionPropertiesContext) => Readonly<Record<string, unknown>> | undefined;
+/** Run optional provider enrichment without allowing one hook failure to drop
+ * the rest of the worker's language batch. */
+export declare function runDefinitionPropertiesExtractor(extractor: DefinitionPropertiesExtractor, context: DefinitionPropertiesContext, onError: (error: unknown) => void): Readonly<Record<string, unknown>> | undefined;
+/** Provider metadata is additive; graph identity and source-location fields
+ * supplied by the worker remain authoritative. */
+export declare function mergeCanonicalDefinitionProperties<TCanonical extends Readonly<Record<string, unknown>>>(providerProperties: Readonly<Record<string, unknown>>, canonicalProperties: TCanonical): Record<string, unknown> & TCanonical;
 /** Configuration for AST-based framework detection patterns. */
 export interface AstFrameworkPatternConfig {
     framework: string;
@@ -215,6 +229,10 @@ interface LanguageProviderConfig {
      *  constant, and static declarations. Produces VariableInfo with type, visibility,
      *  isConst, isStatic, isMutable metadata. Default: undefined (no variable extraction). */
     readonly variableExtractor?: VariableExtractor;
+    /** Add language-owned, structured properties to a definition node. Values
+     *  cross the worker boundary and must therefore be structured-clone-safe.
+     *  Shared ingestion code treats these properties as opaque. */
+    readonly definitionPropertiesExtractor?: DefinitionPropertiesExtractor;
     /** Class/type extractor for deriving canonical qualified names for class-like symbols.
      *  Uses the same provider-driven strategy pattern as method/field extraction so
      *  namespace/package/module rules stay language-specific. */

package/dist/core/ingestion/language-provider.js

@@ -8,6 +8,22 @@
  * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
  * so adding a language to the enum without creating a provider is a compiler error.
  */
+/** Run optional provider enrichment without allowing one hook failure to drop
+ * the rest of the worker's language batch. */
+export function runDefinitionPropertiesExtractor(extractor, context, onError) {
+    try {
+        return extractor(context);
+    }
+    catch (error) {
+        onError(error);
+        return undefined;
+    }
+}
+/** Provider metadata is additive; graph identity and source-location fields
+ * supplied by the worker remain authoritative. */
+export function mergeCanonicalDefinitionProperties(providerProperties, canonicalProperties) {
+    return { ...providerProperties, ...canonicalProperties };
+}
 /**
  * Everything a language needs to provide.
  * Required fields must be explicitly set; optional fields have defaults

package/dist/core/ingestion/languages/typescript/convex-endpoint-metadata.d.ts

@@ -0,0 +1,7 @@
+import type { DefinitionPropertiesContext } from '../../language-provider.js';
+/**
+ * Stamp Convex runtime-dispatch metadata only when both the declaration shape
+ * and the factory import provenance are known. The MCP layer consumes the
+ * resulting property without reparsing lossy FTS text.
+ */
+export declare function extractConvexEndpointProperties(context: DefinitionPropertiesContext): Readonly<Record<string, unknown>> | undefined;

package/dist/core/ingestion/languages/typescript/convex-endpoint-metadata.js

@@ -0,0 +1,92 @@
+import { assertCloneable } from '../../workers/clone-safety.js';
+const GENERATED_ENDPOINT_FACTORIES = new Set([
+    'query',
+    'mutation',
+    'action',
+    'internalQuery',
+    'internalMutation',
+    'internalAction',
+    'httpAction',
+]);
+const GENERIC_ENDPOINT_FACTORIES = new Map([...GENERATED_ENDPOINT_FACTORIES].map((factory) => [`${factory}Generic`, factory]));
+const normalizeModuleTarget = (targetRaw) => targetRaw.replace(/\\/g, '/').replace(/\.(?:[cm]?[jt]s)$/, '');
+const isGeneratedServerModule = (targetRaw) => /(?:^|\/)_generated\/server$/.test(normalizeModuleTarget(targetRaw));
+function importedConvexFactory(imports, localName) {
+    for (const parsedImport of imports) {
+        if (parsedImport.kind !== 'named' && parsedImport.kind !== 'alias')
+            continue;
+        if (parsedImport.localName !== localName)
+            continue;
+        const target = normalizeModuleTarget(parsedImport.targetRaw);
+        if (target === 'convex/server') {
+            return GENERIC_ENDPOINT_FACTORIES.get(parsedImport.importedName);
+        }
+        if (isGeneratedServerModule(target)) {
+            return GENERATED_ENDPOINT_FACTORIES.has(parsedImport.importedName)
+                ? parsedImport.importedName
+                : undefined;
+        }
+    }
+    return undefined;
+}
+function matchingDeclarator(node, nodeName) {
+    if (node.type === 'variable_declarator' && node.childForFieldName('name')?.text === nodeName) {
+        return node;
+    }
+    if (node.type === 'export_statement') {
+        const declaration = node.childForFieldName('declaration');
+        return declaration ? matchingDeclarator(declaration, nodeName) : undefined;
+    }
+    if (node.type !== 'lexical_declaration' && node.type !== 'variable_declaration') {
+        return undefined;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declarator' &&
+            child.childForFieldName('name')?.text === nodeName) {
+            return child;
+        }
+    }
+    return undefined;
+}
+function findDeclarator(node, nodeName) {
+    let current = node;
+    while (current) {
+        const declarator = matchingDeclarator(current, nodeName);
+        if (declarator)
+            return declarator;
+        if (current.type === 'program' || current.type === 'statement_block')
+            break;
+        current = current.parent;
+    }
+    return undefined;
+}
+/**
+ * Stamp Convex runtime-dispatch metadata only when both the declaration shape
+ * and the factory import provenance are known. The MCP layer consumes the
+ * resulting property without reparsing lossy FTS text.
+ */
+export function extractConvexEndpointProperties(context) {
+    if ((context.nodeLabel !== 'Const' && context.nodeLabel !== 'Function') || !context.isExported) {
+        return undefined;
+    }
+    const declarator = findDeclarator(context.definitionNode, context.nodeName);
+    const value = declarator?.childForFieldName('value');
+    if (!value || value.type !== 'call_expression')
+        return undefined;
+    const callee = value.childForFieldName('function');
+    if (!callee || callee.type !== 'identifier')
+        return undefined;
+    const factory = importedConvexFactory(context.parsedImports, callee.text);
+    if (factory === undefined)
+        return undefined;
+    const args = value.childForFieldName('arguments');
+    if (!args || args.namedChildCount !== 1)
+        return undefined;
+    const endpointDefinition = args.namedChild(0);
+    if (!endpointDefinition ||
+        !['object', 'arrow_function', 'function_expression'].includes(endpointDefinition.type)) {
+        return undefined;
+    }
+    return assertCloneable({ convexEndpointFactory: factory });
+}

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

@@ -74,6 +74,7 @@ import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindi
 import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding, jsMergeBindings, jsArityCompatibility, } from './javascript/index.js';
 import { extractDispatchGuardRoutes } from '../route-extractors/dispatch-guard.js';
 import { extractDataRouteTableRoutes } from '../route-extractors/data-route-table.js';
+import { extractConvexEndpointProperties } from './typescript/convex-endpoint-metadata.js';
 const extractJsTsRoutes = (...args) => [
     ...extractDispatchGuardRoutes(...args),
     ...extractDataRouteTableRoutes(...args),
@@ -347,6 +348,7 @@ export const typescriptProvider = defineLanguage({
         extractFunctionName: tsExtractFunctionName,
     }),
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    definitionPropertiesExtractor: extractConvexEndpointProperties,
     classExtractor: createClassExtractor(typescriptClassConfig),
     // ── JSDoc → description (issue #2270). An exported decl is captured as the
     //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──
@@ -430,6 +432,7 @@ export const javascriptProvider = defineLanguage({
         extractFunctionName: tsExtractFunctionName,
     }),
     variableExtractor: createVariableExtractor(javascriptVariableConfig),
+    definitionPropertiesExtractor: extractConvexEndpointProperties,
     classExtractor: createClassExtractor(javascriptClassConfig),
     // ── JSDoc → description (issue #2270). An exported decl is captured as the
     //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──

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

@@ -69,7 +69,7 @@ import { defaultExportNameCollides } from '../languages/typescript/cjs-export-as
 import { extractVueScript, extractTemplateComponents, isVueSetupTopLevel, } from '../vue-sfc-extractor.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, parameterShapeIdTag, methodInfoKey, } from '../utils/method-props.js';
 import { extractTemplateArguments, templateArgumentsIdTag, templateConstraintsIdTag, } from '../utils/template-arguments.js';
-import { shouldHarvestModuleConstants } from '../language-provider.js';
+import { mergeCanonicalDefinitionProperties, runDefinitionPropertiesExtractor, shouldHarvestModuleConstants, } from '../language-provider.js';
 import { extractParsedFile } from '../scope-extractor-bridge.js';
 import { persistParsedFileShardSync, persistDurableParsedFileShardSync, } from '../../../storage/parsedfile-store.js';
 import { extractLaravelRoutes } from '../route-extractors/laravel.js';
@@ -2112,18 +2112,30 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     methodProps.scope = varInfo.scope;
                 }
             }
+            const isExported = language === SupportedLanguages.Vue && isVueSetup
+                ? isVueSetupTopLevel(nameNode || definitionNode)
+                : cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName);
+            if (definitionNode && provider.definitionPropertiesExtractor) {
+                const definitionProperties = runDefinitionPropertiesExtractor(provider.definitionPropertiesExtractor, {
+                    nodeLabel,
+                    nodeName,
+                    definitionNode,
+                    parsedImports: parsedFile?.parsedImports ?? [],
+                    isExported,
+                }, (error) => reportWarning(`Definition property extraction failed for ${file.path}:${nodeName}: ${error instanceof Error ? error.message : String(error)}`));
+                if (definitionProperties !== undefined)
+                    Object.assign(methodProps, definitionProperties);
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
-                properties: {
+                properties: mergeCanonicalDefinitionProperties(methodProps, {
                     name: nodeName,
                     filePath: file.path,
                     startLine,
                     endLine: definitionNode ? definitionNode.endPosition.row + lineOffset : startLine,
                     language: language,
-                    isExported: language === SupportedLanguages.Vue && isVueSetup
-                        ? isVueSetupTopLevel(nameNode || definitionNode)
-                        : cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName),
+                    isExported,
                     ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
                     ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0
                         ? { templateArguments: classTemplateArguments }
@@ -2138,10 +2150,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         }
                         : {}),
                     ...(description !== undefined ? { description } : {}),
-                    ...methodProps,
                     ...(declaredType !== undefined ? { declaredType } : {}),
                     ...(returnShapeProperty ? { fromReturnShape: true, isDetail: true } : {}),
-                },
+                }),
             });
             // enclosingClassId already computed above (before nodeId generation)
             const ownerId = enclosingClassId ?? objectLiteralOwnerInfo?.ownerId;

package/dist/core/lbug/csv-generator.js

@@ -417,7 +417,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
         const fileWriter = new BufferedCSVWriter(path.join(csvDir, 'file.csv'), 'id,name,filePath,content');
         const folderWriter = new BufferedCSVWriter(path.join(csvDir, 'folder.csv'), 'id,name,filePath');
         const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description';
-        const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), codeElementHeader);
+        const functionWriter = new BufferedCSVWriter(path.join(csvDir, 'function.csv'), `${codeElementHeader},convexEndpointFactory`);
         const classWriter = new BufferedCSVWriter(path.join(csvDir, 'class.csv'), `${codeElementHeader},frameworkAnnotations`);
         const interfaceWriter = new BufferedCSVWriter(path.join(csvDir, 'interface.csv'), codeElementHeader);
         const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
@@ -436,6 +436,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
         const basicBlockWriter = new BufferedCSVWriter(path.join(csvDir, 'basicblock.csv'), BASICBLOCK_CSV_HEADER);
         // Multi-language node types share the same CSV shape (no isExported column)
         const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
+        const constHeader = `${multiLangHeader},convexEndpointFactory`;
         const MULTI_LANG_TYPES = [
             'Struct',
             'Enum',
@@ -460,7 +461,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
         const propertyHeader = 'id,name,filePath,startLine,endLine,content,description,declaredType,isDetail';
         const multiLangWriters = new Map();
         for (const t of MULTI_LANG_TYPES) {
-            multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : multiLangHeader));
+            multiLangWriters.set(t, new BufferedCSVWriter(path.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : t === 'Const' ? constHeader : multiLangHeader));
         }
         const codeWriterMap = {
             Function: functionWriter,
@@ -609,6 +610,9 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                         if (node.label === 'Class') {
                             row.push(escapeCSVField(formatCSVStringArray(node.properties.frameworkAnnotations)));
                         }
+                        else if (node.label === 'Function') {
+                            row.push(escapeCSVField(String(node.properties.convexEndpointFactory ?? '')));
+                        }
                         pending = writer.addRow(row.join(','));
                     }
                     else {
@@ -632,7 +636,9 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseCo
                                         // empty BOOLEAN cell fails the COPY.
                                         node.properties.isDetail === true ? 'true' : 'false',
                                     ]
-                                    : []),
+                                    : node.label === 'Const'
+                                        ? [escapeCSVField(String(node.properties.convexEndpointFactory ?? ''))]
+                                        : []),
                             ].join(','));
                         }
                         else {

package/dist/core/lbug/lbug-adapter.js

@@ -1336,9 +1336,15 @@ export const getCopyQuery = (table, filePath) => {
     if (table === 'Method') {
         return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description, parameterCount, returnType) FROM "${filePath}" ${COPY_CSV_OPTS}`;
     }
+    if (table === 'Function') {
+        return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description, convexEndpointFactory) FROM "${filePath}" ${COPY_CSV_OPTS}`;
+    }
     if (table === 'Property') {
         return `COPY ${t}(id, name, filePath, startLine, endLine, content, description, declaredType, isDetail) FROM "${filePath}" ${COPY_CSV_OPTS}`;
     }
+    if (table === 'Const') {
+        return `COPY ${t}(id, name, filePath, startLine, endLine, content, description, convexEndpointFactory) FROM "${filePath}" ${COPY_CSV_OPTS}`;
+    }
     // TypeScript/JS code element tables have isExported; multi-language tables do not
     if (TABLES_WITH_EXPORTED.has(table)) {
         return `COPY ${t}(id, name, filePath, startLine, endLine, isExported, content, description) FROM "${filePath}" ${COPY_CSV_OPTS}`;
@@ -1388,6 +1394,18 @@ export const insertNodeToLbug = async (label, properties, dbPath) => {
                 : '';
             query = `CREATE (n:Class {id: ${formatCypherValue(properties.id)}, name: ${formatCypherValue(properties.name)}, filePath: ${formatCypherValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${formatCypherValue(properties.content || '')}${descPart}, frameworkAnnotations: ${formatCypherStringArray(properties.frameworkAnnotations)}})`;
         }
+        else if (label === 'Function') {
+            const descPart = properties.description
+                ? `, description: ${formatCypherValue(properties.description)}`
+                : '';
+            query = `CREATE (n:Function {id: ${formatCypherValue(properties.id)}, name: ${formatCypherValue(properties.name)}, filePath: ${formatCypherValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, isExported: ${!!properties.isExported}, content: ${formatCypherValue(properties.content || '')}${descPart}, convexEndpointFactory: ${formatCypherValue(properties.convexEndpointFactory ?? '')}})`;
+        }
+        else if (label === 'Const') {
+            const descPart = properties.description
+                ? `, description: ${formatCypherValue(properties.description)}`
+                : '';
+            query = `CREATE (n:Const {id: ${formatCypherValue(properties.id)}, name: ${formatCypherValue(properties.name)}, filePath: ${formatCypherValue(properties.filePath)}, startLine: ${properties.startLine || 0}, endLine: ${properties.endLine || 0}, content: ${formatCypherValue(properties.content || '')}${descPart}, convexEndpointFactory: ${formatCypherValue(properties.convexEndpointFactory ?? '')}})`;
+        }
         else if (TABLES_WITH_EXPORTED.has(label)) {
             const descPart = properties.description
                 ? `, description: ${formatCypherValue(properties.description)}`
@@ -1478,6 +1496,18 @@ export const batchInsertNodesToLbug = async (nodes, dbPath) => {
                         : '';
                     query = `MERGE (n:Class {id: ${formatCypherValue(properties.id)}}) SET n.name = ${formatCypherValue(properties.name)}, n.filePath = ${formatCypherValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${formatCypherValue(properties.content || '')}${descPart}, n.frameworkAnnotations = ${formatCypherStringArray(properties.frameworkAnnotations)}`;
                 }
+                else if (label === 'Function') {
+                    const descPart = properties.description
+                        ? `, n.description = ${formatCypherValue(properties.description)}`
+                        : '';
+                    query = `MERGE (n:Function {id: ${formatCypherValue(properties.id)}}) SET n.name = ${formatCypherValue(properties.name)}, n.filePath = ${formatCypherValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.isExported = ${!!properties.isExported}, n.content = ${formatCypherValue(properties.content || '')}${descPart}, n.convexEndpointFactory = ${formatCypherValue(properties.convexEndpointFactory ?? '')}`;
+                }
+                else if (label === 'Const') {
+                    const descPart = properties.description
+                        ? `, n.description = ${formatCypherValue(properties.description)}`
+                        : '';
+                    query = `MERGE (n:Const {id: ${formatCypherValue(properties.id)}}) SET n.name = ${formatCypherValue(properties.name)}, n.filePath = ${formatCypherValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${formatCypherValue(properties.content || '')}${descPart}, n.convexEndpointFactory = ${formatCypherValue(properties.convexEndpointFactory ?? '')}`;
+                }
                 else if (TABLES_WITH_EXPORTED.has(label)) {
                     const descPart = properties.description
                         ? `, n.description = ${formatCypherValue(properties.description)}`

package/dist/core/lbug/schema.d.ts

@@ -13,7 +13,7 @@ export { NODE_TABLES, REL_TABLE_NAME, REL_TYPES, EMBEDDING_TABLE_NAME };
 export type { NodeTableName, RelType } from '../../_shared/index.js';
 export declare const FILE_SCHEMA = "\nCREATE NODE TABLE File (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  content STRING,\n  PRIMARY KEY (id)\n)";
 export declare const FOLDER_SCHEMA = "\nCREATE NODE TABLE Folder (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  PRIMARY KEY (id)\n)";
-export declare const FUNCTION_SCHEMA = "\nCREATE NODE TABLE Function (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
+export declare const FUNCTION_SCHEMA = "\nCREATE NODE TABLE Function (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  convexEndpointFactory STRING,\n  PRIMARY KEY (id)\n)";
 export declare const CLASS_SCHEMA = "\nCREATE NODE TABLE Class (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  frameworkAnnotations STRING[],\n  PRIMARY KEY (id)\n)";
 export declare const INTERFACE_SCHEMA = "\nCREATE NODE TABLE Interface (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  PRIMARY KEY (id)\n)";
 export declare const METHOD_SCHEMA = "\nCREATE NODE TABLE Method (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  isExported BOOLEAN,\n  content STRING,\n  description STRING,\n  parameterCount INT32,\n  returnType STRING,\n  PRIMARY KEY (id)\n)";
@@ -29,7 +29,7 @@ export declare const NAMESPACE_SCHEMA: string;
 export declare const TRAIT_SCHEMA: string;
 export declare const IMPL_SCHEMA: string;
 export declare const TYPE_ALIAS_SCHEMA: string;
-export declare const CONST_SCHEMA: string;
+export declare const CONST_SCHEMA = "\nCREATE NODE TABLE `Const` (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  content STRING,\n  description STRING,\n  convexEndpointFactory STRING,\n  PRIMARY KEY (id)\n)";
 export declare const STATIC_SCHEMA: string;
 export declare const VARIABLE_SCHEMA: string;
 export declare const PROPERTY_SCHEMA = "\nCREATE NODE TABLE `Property` (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  startLine INT64,\n  endLine INT64,\n  content STRING,\n  description STRING,\n  declaredType STRING,\n  /*\n   * DETAIL SYMBOL \u2014 true when this property is a member of a shape that has no\n   * independent identity: the keys of an anonymous literal returned from a\n   * function (R3-4).\n   *\n   * It exists because indexing those keys is right for the GRAPH and wrong for\n   * TEXT SEARCH. They are ordinary words (message, value, timestamp) and\n   * there are many of them, so letting them into the FTS result set pushes the\n   * CALLABLES named after the same concept past the row cap the search applies\n   * \u2014 measured: query('message') went from two processes to none on the\n   * mini-repo fixture. A ranking tweak cannot fix that, because the rows never\n   * come back from the FTS call in the first place.\n   *\n   * So the search layer gained a notion it did not have \u2014 a symbol that is\n   * queryable, walkable and impact-analysable, but not a concept a text search\n   * should surface on its own. buildFtsQueryCypher excludes these for the\n   * Property table only; every other consumer sees them normally.\n   */\n  isDetail BOOLEAN,\n  PRIMARY KEY (id)\n)";

package/dist/core/lbug/schema.js

@@ -44,6 +44,7 @@ CREATE NODE TABLE Function (
   isExported BOOLEAN,
   content STRING,
   description STRING,
+  convexEndpointFactory STRING,
   PRIMARY KEY (id)
 )`;
 export const CLASS_SCHEMA = `
@@ -152,7 +153,18 @@ export const NAMESPACE_SCHEMA = CODE_ELEMENT_BASE('Namespace');
 export const TRAIT_SCHEMA = CODE_ELEMENT_BASE('Trait');
 export const IMPL_SCHEMA = CODE_ELEMENT_BASE('Impl');
 export const TYPE_ALIAS_SCHEMA = CODE_ELEMENT_BASE('TypeAlias');
-export const CONST_SCHEMA = CODE_ELEMENT_BASE('Const');
+export const CONST_SCHEMA = `
+CREATE NODE TABLE \`Const\` (
+  id STRING,
+  name STRING,
+  filePath STRING,
+  startLine INT64,
+  endLine INT64,
+  content STRING,
+  description STRING,
+  convexEndpointFactory STRING,
+  PRIMARY KEY (id)
+)`;
 export const STATIC_SCHEMA = CODE_ELEMENT_BASE('Static');
 export const VARIABLE_SCHEMA = CODE_ELEMENT_BASE('Variable');
 export const PROPERTY_SCHEMA = `

package/dist/mcp/local/convex-metadata.d.ts

@@ -0,0 +1,8 @@
+import { executeParameterized } from '../../core/lbug/pool-adapter.js';
+export interface ConvexDispatchMetadata {
+    readonly factory?: string;
+    readonly boundary: string;
+    readonly staleIndex?: true;
+    readonly probeFailed?: true;
+}
+export declare function queryConvexDispatchMetadata(lbugPath: string, symbolId: string, symbolName: string, symbolType: string, runQuery?: typeof executeParameterized): Promise<ConvexDispatchMetadata | undefined>;

package/dist/mcp/local/convex-metadata.js

@@ -0,0 +1,45 @@
+import { executeParameterized } from '../../core/lbug/pool-adapter.js';
+import { logger } from '../../core/logger.js';
+function isMissingConvexMetadataProperty(error) {
+    const message = error instanceof Error ? error.message : String(error ?? '');
+    return /cannot find property\s+convexEndpointFactory|property[^\n]*convexEndpointFactory[^\n]*not (?:defined|found)/i.test(message);
+}
+export async function queryConvexDispatchMetadata(lbugPath, symbolId, symbolName, symbolType, runQuery = executeParameterized) {
+    if (symbolType !== 'Const' && symbolType !== 'Function')
+        return undefined;
+    const nodeLabel = symbolType === 'Function' ? 'Function' : 'Const';
+    try {
+        const rows = await runQuery(lbugPath, `MATCH (n:${nodeLabel} {id: $symbolId})
+       RETURN n.convexEndpointFactory AS factory`, { symbolId });
+        const row = rows[0];
+        if (row === undefined)
+            return undefined;
+        const factory = String(row.factory ?? row[0] ?? '');
+        if (factory.length === 0)
+            return undefined;
+        return {
+            factory,
+            boundary: `${symbolName} is exported through Convex ${factory}({...}) and can be addressed through ` +
+                `the anyApi runtime proxy; callers across that dynamic-dispatch boundary leave no static ` +
+                `edge, so actual impact may be higher.`,
+        };
+    }
+    catch (error) {
+        if (isMissingConvexMetadataProperty(error)) {
+            return {
+                staleIndex: true,
+                boundary: 'Convex runtime-proxy metadata is unavailable because this index predates ' +
+                    'convexEndpointFactory; re-index before treating impact as exact.',
+            };
+        }
+        logger.warn({
+            context: 'impact:convex-metadata',
+            err: error instanceof Error ? error.message : String(error),
+        }, 'GitNexus Convex metadata probe failed (degraded)');
+        return {
+            probeFailed: true,
+            boundary: 'Convex runtime-proxy metadata could not be checked; impact remains a lower bound ' +
+                'until the metadata probe succeeds.',
+        };
+    }
+}

package/dist/mcp/local/local-backend.d.ts

@@ -94,9 +94,8 @@ export interface EpistemicCauses {
      */
     readonly receiverTyping: number;
     /**
-     * Symbols on the far side of a dispatch boundary that the traversal could not
-     * attribute to the queried symbol: implementations plus interface-level
-     * consumers, summed over the boundary nodes that were flagged.
+     * Symbols on or beyond a dispatch boundary that the traversal could not
+     * attribute statically: implementations plus interface-level consumers.
      *
      * Unit: SYMBOLS, not call sites — deliberately, because a call-site count is
      * not derivable on this side. The graph does not retain per-site multiplicity
@@ -106,6 +105,10 @@ export interface EpistemicCauses {
      * symbol reachable through two flagged boundary nodes is counted once per
      * node, so this is itself a lower bound.
      *
+     * Framework runtime-proxy metadata can prove that impact is incomplete but
+     * cannot provide this magnitude, so it contributes a boundary note while
+     * leaving this count unchanged.
+     *
      * It is still directly comparable in magnitude with `receiverTyping` — both
      * answer "how much is missing" — which `boundaries.length` was not.
      */

package/dist/mcp/local/local-backend.js

@@ -11,6 +11,7 @@ import { createHash } from 'crypto';
 import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, statDbIdentity, dbIdentityChanged, } from '../../core/lbug/pool-adapter.js';
 import { queryClassBeanMetadata } from './bean-metadata.js';
 import { querySpringAopMetadata } from './aop-metadata.js';
+import { queryConvexDispatchMetadata } from './convex-metadata.js';
 import { isValidQueryParams } from '../../core/lbug/query-params.js';
 import { toDisplayLine } from './line-display.js';
 import { LBUG_ID_PROBE_BATCH_SIZE, LBUG_QUERY_BATCH_SIZE } from '../../core/lbug/query-batch.js';
@@ -464,7 +465,7 @@ function epistemicFrom(dropped) {
                 epistemic: 'exact',
                 causes: {
                     receiverTyping: 0,
-                    dispatchBoundary: 0,
+                    dispatchBoundary: dropped.dispatch,
                     externalBoundary: dropped.external,
                     undecidedSatisfaction: 0,
                 },
@@ -479,7 +480,7 @@ function epistemicFrom(dropped) {
             // would read a different magnitude than the human reading the text.
             causes: {
                 receiverTyping: dropped.sites,
-                dispatchBoundary: 0,
+                dispatchBoundary: dropped.dispatch,
                 externalBoundary: dropped.external,
                 undecidedSatisfaction: dropped.undecided,
             },
@@ -5524,7 +5525,7 @@ export class LocalBackend {
         this.crossLanguagePropertyCache.set(repo.lbugPath, { indexedAt: repo.indexedAt, byName });
         return byName;
     }
-    async computeEpistemicBoundary(repo, symId, symType, symName) {
+    async computeEpistemicBoundary(repo, symId, symType, symName, direction) {
         const HERITAGE_TYPES = EPISTEMIC_HERITAGE_RELATION_TYPES;
         const CONSUMER_TYPES = EPISTEMIC_CONSUMER_RELATION_TYPES;
         // #2744 — call sites dropped for want of a receiver type. Checked BEFORE
@@ -5557,6 +5558,14 @@ export class LocalBackend {
         // the owning-type hop below would be a graph round-trip per method query in
         // every index that has no such record — which is every non-Go one, since Go
         // is the only language with a structural-satisfaction hook.
+        const convexDispatchPromise = direction === 'downstream'
+            ? Promise.resolve(undefined)
+            : queryConvexDispatchMetadata(repo.lbugPath, symId, symName, symType);
+        const interfaceRowsPromise = executeParameterized(repo.lbugPath, `MATCH (x)-[r:CodeRelation]->(iface)
+       WHERE x.id = $symId AND r.type IN $heritage
+       RETURN DISTINCT iface.id AS id, iface.name AS name, labels(iface)[0] AS label
+       ORDER BY id
+       LIMIT 25`, { symId, heritage: HERITAGE_TYPES }).catch(() => []);
         const undecidedSummary = meta?.undecidedInterfaceSatisfaction;
         const undecidedDrops = undecidedSummary === undefined
             ? { notes: [], undecided: 0 }
@@ -5566,10 +5575,19 @@ export class LocalBackend {
                     ? await this.owningTypeNames(repo, symId)
                     : []),
             ]);
+        const convexDispatch = await convexDispatchPromise;
         const droppedBoundaries = {
             ...receiverDrops,
-            notes: [...receiverDrops.notes, ...undecidedDrops.notes],
+            notes: [
+                ...receiverDrops.notes,
+                ...undecidedDrops.notes,
+                ...(convexDispatch === undefined ? [] : [convexDispatch.boundary]),
+            ],
             undecided: undecidedDrops.undecided,
+            // Endpoint/probe evidence proves incompleteness but does not expose a
+            // count of omitted symbols. Keep the magnitude at zero rather than
+            // inventing one from the presence of a note.
+            dispatch: 0,
         };
         try {
             // Discover the interface / abstract supertypes on the target's boundary.
@@ -5578,11 +5596,7 @@ export class LocalBackend {
             if (symType === 'Interface') {
                 boundary.set(symId, { name: symName || '', label: 'Interface' });
             }
-            const ifaceRows = await executeParameterized(repo.lbugPath, `MATCH (x)-[r:CodeRelation]->(iface)
-         WHERE x.id = $symId AND r.type IN $heritage
-         RETURN DISTINCT iface.id AS id, iface.name AS name, labels(iface)[0] AS label
-         ORDER BY id
-         LIMIT 25`, { symId, heritage: HERITAGE_TYPES }).catch(() => []);
+            const ifaceRows = await interfaceRowsPromise;
             for (const r of ifaceRows) {
                 const id = (r.id ?? r[0]);
                 if (id && !boundary.has(id)) {
@@ -5650,7 +5664,7 @@ export class LocalBackend {
                 boundaries: [...droppedBoundaries.notes, ...boundaries],
                 causes: {
                     receiverTyping: droppedBoundaries.sites,
-                    dispatchBoundary: dispatchBoundarySymbols,
+                    dispatchBoundary: droppedBoundaries.dispatch + dispatchBoundarySymbols,
                     externalBoundary: droppedBoundaries.external,
                     undecidedSatisfaction: droppedBoundaries.undecided,
                 },
@@ -5713,7 +5727,7 @@ export class LocalBackend {
         // so every consumer would be reading a field the compiler says is absent.
         const epistemicPromise = opts.skipEpistemic
             ? Promise.resolve({})
-            : this.computeEpistemicBoundary(repo, symId, symType, (sym.name || sym[1]));
+            : this.computeEpistemicBoundary(repo, symId, symType, (sym.name || sym[1]), direction);
         const beanMetadataPromise = opts.skipEpistemic || summaryOnly
             ? Promise.resolve(undefined)
             : queryClassBeanMetadata(repo.lbugPath, symId, symType);

package/dist/mcp/tools.js

@@ -251,9 +251,10 @@ COMPLETENESS OF incoming: alongside symbol/incoming/outgoing the result carries
 - causes: { receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — machine-readable WHY. Every field counts MISSING THINGS, never sentences:
   - causes.receiverTyping (unit: call sites) > 0 — RESOLVER GAP: the analyzer dropped that many call sites on this name because it could not type the receiver, so they are missing from incoming. Do not read an absent caller as proof none exists.
   - causes.externalBoundary (unit: call sites) > 0 — the calls left the indexed program (System.out.println, fetch(...)). NOT a defect: no in-graph node could have been reached. An epistemic:'exact' result can carry this.
-  - causes.dispatchBoundary (unit: symbols) > 0 — DI / interface dispatch: implementations plus interface-level consumers behind a boundary static analysis cannot cross. Irreducible.
+  - causes.dispatchBoundary (unit: symbols) > 0 — DI or interface dispatch: that many symbols sit on or beyond a boundary static analysis cannot cross. Irreducible. A symbol count, not a site count — per-site multiplicity is not retained for these edges — so compare its magnitude with receiverTyping, not its exact value. A framework runtime-proxy boundary can make epistemic lower-bound while this value remains 0 because endpoint metadata proves the gap but cannot count omitted symbols.
+  - causes.undecidedSatisfaction (unit: unjudged interface/type pairs) > 0 — the analyzer could not decide whether a type satisfies an interface, so no IMPLEMENTS edge exists and no dispatch boundary was left for the walk to notice. Usually fixable by making the missing dependency available to analysis.
 
-REQUIRES RE-INDEX: causes.receiverTyping and causes.externalBoundary come from index-time metadata only a current analyzer writes; against an older index they read as absent/0, which is indistinguishable from "nothing was dropped". Re-run \`gitnexus analyze\` before trusting a zero there.
+REQUIRES RE-INDEX: causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
 
 GROUP MODE: set "repo" to "@<groupName>" to run context in each member repo (aggregated list), or "@<groupName>/<groupRepoPath>" for one member. If you use "@<groupName>" only, the member defaults to the lexicographically first key in group.yaml "repos".
 
@@ -440,11 +441,11 @@ Output includes:
 - causes: { receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — the machine-readable split of WHY, so an agent gating its own edits can tell a fixable analyzer gap from an irreducible one. Every field counts MISSING THINGS, never sentences:
   - causes.receiverTyping (unit: call sites) > 0 — the RESOLVER GAP signal: the analyzer dropped that many call sites because it could not establish the receiver's type (unresolved constructor, factory, chained expression). Those callers are absent from byDepth. Treat the result as incomplete: grep the symbol name before deleting or renaming.
   - causes.externalBoundary (unit: call sites) > 0 — those calls left the indexed program (System.out.println, fetch(...), os.environ.*). NOT a defect and NOT a reason the count is short: there is no in-graph node any edge could have reached. An epistemic:'exact' result can carry this.
-  - causes.dispatchBoundary (unit: symbols) > 0 — DI / interface dispatch: that many implementations plus interface-level consumers sit on the far side of a boundary a static walk cannot cross. Irreducible; a compiler refuses here too. A symbol count, not a site count — per-site multiplicity is not retained for these edges — so compare its magnitude with receiverTyping, not its exact value.
+  - causes.dispatchBoundary (unit: symbols) > 0 — DI or interface dispatch: that many symbols sit on or beyond a boundary a static walk cannot cross. Irreducible. A symbol count, not a site count — per-site multiplicity is not retained for these edges — so compare its magnitude with receiverTyping, not its exact value. A framework runtime-proxy boundary can make epistemic lower-bound while this value remains 0 because endpoint metadata proves the gap but cannot count omitted symbols.
 
   - causes.undecidedSatisfaction (unit: unjudged interface/type pairs) > 0 — the analyzer could not DECIDE whether a type satisfies an interface (a type in a required signature named a package it could not resolve), so no IMPLEMENTS edge exists and no dispatch boundary was left for the walk to notice. Distinct from every cause above, which count decided facts that could not be attributed; this one counts questions never answered. It is the only cause that shortens a result WITHOUT leaving a trace in the graph, so an unhedged zero on a symbol reached only through such an interface would otherwise read as 'nobody calls this'. Usually fixable: it most often means a dependency is missing from the analyzed tree.
 
-REQUIRES RE-INDEX: causes.receiverTyping, causes.externalBoundary and causes.undecidedSatisfaction are read from index-time metadata that only a current analyzer writes. Against an older index they read as absent/0, which is indistinguishable from "nothing was dropped" — re-run \`gitnexus analyze\` before trusting a zero there.
+REQUIRES RE-INDEX: causes.receiverTyping, causes.externalBoundary, causes.undecidedSatisfaction, and framework runtime-proxy boundary detection depend on index-time metadata that only a current analyzer writes. Against an older index the metadata can be absent, which is indistinguishable from "nothing was dropped" unless the schema probe detects the stale index — re-run \`gitnexus analyze\` before trusting a zero or an apparently exact result.
 
 Depth groups:
 - d=1: WILL BREAK (direct callers/importers)

package/dist/storage/parse-cache.js

@@ -564,7 +564,16 @@ import { fileURLToPath } from 'url';
 // IN-FLIGHT claim, not above origin/main. Every open PR touching gitnexus/ was
 // scanned; #3017 is the only other claimant.
 // RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
-const SCHEMA_BUMP = 72;
+//
+// 72 -> 74 adds import-proven Convex endpoint metadata to Const/Function worker
+// output. A warm v72 cache has no convexEndpointFactory property, so the MCP
+// impact probe would keep claiming exact results for unchanged endpoints. The
+// parse-cache bump makes unchanged files re-parse; analyzer runner identity
+// drift separately forces the graph re-emit (run-analyze.ts), and an id/schema
+// migration needs both guarantees. Version 73 is intentionally skipped because
+// concurrent PR #3046 (fixes #3041) claims it. Re-check main and open PRs
+// immediately before merge.
+const SCHEMA_BUMP = 74;
 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.10-rc.219",
+  "version": "1.6.10-rc.220",
   "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",