weavatrix 0.2.5 → 0.2.6

package/README.md

@@ -5,7 +5,7 @@
 Grep sees text. Weavatrix sees structure. It builds a dependency graph of any local repository —
 files, symbols, and the imports/calls/inheritance connecting them — and serves it to Claude Code,
 Codex, or any MCP client: change impact, transitive dependents, health audit, clone detection,
-coverage mapping. **34 tools available; 31 enabled by the default offline profile. Local-first: with
+coverage mapping. **35 tools available; 32 enabled by the default offline profile. Local-first: with
 the defaults, no repository data leaves your machine.**
 
 - Website: [weavatrix.com](https://weavatrix.com)
@@ -22,7 +22,8 @@ answers grep can't produce:
   depends on them — with test coverage attached, so the **untested part of the blast radius** stands
   out before you ship.
 - *"Who calls this function?"* → `inspect_symbol` returns exact bounded TS/JS occurrences plus
-  source context; `get_dependents` walks the symbol-level reverse graph transitively. Opt into
+  source context; `context_bundle` adds grouped graph relations, exact re-export sites, and a
+  smaller source workset. `get_dependents` walks the symbol-level reverse graph transitively. Opt into
   `include_container_importers:true` only when a broader module-import radius is intended.
 - *"Did my refactor actually decouple anything?"* → `graph_diff base_ref=HEAD~1` builds an immutable
   baseline graph without checking it out, then reports the structural delta: new module
@@ -110,7 +111,8 @@ An agent skill with recipes ships in [skill/SKILL.md](skill/SKILL.md) — instal
 `change_impact`, `git_history`, `graph_diff`, `get_architecture_contract`,
 `prepare_change`. Runtime dependencies, TypeScript type-only coupling and language
 compile-only edges (Rust module/use, Java imports) are reported separately where that distinction
-changes the result.
+changes the result. TypeScript type-space and value-space declarations keep distinct identities;
+classes and enums that inhabit both spaces are labelled `both`.
 
 Every current edge carries versioned provenance. The parser emits `EXTRACTED`, `RESOLVED`, and
 `INFERRED`; the built-in bounded TypeScript/JavaScript precision overlay upgrades only references
@@ -118,7 +120,7 @@ confirmed by its bundled `typescript-language-server` + TypeScript runtime to `E
 `CONFLICT` means evidence disagrees. `graph_stats` reports the provenance breakdown and the semantic
 provider's `COMPLETE`, `PARTIAL`, `UNAVAILABLE`, or `OFF` state; `OFF` means precision was explicitly
 disabled and only static evidence is active. Java and Rust language-server providers are not bundled
-in 0.2.5: their edges never become `EXACT_LSP`, even when a mixed repository reports a complete
+in 0.2.6: their edges never become `EXACT_LSP`, even when a mixed repository reports a complete
 TypeScript/JavaScript overlay.
 
 The bounded JS/TS provider is enabled by default for new graphs. Set `WEAVATRIX_PRECISION=off`
@@ -127,8 +129,9 @@ before starting the MCP server for parser-only operation from the first build, o
 choice as **TypeScript/JavaScript semantic precision**.
 
 **search / source** — `search_code` (ripgrep-backed, pure-Node fallback), `read_source` (a
-symbol's actual code in one hop), `inspect_symbol` (one exact bounded TS/JS reference query,
-logical containers, impact and source excerpts), `list_endpoints` (HTTP route inventory:
+symbol's actual code in one hop), `context_bundle` (definition plus grouped inbound/outbound
+containers, exact re-export sites and a few bounded source excerpts), `inspect_symbol` (one exact
+bounded TS/JS reference query, logical containers, impact and source excerpts), `list_endpoints` (HTTP route inventory:
 Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web …)
 
 **health** — `find_dead_code` (bounded review queue for statically unreferenced and test-only files,
@@ -193,6 +196,19 @@ disclosed instead of silently guessed; and the server **hot-reloads its watched
 modules and catalog** when those files change — other MCP helpers and analysis engines require a
 reconnect.
 
+### 0.2.6 compact-context and TypeScript identity patch
+
+- New `context_bundle` turns a symbol into a bounded workset: definition, grouped inbound/outbound
+  containers, reference evidence, exact re-export locations and a small number of source excerpts.
+- Re-export records retain their concrete file, line, alias, specifier, type-only flag and resolved
+  origin. Barrel propagation through `export *` stays exact and private declarations are not exposed.
+- TypeScript interfaces and type aliases are first-class type-space nodes. Same-named runtime values
+  keep separate identities, while classes and enums are explicitly marked as inhabiting both spaces.
+- Graph schema v5 and freshness gates rebuild older caches before these precision-sensitive results
+  are used. The changes remain local-only and add no runtime dependency.
+
+Full patch notes: [docs/releases/v0.2.6.md](docs/releases/v0.2.6.md).
+
 ### 0.2.5 exact-symbol and graph-fidelity patch
 
 - New `inspect_symbol` spends a bounded LSP query on one requested TS/JS declaration, groups exact

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "type": "module",
   "description": "Weavatrix — code graph & blast-radius MCP server for AI coding agents: change impact, transitive dependents, health audit, duplicate detection, and coverage mapping over any local repository.",
   "author": "Sergii Ziborov <sergii.ziborov@gmail.com>",

package/skill/SKILL.md

@@ -40,13 +40,14 @@ Start from the task, not from the complete tool list:
   `get_dependents` and `read_source`.
 - **Trace an API across repositories**: `list_known_repos` -> `trace_api_contract` with an explicit
   backend and client list; inspect each `graphReconciliation.buildMode` before using the verdict.
-- **Inspect exact symbol references**: start with `graph_stats`, then call `inspect_symbol` with an
-  exact node ID (or an unambiguous label). It spends a bounded point query beyond the broad overlay
-  cap and returns occurrence containers plus source context. Use `get_dependents` for transitive
+- **Inspect exact symbol references**: start with `graph_stats`, then call `context_bundle` with an
+  exact node ID (or an unambiguous label) for a compact definition, grouped relations, exact
+  re-export sites and source workset. Use `inspect_symbol` when the raw bounded point query is needed;
+  it spends evidence beyond the broad overlay cap. Use `get_dependents` for transitive
   graph impact and `find_dead_code` for bounded zero-reference
   candidates. Treat `PARTIAL`, `UNAVAILABLE`, `OFF`, or zero exact edges as incomplete evidence, not
   a compiler-exact result; `OFF` means the caller explicitly selected static-only mode. Java and Rust
-  providers are not bundled in 0.2.5, so their edges never become `EXACT_LSP` even when a mixed
+  providers are not bundled in 0.2.6, so their edges never become `EXACT_LSP` even when a mixed
   repository has a complete TypeScript/JavaScript overlay.
 - **Explore an architectural question**: use broad `query_graph` when entry points are unknown; its
   bootstrap/tool-execution ranking prefers production executables over docs, sites and fixtures.

package/src/analysis/graph-analysis.aggregate.js

@@ -63,7 +63,9 @@ export function aggregateGraph(graph, repoRoot) {
         line: String(node.source_location || "").replace(/^L/, ""),
         endLine: String(node.source_end || "").replace(/^L/, ""),
         ...(node.complexity ? { complexity: node.complexity } : {}),
-        ...(node.decorated ? { decorated: true } : {})
+        ...(node.decorated ? { decorated: true } : {}),
+        ...(node.symbol_kind ? {symbolKind: node.symbol_kind} : {}),
+        ...(node.symbol_space ? {symbolSpace: node.symbol_space} : {})
       });
       fileSymbols.set(fid, list);
     }

package/src/analysis/graph-analysis.refs.js

@@ -63,7 +63,7 @@ function importCandidates(fromFile, spec) {
 function stripModuleStatements(text) {
   return String(text || "")
     .replace(/\bimport\s+[\s\S]*?\s+from\s*['"][^'"]+['"]\s*;?/g, "")
-    .replace(/\bexport\s+\{[\s\S]*?\}\s+from\s*['"][^'"]+['"]\s*;?/g, "")
+    .replace(/\bexport\s+(?:type\s+)?\{[\s\S]*?\}\s+from\s*['"][^'"]+['"]\s*;?/g, "")
     .replace(/\b(?:const|let|var)\s+\{[\s\S]*?\}\s*=\s*require\(\s*['"][^'"]+['"]\s*\)\s*;?/g, "");
 }
 
@@ -73,8 +73,10 @@ function parseNamedSpecifiers(raw) {
     .map((part) => part.trim())
     .filter(Boolean)
     .map((part) => {
-      const m = part.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
-      return m ? { imported: m[1], local: m[2] || m[1] } : null;
+      const typeOnly = /^type\s+/.test(part);
+      const clean = part.replace(/^type\s+/, "").trim();
+      const m = clean.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+      return m ? { imported: m[1], local: m[2] || m[1], typeOnly } : null;
     })
     .filter(Boolean);
 }
@@ -93,17 +95,20 @@ export function computeSymbolExternalRefs(filePath, fileSymbols, fileText) {
       const name = bareSymbolName(sym.label);
       if (!isIdentifierName(name)) continue;
       const ids = byName.get(name) || [];
-      ids.push(sym.id);
+      ids.push({id: sym.id, space: sym.symbolSpace || "value"});
       byName.set(name, ids);
     }
     symbolIdsByFileAndName.set(fid, byName);
   }
 
   const symbolExternalRefs = new Map();
-  const addExternalRefs = (targetFid, importedName, refs) => {
+  const addExternalRefs = (targetFid, importedName, refs, typeOnly = false) => {
     if (!targetFid || refs <= 0 || !isIdentifierName(importedName)) return;
     const ids = symbolIdsByFileAndName.get(targetFid)?.get(importedName) || [];
-    for (const id of ids) symbolExternalRefs.set(id, (symbolExternalRefs.get(id) || 0) + refs);
+    for (const entry of ids) {
+      const matches = entry.space === "both" || (typeOnly ? entry.space === "type" : entry.space !== "type");
+      if (matches) symbolExternalRefs.set(entry.id, (symbolExternalRefs.get(entry.id) || 0) + refs);
+    }
   };
   const resolveImportedFid = (fromPath, spec) => {
     for (const candidate of importCandidates(fromPath, spec)) {
@@ -123,18 +128,21 @@ export function computeSymbolExternalRefs(filePath, fileSymbols, fileText) {
       if (!targetFid) continue;
       const named = String(m[1] || "").match(/\{([\s\S]*?)\}/);
       if (named) {
-        for (const spec of parseNamedSpecifiers(named[1])) addExternalRefs(targetFid, spec.imported, countIdentifierInText(scrubbed, spec.local));
+        const statementTypeOnly = /^\s*type\b/.test(String(m[1] || ""));
+        for (const spec of parseNamedSpecifiers(named[1])) addExternalRefs(targetFid, spec.imported, countIdentifierInText(scrubbed, spec.local), statementTypeOnly || spec.typeOnly);
       }
       const ns = String(m[1] || "").match(/\*\s+as\s+([A-Za-z_$][\w$]*)/);
       if (ns) {
         const byName = symbolIdsByFileAndName.get(targetFid) || new Map();
-        for (const name of byName.keys()) addExternalRefs(targetFid, name, countMemberAccess(scrubbed, ns[1], name));
+        const statementTypeOnly = /^\s*type\b/.test(String(m[1] || ""));
+        for (const name of byName.keys()) addExternalRefs(targetFid, name, countMemberAccess(scrubbed, ns[1], name), statementTypeOnly);
       }
     }
-    for (const m of String(txt).matchAll(/\bexport\s+\{([\s\S]*?)\}\s+from\s*['"]([^'"]+)['"]\s*;?/g)) {
-      const targetFid = resolveImportedFid(importerPath, m[2]);
+    for (const m of String(txt).matchAll(/\bexport\s+(type\s+)?\{([\s\S]*?)\}\s+from\s*['"]([^'"]+)['"]\s*;?/g)) {
+      const targetFid = resolveImportedFid(importerPath, m[3]);
       if (!targetFid) continue;
-      for (const spec of parseNamedSpecifiers(m[1])) addExternalRefs(targetFid, spec.imported, 1);
+      const statementTypeOnly = Boolean(m[1]);
+      for (const spec of parseNamedSpecifiers(m[2])) addExternalRefs(targetFid, spec.imported, 1, statementTypeOnly || spec.typeOnly);
     }
     for (const m of String(txt).matchAll(/\b(?:const|let|var)\s+\{([\s\S]*?)\}\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)\s*;?/g)) {
       const targetFid = resolveImportedFid(importerPath, m[2]);

package/src/bounds.js

@@ -0,0 +1,4 @@
+export function boundedInteger(value, fallback, minimum, maximum) {
+  const number = Number(value);
+  return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback));
+}

package/src/graph/builder/lang-js.js

@@ -14,6 +14,10 @@ const TOPVARS = `
   (program (variable_declaration (variable_declarator) @decl))
   (program (export_statement (lexical_declaration (variable_declarator) @decl)))
   (program (export_statement (variable_declaration (variable_declarator) @decl)))`;
+const TYPES = `
+  (interface_declaration name: (_) @interface)
+  (type_alias_declaration name: (_) @type)
+  (enum_declaration name: (_) @enum)`;
 const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`;
 
 function parseExportSpecifiers(raw) {
@@ -95,7 +99,13 @@ export default {
         sourceNode: cap.node.parent,
         selectionNode: cap.node,
         ...(exportStatement ? { exported: true } : {}),
-        ...(isMethod ? methodMetadata(cap.node) : { symbolKind: cap.name === "class" ? "class" : "function", moduleDeclaration: isModuleDeclaration(cap.node) })
+        ...(isMethod
+          ? {...methodMetadata(cap.node), symbolSpace: "value"}
+          : {
+              symbolKind: cap.name === "class" ? "class" : "function",
+              symbolSpace: cap.name === "class" ? "both" : "value",
+              moduleDeclaration: isModuleDeclaration(cap.node),
+            })
       });
       if (exportStatement) {
         recordJsExport({
@@ -103,6 +113,7 @@ export default {
           exported: /^\s*export\s+default\b/.test(exportStatement.text) ? "default" : cap.node.text,
           local: cap.node.text,
           typeOnly: false,
+          line: exportStatement.startPosition.row + 1,
         });
       }
     }
@@ -115,9 +126,40 @@ export default {
         selectionNode: nameNode,
         ...(exported ? { exported: true } : {}),
         symbolKind: "variable",
+        symbolSpace: "value",
         moduleDeclaration: true
       });
