@aroman22/codegraph-vba 1.6.1 → 1.6.2

package/dist/db/migrations.d.ts

@@ -7,7 +7,7 @@ import { SqliteDatabase } from './sqlite-adapter';
 /**
  * Current schema version
  */
-export declare const CURRENT_SCHEMA_VERSION = 9;
+export declare const CURRENT_SCHEMA_VERSION = 10;
 /**
  * Migration definition
  */

package/dist/extraction/grammars.d.ts

@@ -57,6 +57,38 @@ export declare function isPlayRoutesFile(filePath: string): boolean;
  * are all treated as non-VBA — Dysflow always writes the `.txt` suffix.
  */
 export declare function detectVbaFormFile(filePath: string): boolean;
+/**
+ * Dysflow VBA test manifests: `tests(.<slice>)*.json` (e.g. `tests.json`,
+ * `tests.vba.smoke.json`). Recognized by basename only — the content-shape gate
+ * (a top-level `tests` array of `{procedure}`) is applied inside
+ * `VbaTestManifestExtractor`, so `package.json` / `tsconfig.json` are excluded
+ * here and unrelated `tests.*.json` files emit nothing at extraction.
+ *
+ * `.json` is deliberately NOT in `EXTENSION_MAP` (ordinary JSON is not indexed);
+ * this is the sole gate that makes a manifest an indexable source file, mirroring
+ * the `.sql`/`queries.json` gate for `SqlQueryExtractor`.
+ */
+export declare function isVbaTestManifestFile(filePath: string): boolean;
+/**
+ * Dysflow VBA test-sequence file (`<root>/sequences/*.json`, e.g.
+ * `tests/sequences/cache-riesgo.json`). SUB-6 of epic #91. The path-detection
+ * gate is directory-based — a `.json` file anywhere under a `sequences/`
+ * directory — because the basename does not have to start with `tests`
+ * (a leaf-test file `tests.vba.cache-riesgo.json` is NOT a sequence; a
+ * `tests/sequences/cache-riesgo.json` IS).
+ *
+ * Disjoint from `isVbaTestManifestFile`:
+ *  - `isVbaTestManifestFile('tests/tests.vba.smoke.json')` → true
+ *  - `isVbaTestSequenceFile('tests/sequences/cache-riesgo.json')` → true
+ *  - `isVbaTestSequenceFile('tests/tests.vba.smoke.json')` → false
+ * The basename regex on the manifest gate (`^tests(.[\w-]+)*.json$`) does
+ * NOT match `cache-riesgo.json`, so the two detectors do not overlap. The
+ * content-shape gate inside `VbaTestSequenceExtractor` further rejects the
+ * `executionUnits` (strict-sequence) and `slices[]` (slices) shapes — both
+ * of which live at `tests/`, NOT under `sequences/`, and so are excluded
+ * from this extractor even if a future file slips into the same directory.
+ */
+export declare function isVbaTestSequenceFile(filePath: string): boolean;
 /**
  * Initialize the tree-sitter WASM runtime. Must be called before loading grammars.
  * Does NOT load any grammar WASM files — use loadGrammarsForLanguages() for that.

package/dist/extraction/vba/call-sweep.d.ts

@@ -1,3 +1,15 @@
-import { VbaExtractorContext } from './context';
+import { VbaExtractorContext, VbaClassifier } from './context';
+/**
+ * Issue #83: factory for the calls/SQL classifier. The factory takes the
+ * pre-split `lines` array (so `trackSqlVariableAssignment` can do its
+ * multi-line look-ahead for `&`-accumulate semantics) and closes over the
+ * per-file state the legacy `sweepCallsAndSql` declared locally.
+ */
+export declare function createCallsAndSqlClassifier(lines: readonly string[]): VbaClassifier;
+/**
+ * Backward-compat wrapper (see procedures.ts). Returns void — the calls
+ * sweep never contributed to `hasAnySymbols` directly (every other
+ * concern's `count` is the signal the orchestrator reads).
+ */
 export declare function sweepCallsAndSql(ctx: VbaExtractorContext, src: string): void;
 //# sourceMappingURL=call-sweep.d.ts.map

package/dist/extraction/vba/context.d.ts

@@ -19,6 +19,29 @@ export interface ProcInfo {
     visibility: 'public' | 'private' | 'protected' | 'internal';
     startLine: number;
 }