-      if (exported) recordJsExport({ kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false });
+      if (exported) recordJsExport({
+        kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false,
+        line: exportStatementOf(cap.node)?.startPosition.row + 1 || nameNode.startPosition.row + 1,
+      });
+    }
+
+    // TypeScript has separate type and value namespaces. Keep interface/type declarations as
+    // first-class type-space nodes instead of folding them into a same-named runtime declaration.
+    // Enums and classes intentionally occupy both spaces because TypeScript emits runtime values.
+    if (grammar !== "javascript") for (const cap of caps(grammar, TYPES, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      const exportStatement = exportStatementOf(cap.node);
+      const symbolKind = cap.name === "interface" ? "interface" : cap.name === "type" ? "type" : "enum";
+      const symbolSpace = cap.name === "enum" ? "both" : "type";
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        idSuffix: symbolSpace === "type" ? ":type" : "",
+        ...(exportStatement ? {exported: true} : {}),
+        symbolKind,
+        symbolSpace,
+        moduleDeclaration: isModuleDeclaration(cap.node),
+      });
+      if (exportStatement) recordJsExport({
+        kind: "local",
+        exported: cap.node.text,
+        local: cap.node.text,
+        typeOnly: symbolSpace === "type",
+        line: exportStatement.startPosition.row + 1,
+        symbolSpace,
+      });
     }
 
     const importTypeOnly = (node) => {
@@ -218,12 +260,12 @@ export default {
         const namespace = text.match(/^export\s+(type\s+)?\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
         const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}\s+from\b/);
         if (namespace) {
-          recordJsExport({ kind: "namespace", exported: namespace[2], targetFile: tgt, typeOnly: !!namespace[1] });
+          recordJsExport({ kind: "namespace", exported: namespace[2], imported: "*", targetFile: tgt, typeOnly: !!namespace[1], line, specifier: rawSpec });
         } else if (star) {
-          recordJsExport({ kind: "star", targetFile: tgt, typeOnly: !!star[1] });
+          recordJsExport({ kind: "star", exported: "*", imported: "*", targetFile: tgt, typeOnly: !!star[1], line, specifier: rawSpec });
         } else if (clause) {
           for (const spec of parseExportSpecifiers(clause[2])) {
-            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly });
+            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly, line, specifier: rawSpec });
           }
         }
       }
@@ -239,26 +281,19 @@ export default {
       const text = node.text.trim();
       const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}/);
       if (clause) for (const spec of parseExportSpecifiers(clause[2])) {
-        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly });
+        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly, line: node.startPosition.row + 1 });
       }
       const identifierDefault = text.match(/^export\s+default\s+([A-Za-z_$][\w$]*)\s*;?$/);
-      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false });
-      const typedDeclaration = text.match(/^export\s+(?:declare\s+)?(type|interface|enum)\s+([A-Za-z_$][\w$]*)\b/);
-      if (typedDeclaration) recordJsExport({
-        kind: "local",
-        exported: typedDeclaration[2],
-        local: typedDeclaration[2],
-        typeOnly: typedDeclaration[1] !== "enum",
-      });
+      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false, line: node.startPosition.row + 1 });
       const defaultValue = field(node, "value");
       if (defaultValue?.type === "object") {
         // Service facades commonly expose local helpers through `export default { getSchema,
         // save: persist }`. Record the public member -> local binding instead of treating the
         // object as an opaque default export.
-        recordJsExport({kind: "facade-root", exported: "default", local: "default", typeOnly: false});
+        recordJsExport({kind: "facade-root", exported: "default", local: "default", typeOnly: false, line: node.startPosition.row + 1});
         for (const property of defaultValue.namedChildren || []) {
           if (["shorthand_property_identifier", "shorthand_property_identifier_pattern"].includes(property.type)) {
-            recordJsExport({kind: "facade-member", member: property.text, local: property.text, typeOnly: false});
+            recordJsExport({kind: "facade-member", member: property.text, local: property.text, typeOnly: false, line: node.startPosition.row + 1});
             markExported(property.text);
             continue;
           }
@@ -268,7 +303,7 @@ export default {
           if (!key || value?.type !== "identifier") continue;
           const member = key.text.replace(/^['"`]|['"`]$/g, "");
           if (!/^[A-Za-z_$][\w$]*$/.test(member)) continue;
-          recordJsExport({kind: "facade-member", member, local: value.text, typeOnly: false});
+          recordJsExport({kind: "facade-member", member, local: value.text, typeOnly: false, line: node.startPosition.row + 1});
           markExported(value.text);
         }
       }

package/src/graph/freshness-probe.js

@@ -9,7 +9,7 @@ import {childProcessEnv} from '../child-env.js'
 import {createRepoBoundary} from '../repo-path.js'
 
 export const REPOSITORY_FRESHNESS_PROBE_V = 1
-export const GRAPH_BUILDER_SCHEMA_V = 4
+export const GRAPH_BUILDER_SCHEMA_V = 5
 export const GRAPH_BUILDER_VERSION = (() => {
     try { return String(createRequire(import.meta.url)('../../package.json').version) }
     catch { return '0.0.0' }
@@ -25,7 +25,9 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 4,
+    reExportOccurrencesV: 1,
+    symbolSpacesV: 1,
+    extractorSchemaV: 5,
 })
 const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
 const MAX_CONTROL_BYTES = 1_000_000

package/src/graph/incremental-refresh.js

@@ -157,12 +157,13 @@ function mergeScopedGraph(base, scoped, affected, snapshot) {
     links,
     externalImports,
     jsExportRecords: scoped.jsExportRecords || base.jsExportRecords || {},
+    reExportOccurrences: scoped.reExportOccurrences || base.reExportOccurrences || [],
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,
     controlHashes: snapshot.controlHashes,
     graphRevision: snapshot.revision,
   };
-  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "extractorSchemaV"]) {
+  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
     merged[key] = Math.max(Number(base[key]) || 0, Number(scoped[key]) || 0);
   }
   return merged;
@@ -183,7 +184,8 @@ export async function refreshGraphIncrementally(repoDir, existingGraph, {
 
   if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
     || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
-    || Number(existingGraph.extractorSchemaV) < 4 || Number(existingGraph.edgeProvenanceV) < 1) {
+    || Number(existingGraph.extractorSchemaV) < 5 || Number(existingGraph.reExportOccurrencesV) < 1
+    || Number(existingGraph.symbolSpacesV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
     return full("incremental-baseline-unavailable");
   }
   if (!sameRecord(existingGraph.controlHashes, snapshot.controlHashes)) return full("ignore-or-control-config-changed");

package/src/graph/internal-builder.barrels.js

@@ -28,7 +28,7 @@ function withTypeOnly(result, typeOnly) {
   return resolved(result.origin.file, result.origin.name, true);
 }
 
-export function resolveJsBarrels({ jsExports, importedLocals, links }) {
+export function resolveJsBarrels({ jsExports, importedLocals, links, resolveSymbol = () => null }) {
   const tables = new Map();
   for (const [file, records] of jsExports) {
     const table = { explicit: new Map(), stars: [], facadeMembers: new Map() };
@@ -111,6 +111,43 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     }));
   };
 
+  // Materialize source-free, occurrence-level re-export evidence. Named/local alias records retain
+  // their exact public name and final declaration origin; wildcard/namespace records retain the
+  // concrete facade statement and target for on-demand propagation in context tools.
+  const reExportOccurrences = [];
+  for (const [file, records] of jsExports) for (const record of records || []) {
+    if (["facade-root", "facade-member"].includes(record.kind)) continue;
+    const resolution = record.kind === "star" || !record.exported
+      ? MISSING
+      : resolveExport(file, record.exported);
+    if (resolution.status === "resolved") {
+      record.originFile = resolution.origin.file;
+      record.originName = resolution.origin.name;
+      record.originTypeOnly = resolution.origin.typeOnly === true;
+      record.originId = resolveSymbol(resolution.origin.file, resolution.origin.name, resolution.origin.typeOnly === true) || null;
+    }
+    const reExportedLocal = record.kind === "local" && resolution.status === "resolved" && resolution.origin.file !== file;
+    if (!record.targetFile && !reExportedLocal) continue;
+    reExportOccurrences.push({
+      file,
+      line: Number(record.line) || 1,
+      kind: record.kind,
+      exported: record.exported || record.member || "*",
+      imported: record.imported || record.local || "*",
+      targetFile: record.targetFile || resolution.origin?.file || file,
+      typeOnly: record.typeOnly === true || resolution.origin?.typeOnly === true,
+      ...(record.specifier ? {specifier: record.specifier} : {}),
+      status: record.kind === "star" ? "wildcard" : resolution.status,
+      ...(resolution.status === "resolved" ? {
+        originFile: resolution.origin.file,
+        originName: resolution.origin.name,
+        ...(record.originId ? {originId: record.originId} : {}),
+      } : {}),
+    });
+  }
+  reExportOccurrences.sort((left, right) => left.file.localeCompare(right.file)
+    || left.line - right.line || left.exported.localeCompare(right.exported));
+
   // Every internal re-export is a physical facade hop. It remains in the graph for runtime cycle truth,
   // but semantic consumers ignore it in favor of importer -> declaration edges below.
   for (const link of links) {
@@ -194,5 +231,5 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
-  return { resolveExport, resolveNamespaceMember, resolveFacadeMember };
+  return { resolveExport, resolveNamespaceMember, resolveFacadeMember, reExportOccurrences };
 }

package/src/graph/internal-builder.build.js

@@ -37,6 +37,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   const addNode = (n) => { if (!nodeIds.has(n.id)) { nodeIds.add(n.id); nodes.push(n); nodeById.set(n.id, n); } };
   const perFileSymbols = new Map();
   const symByFileName = new Map();
+  const symIdsByFileName = new Map();
   const importedLocals = new Map();
   const jsExports = new Map();
   if (requestedFiles && opts.baseGraph?.jsExportRecords) {
@@ -54,6 +55,11 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       let names = symByFileName.get(file);
       if (!names) symByFileName.set(file, (names = new Map()));
       if (!names.has(match[1])) names.set(match[1], id);
+      let idsByName = symIdsByFileName.get(file);
+      if (!idsByName) symIdsByFileName.set(file, (idsByName = new Map()));
+      const ids = idsByName.get(match[1]) || [];
+      ids.push(id);
+      idsByName.set(match[1], ids);
       nodeById.set(id, node);
     }
   }
@@ -73,17 +79,17 @@ export async function buildInternalGraph(repoDir, opts = {}) {
   for (const abs of files) {
     const fileRel = rel(abs); const ext = extname(abs);
     addNode({ id: fileRel, label: fileRel.split("/").pop(), file_type: "code", source_file: fileRel, source_location: "L1" });
-    if (isDataFile(fileRel) || isDocFile(fileRel)) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); continue; }  // config/infra/docs file-only node
+    if (isDataFile(fileRel) || isDocFile(fileRel)) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue; }  // config/infra/docs file-only node
     const grammar = EXT_LANG[ext]; const lang = LANGS[FAMILY[grammar]]; if (!lang || !langs[grammar]) continue;
     let code; try { code = readFileSync(abs, "utf8"); } catch { continue; }
     // giant / generated / minified file → keep the file NODE but don't parse symbols (avoids a wedged parse)