+/**
+ * Issue #83: the per-concern classifier shape. The single walker in
+ * `vba-extractor.ts` calls `classifyLine(line, index, ctx)` once per
+ * pre-split line, in a stable order across all six concerns. No internal
+ * `.split('\n')` — the split happens once in the walker.
+ */
+export interface VbaClassifier {
+    /** Stable, human-readable name for logs/metrics. */
+    readonly name: string;
+    /**
+     * Number of top-level symbols this classifier emitted. Read by the
+     * orchestrator to compute `hasAnySymbols` (skip module-node creation
+     * for files with NO symbols per REQ-CODE-10).
+     */
+    count: number;
+    /** Classify one pre-split line. May mutate `ctx` and bump `count`. */
+    classifyLine(line: string, index: number, ctx: VbaExtractorContext): void;
+    /**
+     * Optional end-of-file hook. Used by the calls-and-sql classifier to
+     * flush `procEndLines` → function node `endLine`.
+     */
+    finalize?(ctx: VbaExtractorContext): void;
+}
 export declare class VbaExtractorContext {
     filePath: string;
     nodes: Node[];
@@ -44,6 +67,14 @@ export declare class VbaExtractorContext {
      * Let Foo`, and `Property Set Foo` all share the name `Foo`.
      */
     localProcs: Map<string, ProcInfo[]>;
+    /**
+     * Issue #83: flat list of every `ProcInfo` produced by the procedures
+     * classifier, in declaration order. Mirrors the array the legacy
+     * `sweepProcedures` returned; the orchestrator reads it after the single
+     * walker pass to (a) decide `hasAnySymbols`, and (b) check for a
+     * `New` initializer to set `hasClassInitializer` on the class node.
+     */
+    procedures: ProcInfo[];
     /**
      * Cache: procedure name → first matching function node emitted for that
      * name (audit S2 — O(1) same-file call resolution).
@@ -114,6 +145,17 @@ export declare class VbaExtractorContext {
     procStack: number[];
     /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
     localEvents: Map<string, Node>;
+    /**
+     * Same-file function/property return types, keyed by lowercase proc name →
+     * declared return type. ONLY non-primitive (project-class) return types are
+     * stored. Populated by `sweepProcedures` (which runs before the call sweep);
+     * consumed by the call sweep's `Set x = Factory(...)` handling to type the
+     * assigned local var so a later `x.Method` qualified call resolves to the
+     * factory's class instead of a dead-end `x.Method` stub. Cross-file
+     * factories are not covered here (no return type is visible at extraction
+     * time) — that stays the resolver's frontier.
+     */
+    functionReturnTypes: Map<string, string>;
     constructor(filePath: string);
     /**
      * Emit a `contains` edge from the (lazily-created) module/class node to
@@ -156,8 +198,16 @@ export declare class VbaExtractorContext {
      * node named `targetName`. Used by Dim, WithEvents, Set-New, and SQL sweeps.
      * Fix 5: the synthetic node id is keyed on (filePath, kind, name) WITHOUT
      * lineNum so the same type/table referenced on N lines produces ONE node.
-     */
-    emitReference(targetName: string, lineNum: number, column: number, synthesizedBy: string): void;
+     *
+     * `access` (optional): when a caller can classify the reference as a data
+     * read or write — SQL table references derive it from the statement verb —
+     * it is stamped onto `edge.metadata.access` so consumers can answer "who
+     * WRITES table X" vs "who READS table X". Mirrors the read/write tagging the
+     * TempVars sweep already emits (`emitTempVarReference`). Omitted for
+     * structural references (Dim/WithEvents/Set-New) where the direction is not
+     * meaningful.
+     */
+    emitReference(targetName: string, lineNum: number, column: number, synthesizedBy: string, access?: 'read' | 'write'): void;
     /**
      * Issue #52: shared lookup helper for `scanDoCmdOpenCalls` and
      * `scanDoCmdOpenQuery`. The current scope is the procedure whose

package/dist/extraction/vba/declarations.d.ts

@@ -1,3 +1,12 @@
-import { VbaExtractorContext } from './context';
+import { VbaExtractorContext, VbaClassifier } from './context';
+/**
+ * Issue #83: factory for the events/types/declares classifier. Closure
+ * state: `currentType` (the open `Type ... End Type` block).
+ */
+export declare function createEventsTypesDeclaresClassifier(): VbaClassifier;
+/**
+ * Backward-compat wrapper (see procedures.ts). Returns the classifier's
+ * `count` so the orchestrator can decide `hasAnySymbols`.
+ */
 export declare function sweepEventsTypesAndDeclares(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=declarations.d.ts.map

package/dist/extraction/vba/dims.d.ts

@@ -1,3 +1,11 @@
-import { VbaExtractorContext } from './context';
+import { VbaExtractorContext, VbaClassifier } from './context';
+/**
+ * Issue #83: factory for the Dim / WithEvents classifier. Stateless per-line.
+ */
+export declare function createDimsClassifier(): VbaClassifier;
+/**
+ * Backward-compat wrapper (see procedures.ts). Returns the classifier's
+ * `count` so the orchestrator can decide `hasAnySymbols`.
+ */
 export declare function sweepDimsAndWithEvents(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=dims.d.ts.map

package/dist/extraction/vba/enums-consts.d.ts

@@ -1,15 +1,18 @@
-import { VbaExtractorContext } from './context';
+import { VbaExtractorContext, VbaClassifier } from './context';
 /**
- * Walk the (uncommented, line-joined) source and emit:
- *  - one `enum` node per `Enum <Name>` block, with one `enum_member` node
- *    per member and a `contains` edge enum→member;
- *  - one `constant` node per name declared on a `Const` line (multi-name
- *    lines emit one node per name);
- *  - a `contains` edge from the module/class node to each enum and constant
- *    (held in `pendingModuleOrClassSource` until the module node exists).
+ * Issue #83: factory for the enum / const classifier. Closure state:
+ * `currentEnum` (open `Enum ... End Enum` block).
  *
- * Returns the number of top-level symbols (enums + constants) emitted so
- * the caller can flip `hasAnySymbols`.
+ * Also resets + advances the SHARED `ctx.procStack`/`ctx.currentProcKey`
+ * per line — same protocol the pre-#83 sweep followed. The calls-sql
+ * classifier runs AFTER this one in the per-line dispatch order and
+ * applies the same protocol, so the end-of-line scope state is identical
+ * to the legacy sequential-sweep behaviour.
+ */
+export declare function createEnumsConstsClassifier(): VbaClassifier;
+/**
+ * Backward-compat wrapper (see procedures.ts). Returns the classifier's
+ * `count` so the orchestrator can decide `hasAnySymbols`.
  */
 export declare function sweepEnumsAndConsts(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=enums-consts.d.ts.map

package/dist/extraction/vba/implements.d.ts

@@ -1,3 +1,11 @@
-import { VbaExtractorContext } from './context';
+import { VbaExtractorContext, VbaClassifier } from './context';
+/**
+ * Issue #83: factory for the `Implements` classifier. Stateless per-line.
+ */
+export declare function createImplementsClassifier(): VbaClassifier;
+/**
+ * Backward-compat wrapper (see procedures.ts). Returns the classifier's
+ * `count` so the orchestrator can decide `hasAnySymbols`.
+ */
 export declare function sweepImplements(ctx: VbaExtractorContext, src: string): number;
 //# sourceMappingURL=implements.d.ts.map

package/dist/extraction/vba/procedures.d.ts

@@ -1,3 +1,15 @@
-import { VbaExtractorContext, ProcInfo } from './context';
+import { VbaExtractorContext, ProcInfo, VbaClassifier } from './context';
+/**
+ * Issue #83: factory for the procedures classifier. Closure state: none
+ * beyond `count` (the per-concern accumulators live on `ctx`).
+ */
+export declare function createProceduresClassifier(): VbaClassifier;
+/**
+ * Backward-compat wrapper: pre-#83 callers (e.g. legacy test fixtures)
+ * used `sweepProcedures(ctx, src)` and got back the ProcInfo[].
+ * Now it returns `ctx.procedures` (the same flat list the factory
+ * appends to). The implementation still calls the classifier once per
+ * pre-split line, so the count is identical to the new walker path.
+ */
 export declare function sweepProcedures(ctx: VbaExtractorContext, src: string): ProcInfo[];
 //# sourceMappingURL=procedures.d.ts.map

package/dist/extraction/vba-test-manifest-extractor.d.ts

@@ -0,0 +1,26 @@
+import { ExtractionResult } from '../types';
+/**
+ * Content-shape gate: is `parsed` a VBA test manifest — a top-level `tests`
+ * array with at least one item carrying a string `procedure`? Pure; the file's
+ * basename is gated separately by `isVbaTestManifestFile` in `grammars.ts`.
+ */
+export declare function isVbaTestManifestShape(parsed: unknown): boolean;
+export declare class VbaTestManifestExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private unresolvedReferences;
+    private errors;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    /**
+     * One `UnresolvedReference` per `tests[]` entry carrying a string `procedure`,
+     * pointing at that procedure name. The `ReferenceResolver` (SUB-3) binds each
+     * to the existing `Test_*` `function` node — no duplicate node is emitted here.
+     * `name` defaults to the procedure name; `tags` defaults to `[]`.
+     */
+    private emitTestReferences;
+    private result;
+    private createFileNode;
+}
+//# sourceMappingURL=vba-test-manifest-extractor.d.ts.map

package/dist/extraction/vba-test-sequence-extractor.d.ts

@@ -0,0 +1,29 @@
+import { ExtractionResult } from '../types';
+/**
+ * Content-shape gate: is `parsed` a Dysflow VBA test sequence — a top-level
+ * `runnerPolicy` object AND a `procedures` array whose items are strings
+ * (possibly empty)? Pure; the file's path is gated separately by
+ * `isVbaTestSequenceFile` in `grammars.ts`.
+ *
+ * The gate accepts an EMPTY `procedures` array on purpose: an empty sequence
+ * still gets a `file` node from the extractor (so the manifest is visible in
+ * the graph) but emits zero `UnresolvedReference`s (no procedures to bind).
+ *
+ * A shape that ALSO carries an `executionUnits` or `slices[]` key (the
+ * strict-sequence / slices shapes) is rejected — those are top-level
+ * orchestration/grouping plans, not per-atom sequences.
+ */
+export declare function isVbaTestSequenceShape(parsed: unknown): boolean;
+export declare class VbaTestSequenceExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private unresolvedReferences;
+    private errors;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private emitProcedureReferences;
+    private result;
+    private createFileNode;
+}
+//# sourceMappingURL=vba-test-sequence-extractor.d.ts.map

package/dist/mcp/server-instructions.d.ts

@@ -17,7 +17,7 @@
  * tools (node/search/callers/…) stay defined and are re-enablable via
  * CODEGRAPH_MCP_TOOLS, but they are NOT listed to agents, so don't name them.
  */
-export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence over an indexed knowledge graph\n\nCodegraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## One tool: codegraph_explore \u2014 use it instead of reading files\n\nThere is a single tool, `codegraph_explore`, and it is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `codegraph_explore` before you Read. ONE call\nusually answers the whole question. Codegraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work codegraph already did and costs more\nfor the same answer. A direct codegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `codegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `codegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `codegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `codegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust codegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `codegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail codegraph didn't cover, or for what codegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `codegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust codegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F CodeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.codegraph/`), stop calling codegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `codegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. Codegraph supplements those with structural context they don't have.\n\n## Supported Languages\n\nThe indexer recognizes a fixed set of languages; if you ask about symbols in a\nfile with an unsupported extension, codegraph will report the project isn't\nindexed for that file and you should fall back to Read/Grep. The fork-specific\naddition beyond upstream codegraph is **VBA / Access** (Dysflow export\nformat):\n\n- **VBA / Access** - Dysflow exports Access/VBA source as `.bas`/`.cls`/\n  `.form.txt`/`.report.txt`. Codegraph extracts `.bas`/`.cls` as `module`/\n  `class`/`function` nodes with `calls`/`implements`/`references` edges\n  (procedural-level; regex-based, not full AST). Cross-module calls, qualified\n  `Dim As`, `WithEvents`, and SQL table references inside string literals\n  emit synthesized edges tagged `metadata.synthesizedBy` (`vba-name-resolution`,\n  `vba-withevents`, `vba-sql-table`). `.form.txt` and `.report.txt` are\n  extracted as a `module` plus one `property` per Access control - **no**\n  `function`/`sub`/`class` nodes come from form files; the canonical code\n  lives in the sibling `.cls`, parsed by the same extractor on that file.\n  Pass `projectPath` to a codegraph index that includes VBA files.\n";
+export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence over an indexed knowledge graph\n\nCodegraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## One tool: codegraph_explore \u2014 use it instead of reading files\n\nThere is a single tool, `codegraph_explore`, and it is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `codegraph_explore` before you Read. ONE call\nusually answers the whole question. Codegraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work codegraph already did and costs more\nfor the same answer. A direct codegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `codegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `codegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `codegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `codegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust codegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `codegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail codegraph didn't cover, or for what codegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `codegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust codegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F CodeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.codegraph/`), stop calling codegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `codegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. Codegraph supplements those with structural context they don't have.\n\n## Supported Languages\n\nThe indexer recognizes a fixed set of languages; if you ask about symbols in a\nfile with an unsupported extension, codegraph will report the project isn't\nindexed for that file and you should fall back to Read/Grep. The fork-specific\naddition beyond upstream codegraph is **VBA / Access** (Dysflow export\nformat):\n\n- **VBA / Access** - Dysflow exports Access/VBA source as `.bas`/`.cls`/\n  `.form.txt`/`.report.txt`. Codegraph extracts `.bas`/`.cls` as `module`/\n  `class`/`function` nodes with `calls`/`implements`/`references` edges\n  (procedural-level; regex-based, not full AST). Cross-module calls, qualified\n  `Dim As`, `WithEvents`, and SQL table references inside string literals\n  emit synthesized edges tagged `metadata.synthesizedBy` (`vba-name-resolution`,\n  `vba-withevents`, `vba-sql-table`). `.form.txt` and `.report.txt` are\n  extracted as a `module` plus one `property` per Access control - **no**\n  `function`/`sub`/`class` nodes come from form files; the canonical code\n  lives in the sibling `.cls`, parsed by the same extractor on that file.\n  Dysflow test manifests (`tests.*.json`) link each registered `Test_*`\n  procedure to its manifest with a `references` edge tagged\n  `vba-test-manifest` carrying the test name + tags, so `getCallers` of a\n  production symbol reaches its covering test atoms with the manifest and tags\n  to run.\n  Pass `projectPath` to a codegraph index that includes VBA files.\n";
 /**
  * Instructions variant sent when the server's own root has NO codegraph index.
  *

package/dist/resolution/types.d.ts

@@ -24,6 +24,13 @@ export interface UnresolvedRef {
     language: Language;
     /** Possible qualified names it might resolve to */
     candidates?: string[];
+    /**
+     * Optional extractor-specific annotations carried from the source
+     * `UnresolvedReference` (e.g. `synthesizedBy: 'vba-test-manifest'` plus its
+     * `testName`/`tags`/`manifestFile`). Preserved in-memory through resolution
+     * so `createEdges` can stamp provenance onto the resolved edge.
+     */
+    metadata?: Record<string, unknown>;
 }
 /**
  * A resolved reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aroman22/codegraph-vba",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
   "bin": {
     "codegraph-vba": "npm-shim.js"
@@ -15,12 +15,12 @@
     "./package.json": "./package.json"
   },
   "optionalDependencies": {
-    "@aroman22/codegraph-vba-darwin-arm64": "1.6.1",
-    "@aroman22/codegraph-vba-darwin-x64": "1.6.1",
-    "@aroman22/codegraph-vba-linux-arm64": "1.6.1",
-    "@aroman22/codegraph-vba-linux-x64": "1.6.1",
-    "@aroman22/codegraph-vba-win32-arm64": "1.6.1",
-    "@aroman22/codegraph-vba-win32-x64": "1.6.1"
+    "@aroman22/codegraph-vba-darwin-arm64": "1.6.2",
+    "@aroman22/codegraph-vba-darwin-x64": "1.6.2",
+    "@aroman22/codegraph-vba-linux-arm64": "1.6.2",
+    "@aroman22/codegraph-vba-linux-x64": "1.6.2",
+    "@aroman22/codegraph-vba-win32-arm64": "1.6.2",
+    "@aroman22/codegraph-vba-win32-x64": "1.6.2"
   },
   "files": [
     "npm-shim.js",