-    if (code.length > MAX_PARSE_BYTES) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); continue; }
+    if (code.length > MAX_PARSE_BYTES) { perFileSymbols.set(fileRel, []); symByFileName.set(fileRel, new Map()); symIdsByFileName.set(fileRel, new Map()); continue; }
     if ((++_parsed % 24) === 0) await new Promise((r) => setImmediate(r)); // breathe: let the UI paint between chunks
     if (typeof opts.onParseFile === "function") opts.onParseFile(fileRel);
     const parser = new Parser(); parser.setLanguage(langs[grammar]);
     let tree; try { tree = parser.parse(code); } catch { continue; }
 
-    const syms = []; const nameToId = new Map(); const moduleNameToId = new Map();
+    const syms = []; const nameToId = new Map(); const nameToIds = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
       if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) return;
       const suffix = /^:[A-Za-z0-9_-]+$/.test(extra?.idSuffix || "") ? extra.idSuffix : "";
@@ -135,6 +141,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         ...(extra && extra.exported ? { exported: true } : {}),
         ...(extra && extra.decorated ? { decorated: true } : {}),
         ...(extra && extra.symbolKind ? { symbol_kind: extra.symbolKind } : {}),
+        ...(extra && extra.symbolSpace ? { symbol_space: extra.symbolSpace } : {}),
         ...(extra && extra.memberOf ? { member_of: extra.memberOf } : {}),
         ...(extra && extra.visibility ? { visibility: extra.visibility } : {})
       });
@@ -146,8 +153,12 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         end: endLine >= line ? endLine : 0,
         ...(extra?.memberOf ? {memberOf: extra.memberOf} : {}),
         ...(extra?.symbolKind ? {symbolKind: extra.symbolKind} : {}),
+        ...(extra?.symbolSpace ? {symbolSpace: extra.symbolSpace} : {}),
       });
       if (!nameToId.has(name)) nameToId.set(name, id);
+      const ids = nameToIds.get(name) || [];
+      ids.push(id);
+      nameToIds.set(name, ids);
       if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
       return id;
     };
@@ -196,7 +207,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     for (let i = 0; i < syms.length; i++) {
       if (!syms[i].end || syms[i].end < syms[i].start) syms[i].end = i + 1 < syms.length ? syms[i + 1].start - 1 : eof;
     }
-    perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId);
+    perFileSymbols.set(fileRel, syms); symByFileName.set(fileRel, nameToId); symIdsByFileName.set(fileRel, nameToIds);
     tree.delete();
   }
 
@@ -211,7 +222,27 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     let dm = goDirSymbols.get(d); if (!dm) goDirSymbols.set(d, (dm = new Map()));
     for (const [n, id] of m) if (!dm.has(n)) dm.set(n, id);
   }
-  const { resolveNamespaceMember } = resolveJsBarrels({ jsExports, importedLocals, links });
+  const inferredSymbolSpace = (node) => {
+    const explicit = String(node?.symbol_space || "");
+    if (["value", "type", "both"].includes(explicit)) return explicit;
+    const kind = String(node?.symbol_kind || "").toLowerCase();
+    if (["interface", "type"].includes(kind)) return "type";
+    if (["class", "enum"].includes(kind)) return "both";
+    return "value";
+  };
+  const resolveNamedSymbol = (file, name, space = "value") => {
+    const ids = symIdsByFileName.get(file)?.get(name) || [];
+    const accepts = (id) => {
+      const symbolSpace = inferredSymbolSpace(nodeById.get(id));
+      return symbolSpace === "both" || symbolSpace === space;
+    };
+    const exact = ids.find((id) => inferredSymbolSpace(nodeById.get(id)) === space);
+    return exact || ids.find(accepts) || null;
+  };
+  const { resolveNamespaceMember, reExportOccurrences } = resolveJsBarrels({
+    jsExports, importedLocals, links,
+    resolveSymbol: (file, name, typeOnly) => resolveNamedSymbol(file, name, typeOnly ? "type" : "value"),
+  });
   // Exact source ranges can overlap (a named function nested inside another function). Attribute a call
   // to the innermost matching symbol, not whichever outer declaration happened to be added first.
   const enclosing = (fileRel, line) => {
@@ -223,13 +254,13 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     return best;
   };
   const resolveCall = (name, fileRel) => {
-    const local = symByFileName.get(fileRel); if (local && local.has(name)) return local.get(name);
+    const local = resolveNamedSymbol(fileRel, name, "value"); if (local) return local;
     if (sharesDirScope(fileRel)) { const d = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : ""; const dm = goDirSymbols.get(d); if (dm && dm.has(name)) return dm.get(name); }
     const imp = importedLocals.get(fileRel) && importedLocals.get(fileRel).get(name);
     if (imp && imp.targetFile) {
       const targetFile = imp.originFile || imp.targetFile;
       const importedName = imp.originName || imp.imported;
-      const tf = symByFileName.get(targetFile); if (tf && tf.has(importedName)) return tf.get(importedName);
+      return resolveNamedSymbol(targetFile, importedName, "value");
     }
     return null;
   };
@@ -295,7 +326,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         if (!imp || !["*", "default"].includes(imp.imported) || imp.typeOnly) continue;
         const origin = resolveNamespaceMember(fileRel, imp, property.text, "call");
         if (origin.status !== "resolved") continue;
-        const target = symByFileName.get(origin.origin.file)?.get(origin.origin.name);
+        const target = resolveNamedSymbol(origin.origin.file, origin.origin.name, "value");
         const caller = enclosing(fileRel, cap.node.startPosition.row + 1);
         if (target && caller && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
       }
@@ -315,13 +346,25 @@ export async function buildInternalGraph(repoDir, opts = {}) {
           const origin = resolveNamespaceMember(fileRel, imp, parts[parts.length - 1], "jsx");
           if (origin.status === "resolved") { targetFile = origin.origin.file; importedName = origin.origin.name; }
         }
-        const targetSymbols = symByFileName.get(targetFile);
-        if (!targetSymbols) continue;
-        const target = targetSymbols.get(importedName) || targetSymbols.get(localName);
+        const target = resolveNamedSymbol(targetFile, importedName, "value") || resolveNamedSymbol(targetFile, localName, "value");
         if (!target) continue;
         const owner = enclosing(fileRel, cap.node.startPosition.row + 1);
         links.push({ source: owner?.id || fileRel, target, relation: "references", confidence: "INFERRED", usage: "jsx", line: cap.node.startPosition.row + 1 });
       }
+      // Type identifiers are a separate namespace in TypeScript. Resolve them to type/both-space
+      // declarations without creating runtime calls or keeping a same-named value symbol alive.
+      if (grammar !== "javascript") for (const cap of caps(grammar, `(type_identifier) @typeRef`, tree.rootNode)) {
+        const name = cap.node.text;
+        const imp = importedLocals.get(fileRel)?.get(name);
+        const targetFile = imp?.originFile || imp?.targetFile || fileRel;
+        const targetName = imp?.originName || imp?.imported || name;
+        const target = resolveNamedSymbol(targetFile, targetName, "type");
+        if (!target || String(target).startsWith(`${fileRel}#${name}@${cap.node.startPosition.row + 1}`)) continue;
+        const owner = enclosing(fileRel, cap.node.startPosition.row + 1);
+        const source = owner?.id || fileRel;
+        if (source === target) continue;
+        links.push({source, target, relation: "references", confidence: "EXTRACTED", provenance: "RESOLVED", typeOnly: true, line: cap.node.startPosition.row + 1, usage: "type"});
+      }
     }
     // Go value references: a top-level const/var/type/func used BY NAME (bare `X`, or cross-package `pkg.X`) in
     // another file/scope → a `references` edge, so used-but-never-called symbols (message-type consts, etc.) are
@@ -379,7 +422,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 4,
+    reExportOccurrencesV: 1,
+    symbolSpacesV: 1,
+    extractorSchemaV: 5,
+    reExportOccurrences,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,

package/src/mcp/catalog.mjs

@@ -26,9 +26,9 @@ const PROFILE_CAPS = Object.freeze({
 
 // The files whose mtime the stdio shell watches for hot reload — keep in sync with the imports in
 // loadHotApi below (catalog.mjs itself is last: a change here re-derives the whole table).
-export const HOT_FILES = ['tools-graph.mjs', 'tools-impact.mjs', 'tools-health.mjs', 'tools-source.mjs', 'tools-actions.mjs', 'tools-architecture.mjs', 'tools-history.mjs', 'tools-company.mjs', 'catalog.mjs']
+export const HOT_FILES = ['tools-graph.mjs', 'tools-impact.mjs', 'tools-health.mjs', 'tools-source.mjs', 'tools-context.mjs', 'tools-actions.mjs', 'tools-architecture.mjs', 'tools-history.mjs', 'tools-company.mjs', 'catalog.mjs']
 
-function buildTools({tg, ti, th, ts, ta, tar, thi, tc}) {
+function buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc}) {
     const tools = [
         {cap: 'graph', name: 'graph_stats', description: 'Return summary statistics: node count, edge count, communities, versioned edge-provenance/legacy-confidence breakdowns, and graph build time vs repo HEAD (staleness).', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => tg.tGraphStats(g, ctx)},
         {cap: 'graph', name: 'get_node', description: 'Get full details for a specific node by label or ID.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID to look up'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNode(g, a, ctx)},
@@ -86,6 +86,7 @@ function buildTools({tg, ti, th, ts, ta, tar, thi, tc}) {
         {cap: 'search', name: 'search_code', description: 'Full-text or regex search across the repo source (ripgrep-backed, Node fallback). The graph only stores structure — use this to find literal text/patterns, then get_node/get_neighbors for structure.', inputSchema: {type: 'object', properties: {query: {type: 'string', description: 'text or regex to search for'}, is_regex: {type: 'boolean', default: false}, glob: {type: 'string', description: 'optional path glob, e.g. "*.js" or "src/**"'}, max_results: {type: 'integer', default: 40}}, required: ['query']}, run: (g, a, ctx) => searchCode({repoRoot: ctx.repoRoot, resolveRg}, a)},
           {cap: 'source', name: 'read_source', description: "Read the actual source of a node (by label/ID) or a repo-relative file path — the symbol's lines with context. The graph stores only locations, not source text. For a path read, pass start_line to anchor the window anywhere in the file (otherwise it shows the head).", inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'node label or ID'}, path: {type: 'string', description: 'or a repo-relative file path'}, start_line: {type: 'integer', description: 'anchor line: window = start_line-before .. start_line+after'}, before: {type: 'integer', default: 3}, after: {type: 'integer', default: 40}}}, run: (g, a, ctx) => readSource({repoRoot: ctx.repoRoot, resolveNode, isSymbol}, g, a)},
           {cap: 'source', refreshGraph: true, name: 'inspect_symbol', description: 'Inspect one exact symbol with an on-demand TypeScript/JavaScript LSP reference query, grouped occurrence containers, graph blast radius, complexity facts and bounded local source context. Ambiguous labels fail closed; point queries never replace the broad precision overlay.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Exact node ID or unambiguous symbol label'}, precision: {type: 'string', enum: ['auto', 'graph', 'lsp'], default: 'auto'}, max_references: {type: 'integer', minimum: 1, maximum: 5000, default: 1000}, max_containers: {type: 'integer', minimum: 1, maximum: 50, default: 15}, context_lines: {type: 'integer', minimum: 0, maximum: 40, default: 8}, timeout_ms: {type: 'integer', minimum: 1000, maximum: 60000, default: 30000}}, required: ['label']}, run: (g, a, ctx) => ts.tInspectSymbol(g, a, ctx)},
+          {cap: 'source', refreshGraph: true, name: 'context_bundle', description: 'Return one compact, bounded source bundle for an exact symbol: definition, aggregated inbound/outbound containers, exact re-export sites, on-demand TS/JS reference evidence and a few focused source excerpts. Use before an edit when query_graph would be too broad.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Exact node ID or unambiguous symbol label'}, precision: {type: 'string', enum: ['auto', 'graph', 'lsp'], default: 'auto'}, max_references: {type: 'integer', minimum: 1, maximum: 5000, default: 1000}, max_related: {type: 'integer', minimum: 1, maximum: 30, default: 10}, max_reexports: {type: 'integer', minimum: 1, maximum: 100, default: 20}, max_source_files: {type: 'integer', minimum: 1, maximum: 8, default: 4}, context_lines: {type: 'integer', minimum: 0, maximum: 12, default: 4}, timeout_ms: {type: 'integer', minimum: 1000, maximum: 60000, default: 30000}}, required: ['label']}, run: (g, a, ctx) => tb.tContextBundle(g, a, ctx, ts.tInspectSymbol)},
         {cap: 'health', name: 'find_duplicates', description: "Content-based clone detection over production code (MOSS winnowing over method bodies). Supports high-confidence small clones down to 12 tokens when min_tokens is lowered. Tests, e2e, generated code, mocks, stories, docs, benchmarks and temporary roots are classified separately and excluded by default; opt them in explicitly.", inputSchema: {type: 'object', properties: {min_similarity: {type: 'integer', description: '50-100, default 80 (ignored in semantic mode)'}, min_tokens: {type: 'integer', minimum: 12, maximum: 400, description: 'min fragment size, 12-400; default 50'}, mode: {type: 'string', enum: ['renamed', 'strict', 'semantic'], default: 'renamed'}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and paths explicitly classified as excluded; tests still require include_tests'}, include_strings: {type: 'boolean', description: 'Also clone-check large multi-line string literals', default: false}, top_n: {type: 'integer', default: 15}}}, run: (g, a, ctx) => th.tFindDuplicates(g, a, ctx)},
         {cap: 'health', name: 'find_dead_code', description: 'Conservative review queue for statically unreferenced files, functions, methods and symbols. Returns confidence, reason, bounded evidence and explicit framework/dynamic/reflection/public-API caveats; never an auto-delete verdict. Tests, generated code, mocks, stories, docs, benchmarks and temporary roots are excluded by default.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repo-relative path prefix'}, kinds: {type: 'array', items: {type: 'string', enum: ['file', 'function', 'method', 'symbol']}, maxItems: 4, uniqueItems: true, description: 'Optional candidate kinds; defaults to all'}, min_confidence: {type: 'string', enum: ['high', 'medium', 'low'], default: 'medium', description: 'Minimum confidence to include. low explicitly includes public/framework/dynamic review candidates'}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and paths explicitly classified as excluded; tests still require include_tests'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 30}}}, run: (g, a, ctx) => th.tFindDeadCode(g, a, ctx)},
         {cap: 'health', name: 'run_audit', description: 'Full internal health audit. With base_ref, builds and audits an immutable Git checkout, derives changed files, and compares stable deterministic finding IDs; debt defaults to genuinely new findings. Supply-chain checks remain explicitly uncomparable across the source-only baseline. changed_files without base_ref is only changed-scope, never a new-debt claim.', inputSchema: {type: 'object', properties: {category: {type: 'string', enum: ['unused', 'structure', 'vulnerability', 'malware'], description: 'Only findings of this category'}, min_severity: {type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'], description: 'Minimum severity to include'}, max_findings: {type: 'integer', description: 'Max findings to list, default 30'}, include_malware_scan: {type: 'boolean', description: 'Also grep installed packages for malware heuristics (slow)', default: false}, base_ref: {type: 'string', maxLength: 200, description: 'Optional immutable Git baseline (for example HEAD~1 or origin/main). Enables honest new/existing/fixed debt comparison'}, changed_files: {type: 'array', items: {type: 'string'}, minItems: 1, maxItems: 500, description: 'Optional explicit repo-relative scope. Without base_ref this is changed-scope only; when omitted with base_ref, files are derived from the Git diff'}, debt: {type: 'string', enum: ['new', 'existing', 'all'], default: 'new', description: 'Baseline comparison view. Defaults to genuinely new deterministic findings when base_ref is present'}}}, run: (g, a, ctx) => th.tRunAudit(g, a, ctx)},
@@ -133,17 +134,18 @@ function buildTools({tg, ti, th, ts, ta, tar, thi, tc}) {
 // present string (even '') is an explicit selection, so "select nothing" really exposes nothing.
 export async function loadHotApi(version, capsArg) {
     const v = version ? `?v=${version}` : ''
-    const [tg, ti, th, ts, ta, tar, thi, tc] = await Promise.all([
+    const [tg, ti, th, ts, tb, ta, tar, thi, tc] = await Promise.all([
         import(new URL(`./tools-graph.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-impact.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-health.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-source.mjs${v}`, import.meta.url).href),
+        import(new URL(`./tools-context.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-actions.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-architecture.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-history.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-company.mjs${v}`, import.meta.url).href),
     ])
-    const all = buildTools({tg, ti, th, ts, ta, tar, thi, tc})
+    const all = buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc})
     const raw = capsArg == null ? 'offline' : String(capsArg).trim()
     const selected = PROFILE_CAPS[raw] || raw.split(',').map((s) => s.trim()).filter(Boolean)
         .flatMap((cap) => cap === 'online' ? ['advisories', 'hosted'] : [cap])

package/src/mcp/graph-context.mjs

@@ -62,6 +62,10 @@ export function loadGraph(path, {repoRoot = null} = {}) {
         edgeTypesV: Number(raw.edgeTypesV) || 0,
         edgeProvenanceV: Number(raw.edgeProvenanceV) || 0,
         barrelResolutionV: Number(raw.barrelResolutionV) || 0,
+        reExportOccurrencesV: Number(raw.reExportOccurrencesV) || 0,
+        symbolSpacesV: Number(raw.symbolSpacesV) || 0,
+        reExportOccurrences: Array.isArray(raw.reExportOccurrences) ? raw.reExportOccurrences : [],
+        jsExportRecords: raw.jsExportRecords && typeof raw.jsExportRecords === 'object' ? raw.jsExportRecords : {},
         extractorSchemaV: Number(raw.extractorSchemaV) || 0,
         extImportsV: Number(raw.extImportsV) || 0,
         complexityV: Number(raw.complexityV) || 0,

package/src/mcp/graph-diff.mjs

@@ -35,7 +35,7 @@ function stableNodeIndex(graph) {
         if (!raw) continue
         const stem = terminalLineSuffix(raw)
         const params = Number.isInteger(node?.complexity?.params) ? node.complexity.params : ''
-        const signature = [stem, node?.symbol_kind || '', node?.exported === true ? 'exported' : '', params].join('\u0000')
+        const signature = [stem, node?.symbol_kind || '', node?.symbol_space || '', node?.exported === true ? 'exported' : '', params].join('\u0000')
         if (!groups.has(signature)) groups.set(signature, [])
         groups.get(signature).push(node)
     }

package/src/mcp/sync-payload.mjs

@@ -180,7 +180,7 @@ function sanitizeNodeV3(value) {
     else delete out.file_type;
     if (sourceFile) out.source_file = sourceFile;
     else delete out.source_file;
-    for (const key of ['symbol_kind', 'member_of', 'visibility']) setIf(out, key, safeToken(value[key], 128));
+    for (const key of ['symbol_kind', 'symbol_space', 'member_of', 'visibility']) setIf(out, key, safeToken(value[key], 128));
     if (out.complexity) {
         for (const key of ['family', 'scope', 'complexityScope', 'confidence']) {
             const safe = safeToken(value.complexity?.[key], 32);

package/src/mcp/tools-actions.mjs

@@ -91,7 +91,9 @@ export async function tOpenRepo(g, args, ctx) {
             savedPrecision = ['lsp', 'off'].includes(saved.graphPrecisionMode) ? saved.graphPrecisionMode : defaultPrecisionMode()
             schemaUpgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
                 || !Number.isInteger(saved.edgeProvenanceV) || saved.edgeProvenanceV < 1
-                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 4
+                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 5
+                || !Number.isInteger(saved.reExportOccurrencesV) || saved.reExportOccurrencesV < 1
+                || !Number.isInteger(saved.symbolSpacesV) || saved.symbolSpacesV < 1
             if (savedPrecision === 'lsp') {
                 const overlay = readPrecisionOverlay(graphPath, saved)
                 precisionUpgrade = !overlay || (typeof overlay.semanticInputFingerprint === 'string'

package/src/mcp/tools-context.mjs

@@ -0,0 +1,164 @@
+import {isStructuralRelation} from '../graph/relations.js'
+import {boundedInteger} from '../bounds.js'
+import {isSymbol, labelOf} from './graph-context.mjs'
+import {toolResult} from './tool-result.mjs'
+
+const MAX_LINE_SAMPLES = 5
+
+const fileOf = (g, id) => {
+    const node = g.byId.get(String(id))
+    return String(node?.source_file || (isSymbol(id) ? String(id).split('#')[0] : id))
+}
+
+function aggregateEdges(g, edges, cap) {
+    const groups = new Map()
+    for (const edge of edges || []) {
+        if (isStructuralRelation(edge.relation) || edge.barrelProxy === true) continue
+        const id = String(edge.id)
+        const relation = String(edge.relation || 'references')
+        const key = `${id}\0${relation}`
+        let group = groups.get(key)
+        if (!group) {
+            group = {id, label: labelOf(g, id), file: fileOf(g, id), relation, count: 0, lines: []}
+            groups.set(key, group)
+        }
+        group.count++
+        if (Number.isInteger(edge.line) && group.lines.length < MAX_LINE_SAMPLES && !group.lines.includes(edge.line)) group.lines.push(edge.line)
+        if (edge.typeOnly === true) group.typeOnly = true
+        if (edge.compileOnly === true) group.compileOnly = true
+    }
+    const all = [...groups.values()].sort((left, right) => right.count - left.count
+        || left.file.localeCompare(right.file) || left.id.localeCompare(right.id))
+    return {total: all.length, shown: all.slice(0, cap), capped: all.length > cap}
+}
+
+const sameOrigin = (occurrence, definition) => occurrence.originId === definition.id
+    || (occurrence.originFile === definition.file && occurrence.originName === definition.name)
+
+function exactReExportSites(g, definition, cap) {
+    const occurrences = Array.isArray(g.reExportOccurrences) ? g.reExportOccurrences : []
+    const exposures = new Map()
+    if (definition.exported) exposures.set(definition.file, new Set([definition.name]))
+    const shown = new Map()
+    const add = (occurrence, exported = occurrence.exported) => {
+        const key = `${occurrence.file}\0${occurrence.line}\0${exported}\0${occurrence.kind}`
+        if (shown.has(key)) return false
+        shown.set(key, {
+            file: occurrence.file,
+            line: occurrence.line,
+            kind: occurrence.kind,
+            exported,
+            imported: occurrence.imported,
+            targetFile: occurrence.targetFile,
+            typeOnly: occurrence.typeOnly === true,
+            ...(occurrence.specifier ? {specifier: occurrence.specifier} : {}),
+            ...(occurrence.originFile ? {originFile: occurrence.originFile, originName: occurrence.originName} : {}),
+        })
+        return true
+    }
+    for (let pass = 0; pass <= occurrences.length; pass++) {
+        let changed = false
+        for (const occurrence of occurrences) {
+            if (occurrence.kind === 'star') {
+                const names = exposures.get(occurrence.targetFile)
+                if (!names) continue
+                for (const name of names) {
+                    if (name === 'default') continue
+                    changed = add(occurrence, name) || changed
+                    let exported = exposures.get(occurrence.file)
+                    if (!exported) exposures.set(occurrence.file, (exported = new Set()))
+                    const before = exported.size
+                    exported.add(name)
+                    changed = exported.size !== before || changed
+                }
+                continue
+            }
+            if (!sameOrigin(occurrence, definition)) continue
+            changed = add(occurrence) || changed
+            if (occurrence.kind !== 'namespace') {
+                let exported = exposures.get(occurrence.file)
+                if (!exported) exposures.set(occurrence.file, (exported = new Set()))
+                const before = exported.size
+                exported.add(occurrence.exported)
+                changed = exported.size !== before || changed
+            }
+        }
+        if (!changed) break
+    }
+    const all = [...shown.values()].sort((left, right) => left.file.localeCompare(right.file)
+        || left.line - right.line || left.exported.localeCompare(right.exported))
+    return {total: all.length, shown: all.slice(0, cap), capped: all.length > cap}
+}
+
+function linesForGroups(title, groups) {
+    if (!groups.shown.length) return [`${title}: none`]
+    const lines = [`${title}: ${groups.total} container(s)${groups.capped ? ` (${groups.shown.length} shown)` : ''}`]
+    for (const group of groups.shown) {
+        const sites = group.lines.length ? `:${group.lines.join(',')}` : ''
+        lines.push(`  ${group.count}× ${group.relation}  ${group.label}  [${group.file}${sites}]`)
+    }
+    return lines
+}
+
+function textFor(result) {
+    if (result.status !== 'OK') return result.text || `Context bundle: ${result.status}`
+    const definition = result.definition
+    const lines = [
+        `Context bundle: ${definition.label}  [${definition.id}]`,
+        `Definition: ${definition.file}:${definition.line} (${definition.kind}, ${definition.space} space)`,
+        `Evidence: ${result.evidence.state}; ${result.references.occurrences} exact reference occurrence(s) in ${result.references.files} file(s).`,
+        ...linesForGroups('Inbound', result.inbound),
+        ...linesForGroups('Outbound', result.outbound),
+        `Re-export sites: ${result.reExports.total}${result.reExports.capped ? ` (${result.reExports.shown.length} shown)` : ''}`,
+    ]
+    for (const site of result.reExports.shown) lines.push(`  ${site.file}:${site.line}  ${site.kind} ${site.imported} → ${site.exported}${site.typeOnly ? ' [type]' : ''}`)
+    for (const source of result.source) lines.push('', `${source.role} source (${source.file}:${source.startLine}-${source.endLine}):`, source.text)
+    return lines.join('\n')
+}
+
+export async function tContextBundle(g, args = {}, ctx = {}, inspectSymbol) {
+    if (typeof inspectSymbol !== 'function') throw new Error('context_bundle requires inspect_symbol support')
+    const maxRelated = boundedInteger(args.max_related, 10, 1, 30)
+    const maxReExports = boundedInteger(args.max_reexports, 20, 1, 100)
+    const maxSourceFiles = boundedInteger(args.max_source_files, 4, 1, 8)
+    const inspected = await inspectSymbol(g, {
+        ...args,
+        max_containers: Math.min(maxRelated, boundedInteger(args.max_containers, 10, 1, 30)),
+        context_lines: boundedInteger(args.context_lines, 4, 0, 12),
+    }, ctx)
+    const inspection = inspected?.result
+    if (!inspection || inspection.status !== 'OK') return inspected
+    const definition = {
+        ...inspection.definition,
+        name: String(g.byId.get(inspection.definition.id)?.label || '').replace(/\(\)$/, ''),
+    }
+    const inbound = aggregateEdges(g, g.inn.get(definition.id), maxRelated)
+    const outbound = aggregateEdges(g, g.out.get(definition.id), maxRelated)
+    const reExports = exactReExportSites(g, definition, maxReExports)
+    const source = []
+    if (inspection.source.definition) source.push({role: 'Definition', ...inspection.source.definition})
+    for (const excerpt of inspection.source.callers || []) {
+        if (source.length >= maxSourceFiles) break
+        if (source.some((item) => item.file === excerpt.file && item.focusLine === excerpt.focusLine)) continue
+        source.push({role: 'Caller', ...excerpt})
+    }
+    const result = {
+        status: 'OK', definition, evidence: inspection.evidence,
+        references: {
+            occurrences: inspection.exact.occurrences,
+            files: inspection.exact.files,
+            containers: inspection.exact.containers,
+            capped: inspection.exact.capped,
+        },
+        inbound, outbound, reExports, source,
+    }
+    return toolResult(textFor(result), result, {
+        warnings: inspected.warnings,
+        completeness: {
+            status: inspection.evidence.state === 'EXACT' && !inspection.exact.capped && !inbound.capped && !outbound.capped && !reExports.capped ? 'complete' : 'bounded',
+            relatedLimit: maxRelated,
+            reExportLimit: maxReExports,
+            sourceFileLimit: maxSourceFiles,
+        },
+    })
+}

package/src/mcp/tools-graph.mjs

@@ -48,6 +48,8 @@ export function tGraphStats(g, ctx) {
         g.edgeProvenanceV ? `- Edge provenance: v${g.edgeProvenanceV} (${fmt(provenance.counts)}; ${provenance.complete ? 'complete' : `${provenance.counts.UNKNOWN} unclassified`})` : `- Edge provenance: unavailable (rebuild_graph required)`,
         `- Semantic precision: ${precision.state}${precision.provider ? ` via ${precision.provider}${precision.providerVersion ? ` ${precision.providerVersion}` : ''}${precision.typescriptVersion ? ` (TypeScript ${precision.typescriptVersion})` : ''}` : ''}; ${precision.verifiedEdges || 0} EXACT_LSP edge(s), ${precision.queried || 0}/${precision.candidates || 0} bounded target(s) queried${precision.truncated ? ' (partial/truncated)' : ''}${precision.reason ? `; ${precision.reason}` : ''}`,
         g.barrelResolutionV ? `- Barrel resolution: v${g.barrelResolutionV} (semantic tools look through JS/TS re-export facades)` : `- Barrel resolution: unavailable (rebuild_graph required for JS/TS barrel transparency)`,
+        g.reExportOccurrencesV ? `- Re-export occurrences: v${g.reExportOccurrencesV} (${g.reExportOccurrences.length} exact site(s))` : `- Re-export occurrences: unavailable (rebuild_graph required)`,
+        g.symbolSpacesV ? `- TypeScript symbol spaces: v${g.symbolSpacesV} (type/value identities separated)` : `- TypeScript symbol spaces: unavailable (rebuild_graph required)`,
         `- Relations: ${fmt(relCount)}`,
         Object.keys(confCount).length ? `- Legacy confidence: ${fmt(confCount)}` : null,
         `- Communities: ${comm.size} (top by size: ${topComm.map(([c, n]) => `#${c}=${n}`).join(', ')})`,

package/src/mcp/tools-source.mjs

@@ -1,4 +1,5 @@
 import {readFileSync, statSync} from 'node:fs'
+import {boundedInteger} from '../bounds.js'
 import {resolveRepoPath} from '../repo-path.js'
 import {isStructuralRelation} from '../graph/relations.js'
 import {querySymbolPrecision} from '../precision/symbol-query.js'
@@ -9,11 +10,6 @@ const MAX_EXCERPT_CHARS = 4_000
 const MAX_LOCATION_SAMPLES = 5
 const MAX_GRAPH_OCCURRENCES = 100
 
-const boundedInteger = (value, fallback, minimum, maximum) => {
-    const number = Number(value)
-    return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback))
-}
-
 const sourceLine = (node) => {
     const match = /L(\d+)/.exec(String(node?.source_location || ''))
     return match ? Number(match[1]) : 1
@@ -25,7 +21,10 @@ function candidateNodes(g, query, limit = 20) {
     const exact = g.byLabel.get(text)
     const nodes = exact?.length ? exact : g.nodes.filter((node) =>
         String(node.id).toLowerCase().includes(text) || String(node.label || '').toLowerCase().includes(text))
-    return nodes.slice(0, limit).map((node) => ({id: String(node.id), label: String(node.label || node.id), file: node.source_file || null}))
+    return nodes.slice(0, limit).map((node) => ({
+        id: String(node.id), label: String(node.label || node.id), file: node.source_file || null,
+        ...(node.symbol_space ? {space: node.symbol_space} : {}),
+    }))
 }
 
 function excerpt(repoRoot, file, focusLine, contextLines) {
@@ -192,6 +191,8 @@ export async function tInspectSymbol(g, args = {}, ctx = {}) {
         id: targetId,
         label: String(node.label || targetId),
         kind: String(node.symbol_kind || 'symbol'),
+        space: String(node.symbol_space || 'value'),
+        exported: node.exported === true,
         file: String(node.source_file || targetId.split('#')[0]),
         line: sourceLine(node),
         ...(node.source_range ? {range: node.source_range} : {}),

package/src/precision/lsp-client.js

@@ -425,7 +425,7 @@ export class StdioLspClient {
         await this.writeMessage({jsonrpc: JSON_RPC_VERSION, method, params})
     }
 
-    async initialize({capabilities = {}, initializationOptions, clientInfo = {name: 'weavatrix', version: '0.2.5'}} = {}) {
+    async initialize({capabilities = {}, initializationOptions, clientInfo = {name: 'weavatrix', version: '0.2.6'}} = {}) {
         if (this.state !== 'running') throw new Error(`LSP initialize is invalid in state=${this.state}`)
         const result = await this.request('initialize', {
             processId: process.pid,

package/src/precision/lsp-overlay.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { boundedInteger } from "../bounds.js";
 import { atomicWriteFileSync } from "../graph/file-lock.js";
 import { edgeProvenance } from "../graph/edge-provenance.js";
 import { isStructuralRelation } from "../graph/relations.js";
@@ -450,11 +451,6 @@ function publicSemanticSafetyReason(reason) {
     : "TypeScript project configuration could not be verified safely";
 }
 
-function boundedInteger(value, fallback, minimum, maximum) {
-  const number = Number(value);
-  return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback));
-}
-
 export async function buildLspPrecisionOverlay({
   repoRoot,
   graph,

package/src/precision/symbol-query.js

@@ -1,5 +1,6 @@
 import {existsSync, readFileSync, statSync} from 'node:fs'
 import {dirname, resolve} from 'node:path'
+import {boundedInteger} from '../bounds.js'
 import {atomicWriteFileSync, withFileLock} from '../graph/file-lock.js'
 import {
     buildLspPrecisionOverlay,
@@ -15,11 +16,6 @@ const MAX_CACHE_BYTES = 8 * 1024 * 1024
 const MAX_CACHE_READ_BYTES = 16 * 1024 * 1024
 const inFlight = new Map()
 
-const boundedInteger = (value, fallback, minimum, maximum) => {
-    const number = Number(value)
-    return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback))
-}
-
 export function symbolPrecisionCachePath(graphPath) {
     return resolve(dirname(graphPath), SYMBOL_PRECISION_CACHE_FILE)
 }