weavatrix 0.2.3 → 0.2.5

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

@@ -11,11 +11,12 @@ export default {
   grammars: ["python"],
   exts: { ".py": "python", ".pyi": "python" },
   isWeb: false,
+  customCalls: true,
   calls: `(call function: (identifier) @callee)`,
   heritage: [`(class_definition superclasses: (argument_list (identifier) @super))`],
 
   pass1(ctx) {
-    const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, addExternalImport, imports, resolvePyPath, pyBaseDir, pyTopDirs } = ctx;
+    const { grammar, tree, fileRel, code, caps, field, addSym, addImportEdge, addExternalImport, markExported, imports, links, nameToId, resolvePyPath, pyBaseDir, pyTopDirs } = ctx;
     // the importing file's own dir is on sys.path when it runs as a script — try siblings for absolute
     // imports, EXCEPT stdlib names (a sibling logging.py must not shadow `import logging`; py3 absolute
     // imports always pick the stdlib, and a wrong internal edge distorts dead-code + reachability)
@@ -30,15 +31,37 @@ export default {
 
     // ---- symbols (decorated defs are framework-entered — @app.route/@app.event/@pytest.fixture — the
     // flag keeps dead-code checks from calling them dead; tree wraps them in decorated_definition) ----
+    const ownedMethods = [];
     for (const cap of caps(grammar, `(function_definition name: (identifier) @fn) (class_definition name: (identifier) @class)`, tree.rootNode)) {
       const decorated = cap.node.parent?.parent?.type === "decorated_definition";
-      addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "fn", {
+      let ownerName = null;
+      if (cap.name === "fn") {
+        let parent = cap.node.parent?.parent;
+        while (parent && !["function_definition", "class_definition", "module"].includes(parent.type)) parent = parent.parent;
+        if (parent?.type === "class_definition") ownerName = field(parent, "name")?.text || null;
+      }
+      const visibility = /^__[^_].*/.test(cap.node.text) ? "private"
+        : /^_[^_]/.test(cap.node.text) ? "protected" : "public";
+      const id = addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "fn", {
         sourceNode: cap.node.parent,
-        ...(decorated ? { decorated: true } : {})
+        selectionNode: cap.node,
+        ...(decorated ? { decorated: true } : {}),
+        symbolKind: cap.name === "class" ? "class" : ownerName ? "method" : "function",
+        ...(ownerName ? {memberOf: ownerName, visibility} : {moduleDeclaration: true}),
       });
+      if (ownerName) ownedMethods.push({ownerName, id});
+    }
+    for (const method of ownedMethods) {
+      const ownerId = nameToId.get(method.ownerName);
+      if (ownerId) links.push({source: ownerId, target: method.id, relation: "contains", confidence: "EXTRACTED"});
     }
     for (const cap of caps(grammar, `(module (expression_statement (assignment left: (identifier) @var)))`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent, selectionNode: cap.node, symbolKind: "variable", moduleDeclaration: true });
+
+    // Static __all__ is authoritative for wildcard imports. The assignment itself remains indexed,
+    // while listed declarations are marked as the explicit public module surface.
+    const allMatch = String(code || "").match(/(?:^|\n)\s*__all__\s*=\s*[\[(]([\s\S]*?)[\])]/m);
+    if (allMatch) for (const match of allMatch[1].matchAll(/["']([A-Za-z_]\w*)["']/g)) markExported(match[1]);
 
     // ---- import a.b [as c] ----
     for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
@@ -61,6 +84,15 @@ export default {
         else if (modNode.type === "dotted_name") modParts = modNode.text.split(".");
       }
       const baseDir = pyBaseDir(fileRel, dots);
+      const wildcard = node.namedChildren.some((child) => child.type === "wildcard_import");
+      if (wildcard) {
+        const modFile = resolvePyPath(baseDir, modParts) || (dots === 0 ? resolveAbs(modParts) : null);
+        if (modFile) {
+          addImportEdge(modFile);
+          imports.set(`*:${node.startPosition.row + 1}`, {imported: "*", targetFile: modFile, wildcard: true, line: node.startPosition.row + 1});
+        } else if (dots === 0 && modParts.length) recordExternal(modParts.join("."), node.startPosition.row + 1);
+        continue;
+      }
       const names = node.namedChildren.filter((c) => c !== modNode && (c.type === "dotted_name" || c.type === "aliased_import"));
       let externalDone = false; // one record per statement, not per imported name
       for (const nm of names) {
@@ -75,4 +107,129 @@ export default {
       }
     }
   },
+
+  pass2(ctx) {
+    const {grammar, tree, fileRel, caps, field, enclosing, links, nodeById, perFileSymbols, symByFileName, importedLocals, resolveCall} = ctx;
+    const imports = importedLocals.get(fileRel) || new Map();
+    const wildcardImports = [...imports.values()].filter((entry) => entry?.wildcard && entry.targetFile);
+    const emitted = new Set();
+    const addCall = (caller, target, line, evidence) => {
+      if (!caller || !target || target === caller.id) return;
+      const key = `${caller.id}\0${target}\0${line}`;
+      if (emitted.has(key) || links.some((link) => link.source === caller.id && link.target === target && link.relation === "calls" && link.line === line)) return;
+      emitted.add(key);
+      const provenance = ["receiver-type", "wildcard-import", "module-member"].includes(evidence) ? "RESOLVED" : "INFERRED";
+      links.push({source: caller.id, target, relation: "calls", confidence: "INFERRED", provenance, line, pythonResolution: evidence});
+    };
+    const moduleSymbol = (targetFile, name) => {
+      const id = symByFileName.get(targetFile)?.get(name);
+      if (!id) return null;
+      const node = nodeById.get(id);
+      return node?.member_of ? null : id;
+    };
+    const wildcardCandidates = (name) => {
+      const candidates = [];
+      for (const imp of wildcardImports) {
+        const symbols = perFileSymbols.get(imp.targetFile) || [];
+        const explicitAll = symbols.some((symbol) => symbol.name === "__all__");
+        const symbol = symbols.find((entry) => entry.name === name && !entry.memberOf);
+        if (!symbol || (explicitAll ? nodeById.get(symbol.id)?.exported !== true : name.startsWith("_"))) continue;
+        candidates.push(symbol.id);
+      }
+      return [...new Set(candidates)];
+    };
+    const classInfo = (name) => {
+      const local = symByFileName.get(fileRel)?.get(name);
+      if (local && nodeById.get(local)?.symbol_kind === "class") return {id: local, name, file: fileRel};
+      const imp = imports.get(name);
+      if (imp?.targetFile && !imp.wildcard) {
+        const targetFile = imp.originFile || imp.targetFile;
+        const targetName = imp.originName || imp.imported || name;
+        const id = symByFileName.get(targetFile)?.get(targetName);
+        if (id && nodeById.get(id)?.symbol_kind === "class") return {id, name: targetName, file: targetFile};
+      }
+      const wildcard = wildcardCandidates(name).filter((id) => nodeById.get(id)?.symbol_kind === "class");
+      if (wildcard.length === 1) {
+        const node = nodeById.get(wildcard[0]);
+        return {id: wildcard[0], name: node.label || name, file: node.source_file};
+      }
+      return null;
+    };
+    const methodOf = (klass, method) => (perFileSymbols.get(klass.file) || [])
+      .find((symbol) => symbol.memberOf === String(nodeById.get(klass.id)?.label || klass.name).replace(/\(.*$/, "") && symbol.name === method)?.id || null;
+    const bindings = new Map();
+    const shadows = new Set();
+    const scopeKey = (caller, name) => `${caller?.id || ""}\0${name}`;
+    const bind = (caller, name, klass) => { if (caller && name && klass) bindings.set(scopeKey(caller, name), klass); };
+    const typeName = (node) => {
+      const text = String(node?.text || "").replace(/^['"]|['"]$/g, "");
+      return (text.match(/[A-Za-z_]\w*/) || [])[0] || "";
+    };
+
+    for (const cap of caps(grammar, `(parameters (identifier) @param) (typed_parameter) @typed`, tree.rootNode)) {
+      const line = cap.node.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller) continue;
+      if (cap.name === "param") {
+        shadows.add(scopeKey(caller, cap.node.text));
+        continue;
+      }
+      const name = cap.node.namedChildren.find((child) => child.type === "identifier")?.text;
+      if (!name) continue;
+      shadows.add(scopeKey(caller, name));
+      bind(caller, name, classInfo(typeName(field(cap.node, "type"))));
+    }
+    for (const cap of caps(grammar, `(assignment) @assign`, tree.rootNode)) {
+      const assignment = cap.node;
+      const caller = enclosing(fileRel, assignment.startPosition.row + 1);
+      if (!caller) continue;
+      const left = field(assignment, "left");
+      const right = field(assignment, "right");
+      let receiver = "";
+      if (left?.type === "identifier") receiver = left.text;
+      else if (left?.type === "attribute") receiver = left.text;
+      if (!receiver) continue;
+      shadows.add(scopeKey(caller, receiver));
+      const annotation = typeName(field(assignment, "type"));
+      const constructor = right?.type === "call" && field(right, "function")?.type === "identifier"
+        ? field(right, "function").text : "";
+      bind(caller, receiver, classInfo(annotation || constructor));
+    }
+
+    for (const cap of caps(grammar, `(call function: (identifier) @callee)`, tree.rootNode)) {
+      const line = cap.node.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller || shadows.has(scopeKey(caller, cap.node.text))) continue;
+      let target = resolveCall(cap.node.text, fileRel);
+      if (target && nodeById.get(target)?.member_of) target = null;
+      let evidence = "bare";
+      if (!target) {
+        const candidates = wildcardCandidates(cap.node.text);
+        if (candidates.length === 1) { target = candidates[0]; evidence = "wildcard-import"; }
+      }
+      addCall(caller, target, line, evidence);
+    }
+
+    for (const cap of caps(grammar, `(call function: (attribute) @attributeCall)`, tree.rootNode)) {
+      const attribute = cap.node;
+      const object = field(attribute, "object");
+      const member = field(attribute, "attribute");
+      if (!object || !member) continue;
+      const line = attribute.startPosition.row + 1;
+      const caller = enclosing(fileRel, line);
+      if (!caller) continue;
+      if (object.type === "identifier") {
+        const moduleImport = imports.get(object.text);
+        if (moduleImport?.targetFile && moduleImport.imported === "*" && !moduleImport.wildcard) {
+          addCall(caller, moduleSymbol(moduleImport.targetFile, member.text), line, "module-member");
+          continue;
+        }
+      }
+      let klass = null;
+      if (["self", "cls"].includes(object.text) && caller.memberOf) klass = classInfo(caller.memberOf);
+      if (!klass) klass = bindings.get(scopeKey(caller, object.text));
+      if (!klass && object.type === "call" && field(object, "function")?.type === "identifier") klass = classInfo(field(object, "function").text);
+      addCall(caller, klass && methodOf(klass, member.text), line, "receiver-type");
+    }
+  },
 };

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 = 2
+export const GRAPH_BUILDER_SCHEMA_V = 4
 export const GRAPH_BUILDER_VERSION = (() => {
     try { return String(createRequire(import.meta.url)('../../package.json').version) }
     catch { return '0.0.0' }
@@ -22,10 +22,10 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     extImportsV: 2,
     edgeTypesV: 2,
     edgeProvenanceV: 1,
-    complexityV: 1,
+    complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 1,
+    extractorSchemaV: 4,
 })
 const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
 const MAX_CONTROL_BYTES = 1_000_000

package/src/graph/incremental-refresh.js

@@ -183,7 +183,7 @@ export async function refreshGraphIncrementally(repoDir, existingGraph, {
 
   if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
     || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
-    || Number(existingGraph.extractorSchemaV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
+    || Number(existingGraph.extractorSchemaV) < 4 || 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

@@ -31,12 +31,19 @@ function withTypeOnly(result, typeOnly) {
 export function resolveJsBarrels({ jsExports, importedLocals, links }) {
   const tables = new Map();
   for (const [file, records] of jsExports) {
-    const table = { explicit: new Map(), stars: [] };
+    const table = { explicit: new Map(), stars: [], facadeMembers: new Map() };
     for (const record of records || []) {
       if (record.kind === "star") {
         table.stars.push(record);
         continue;
       }
+      if (record.kind === "facade-member") {
+        if (!record.member) continue;
+        const list = table.facadeMembers.get(record.member) || [];
+        list.push(record);
+        table.facadeMembers.set(record.member, list);
+        continue;
+      }
       if (!record.exported) continue;
       const list = table.explicit.get(record.exported) || [];
       list.push(record);
@@ -87,6 +94,23 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
+  const resolveFacadeMember = (file, member, trail = new Set()) => {
+    const key = `${file}\0default.${member}`;
+    if (trail.has(key)) return MISSING;
+    const records = tables.get(file)?.facadeMembers.get(member) || [];
+    if (!records.length) return MISSING;
+    const nextTrail = new Set(trail);
+    nextTrail.add(key);
+    return mergeCandidates(records.map((record) => {
+      const local = record.local || member;
+      const binding = importedLocals.get(file)?.get(local);
+      if (binding?.targetFile && binding.imported && binding.imported !== "*") {
+        return withTypeOnly(resolveExport(binding.targetFile, binding.imported, nextTrail), record.typeOnly || binding.typeOnly);
+      }
+      return resolved(file, local, record.typeOnly);
+    }));
+  };
+
   // 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) {
@@ -149,8 +173,13 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
   // Namespace member usage is only knowable in pass 2 (`ui.Button`, `ui.run`). Expose a bounded helper
   // that uses the same cache and emits the corresponding semantic file edge exactly once.
   const resolveNamespaceMember = (source, imp, member, usage = null) => {
-    if (!imp?.targetFile || imp.imported !== "*") return MISSING;
-    const result = resolveExport(imp.targetFile, member);
+    if (!imp?.targetFile) return MISSING;
+    const defaultFacade = imp.imported === "default" || imp.originName === "default";
+    const result = imp.imported === "*"
+      ? resolveExport(imp.targetFile, member)
+      : defaultFacade
+        ? resolveFacadeMember(imp.originFile || imp.targetFile, member)
+        : MISSING;
     if (result.status !== "resolved") return result;
     if (result.origin.file !== imp.targetFile) {
       for (const link of links) {
@@ -165,5 +194,5 @@ export function resolveJsBarrels({ jsExports, importedLocals, links }) {
     return result;
   };
 
-  return { resolveExport, resolveNamespaceMember };
+  return { resolveExport, resolveNamespaceMember, resolveFacadeMember };
 }

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

@@ -89,6 +89,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       const suffix = /^:[A-Za-z0-9_-]+$/.test(extra?.idSuffix || "") ? extra.idSuffix : "";
       const id = `${fileRel}#${name}@${line}${suffix}`; if (nodeIds.has(id)) return;
       const sourceNode = extra && extra.sourceNode;
+      const selectionNode = extra && extra.selectionNode;
       const endLine = sourceNode?.endPosition ? sourceNode.endPosition.row + 1 : 0;
       let complexity = null;
       if (callable && sourceNode) {
@@ -98,10 +99,38 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       addNode({
         id,
         label: callable ? `${name}()` : name,
+        ...(callable ? { callable: true } : {}),
         file_type: "code",
         source_file: fileRel,
         source_location: `L${line}`,
         ...(endLine >= line ? { source_end: `L${endLine}` } : {}),
+        ...(sourceNode?.startPosition && sourceNode?.endPosition ? {
+          // web-tree-sitter Point columns are zero-based UTF-16 code-unit offsets. Keep the
+          // declaration body range as well as the identifier selection so LSP reference
+          // locations on a boundary line cannot be attributed to the wrong symbol.
+          source_range: {
+            start: {
+              line: sourceNode.startPosition.row,
+              character: sourceNode.startPosition.column,
+            },
+            end: {
+              line: sourceNode.endPosition.row,
+              character: sourceNode.endPosition.column,
+            },
+          },
+        } : {}),
+        ...(selectionNode?.startPosition && selectionNode?.endPosition ? {
+          // web-tree-sitter's JavaScript Point columns are already zero-based UTF-16 code-unit
+          // offsets, matching LSP positions exactly (including text before non-ASCII identifiers).
+          selection_start: {
+            line: selectionNode.startPosition.row,
+            character: selectionNode.startPosition.column,
+          },
+          selection_end: {
+            line: selectionNode.endPosition.row,
+            character: selectionNode.endPosition.column,
+          },
+        } : {}),
         ...(complexity ? { complexity } : {}),
         ...(extra && extra.exported ? { exported: true } : {}),
         ...(extra && extra.decorated ? { decorated: true } : {}),
@@ -110,7 +139,14 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         ...(extra && extra.visibility ? { visibility: extra.visibility } : {})
       });
       links.push({ source: fileRel, target: id, relation: "contains", confidence: "EXTRACTED" });
-      syms.push({ id, name, start: line, end: endLine >= line ? endLine : 0 });
+      syms.push({
+        id,
+        name,
+        start: line,
+        end: endLine >= line ? endLine : 0,
+        ...(extra?.memberOf ? {memberOf: extra.memberOf} : {}),
+        ...(extra?.symbolKind ? {symbolKind: extra.symbolKind} : {}),
+      });
       if (!nameToId.has(name)) nameToId.set(name, id);
       if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
       return id;
@@ -214,10 +250,18 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     let code; try { code = readFileSync(abs, "utf8"); } catch { continue; }
     const parser = new Parser(); parser.setLanguage(langs[grammar]);
     let tree; try { tree = parser.parse(code); } catch { continue; }
-    for (const cap of caps(grammar, lang.calls, tree.rootNode)) {
+    if (!lang.customCalls) for (const cap of caps(grammar, lang.calls, tree.rootNode)) {
       const caller = enclosing(fileRel, cap.node.startPosition.row + 1); if (!caller) continue;
       const target = resolveCall(cap.node.text, fileRel); if (!target || target === caller.id) continue;
-      links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
+      links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
+    }
+    if (typeof lang.pass2 === "function") {
+      try {
+        lang.pass2({
+          grammar, tree, fileRel, code, caps, field, enclosing, links, nodeById,
+          perFileSymbols, symByFileName, importedLocals, resolveCall,
+        });
+      } catch (e) { /* one language-specific resolver never sinks the graph */ void e; }
     }
     // qualified/selector calls (Go): `pkg.Func()` → the imported package's dir; else `receiver.Method()` → the
     // SAME package (heuristic by method name — connects lifecycle methods like peer.Enable() that need type info).
@@ -229,7 +273,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       const dir = fileRel.includes("/") ? fileRel.slice(0, fileRel.lastIndexOf("/")) : "";
       const dm = goDirSymbols.get(imp && imp.targetDir ? imp.targetDir : dir);
       const target = dm && dm.get(fld.text);
-      if (target && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
+      if (target && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
     }
     for (const heritageSpec of lang.heritage || []) {
       const query = typeof heritageSpec === "string" ? heritageSpec : heritageSpec.query;
@@ -248,12 +292,12 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         const object = field(cap.node, "object"), property = field(cap.node, "property");
         if (!object || object.type !== "identifier" || !property) continue;
         const imp = importedLocals.get(fileRel)?.get(object.text);
-        if (!imp || imp.imported !== "*" || imp.typeOnly) continue;
+        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 caller = enclosing(fileRel, cap.node.startPosition.row + 1);
-        if (target && caller && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
+        if (target && caller && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED", line: cap.node.startPosition.row + 1 });
       }
       for (const cap of caps(grammar, `[
         (jsx_opening_element name: (_) @jsx)
@@ -332,10 +376,10 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     extImportsV: 2,
     edgeTypesV: 2,
     edgeProvenanceV: EDGE_PROVENANCE_V,
-    complexityV: 1,
+    complexityV: 2,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
-    extractorSchemaV: 1,
+    extractorSchemaV: 4,
     jsExportRecords: Object.fromEntries([...jsExports.entries()].sort(([a], [b]) => a.localeCompare(b))),
     fileHashes: snapshot.fileHashes,
     fileExportSignatures: snapshot.fileExportSignatures,

package/src/mcp/catalog.mjs

@@ -26,17 +26,17 @@ 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-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-actions.mjs', 'tools-architecture.mjs', 'tools-history.mjs', 'tools-company.mjs', 'catalog.mjs']
 
-function buildTools({tg, ti, th, ta, tar, thi, tc}) {
+function buildTools({tg, ti, th, ts, 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)},
         {cap: 'graph', name: 'get_neighbors', description: 'Get all direct neighbors of a node with edge details (1 hop, call sites deduped). For transitive impact use get_dependents; for the impact of your current branch changes use change_impact.', inputSchema: {type: 'object', properties: {label: {type: 'string'}, relation_filter: {type: 'string', description: 'Optional: filter by relation type'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNeighbors(g, a, ctx)},
-        {cap: 'graph', name: 'query_graph', description: 'Explore the graph around a concept (BFS/DFS). Returns a focused, ranked subgraph — the closest, most-connected nodes near the matched seeds, with edges among them — not the full flood; states how many nodes were reached vs shown.', inputSchema: {type: 'object', properties: {question: {type: 'string', description: 'Natural language question or keyword search'}, mode: {type: 'string', enum: ['bfs', 'dfs'], default: 'bfs'}, depth: {type: 'integer', default: 3}, context_filter: {type: 'array', items: {type: 'string'}}, seed_files: {type: 'array', items: {type: 'string'}, maxItems: 12, description: 'Optional exact repo-relative file paths. When resolved, these are the only seeds unless augment_seeds is true'}, augment_seeds: {type: 'boolean', default: false, description: 'With seed_files, also add fuzzy question-derived seeds; false keeps traversal strictly pinned'}, token_budget: {type: 'integer', description: 'Higher budget shows more nodes/edges', default: 2000}}, required: ['question']}, run: (g, a) => tg.tQueryGraph(g, a)},
+        {cap: 'graph', name: 'query_graph', description: 'Explore the graph around a concept (BFS/DFS). Returns a focused, ranked subgraph — the closest, most-connected nodes near the matched seeds, with edges among them — not the full flood; states how many nodes were reached vs shown.', inputSchema: {type: 'object', properties: {question: {type: 'string', description: 'Natural language question or keyword search'}, mode: {type: 'string', enum: ['bfs', 'dfs'], default: 'bfs'}, depth: {type: 'integer', default: 3}, context_filter: {type: 'array', items: {type: 'string'}}, seed_files: {type: 'array', items: {type: 'string'}, maxItems: 12, description: 'Optional exact repo-relative file paths. When resolved, these are the only seeds unless augment_seeds is true'}, augment_seeds: {type: 'boolean', default: false, description: 'With seed_files, also add fuzzy question-derived seeds; false keeps traversal strictly pinned'}, token_budget: {type: 'integer', description: 'Higher budget shows more nodes/edges', default: 2000}}, required: ['question']}, run: (g, a, ctx) => tg.tQueryGraph(g, a, ctx)},
         {cap: 'graph', name: 'god_nodes', description: 'Rank production-code connectivity hubs by unique call/import/reference neighbors, with class/method ownership reported separately from runtime connectivity. Repeated call sites do not inflate the rank; classified tests, generated/build output and other non-product paths are excluded by default.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', default: 10}, include_classified: {type: 'boolean', default: false, description: 'Include tests/e2e/generated/build output/mocks/stories/docs/benchmarks/temp and paths explicitly excluded by repository classification'}}}, run: (g, a, ctx) => tg.tGodNodes(g, a, ctx)},
         {cap: 'graph', name: 'shortest_path', description: 'Find the shortest path between two concepts in the knowledge graph.', inputSchema: {type: 'object', properties: {source: {type: 'string'}, target: {type: 'string'}, max_hops: {type: 'integer', default: 8}}, required: ['source', 'target']}, run: (g, a) => tg.tShortestPath(g, a)},
-        {cap: 'graph', name: 'get_dependents', description: 'Transitive blast-radius of ONE node: everything that calls/imports/inherits it, directly or through intermediaries (reverse edges, ranked by proximity then connectivity). For a symbol, also follows importers of its containing file. Use before refactoring; get_neighbors shows only 1 hop, change_impact covers your whole current diff at once.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID'}, depth: {type: 'integer', description: 'Max reverse hops, default 3', default: 3}, max_nodes: {type: 'integer', description: 'Max dependents to list, default 40', default: 40}}, required: ['label']}, run: (g, a) => ti.tGetDependents(g, a)},
+        {cap: 'graph', name: 'get_dependents', description: 'Transitive blast-radius of ONE node: everything that calls/imports/inherits it, directly or through intermediaries (reverse edges, ranked by proximity then connectivity). Symbol queries stay symbol-precise by default; set include_container_importers only for a conservative module-wide radius. Use before refactoring; get_neighbors shows only 1 hop, change_impact covers your whole current diff at once.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID'}, depth: {type: 'integer', description: 'Max reverse hops, default 3', default: 3}, max_nodes: {type: 'integer', description: 'Max dependents to list, default 40', default: 40}, include_container_importers: {type: 'boolean', description: 'Also seed importers of the symbol containing file (broader, conservative; default false)', default: false}}, required: ['label']}, run: (g, a) => ti.tGetDependents(g, a)},
         {cap: 'graph', name: 'change_impact', description: 'Verdict-first, symbol-aware blast radius. Parses a zero-context git diff, distinguishes additive exports from signature/body/removal risk, and reverse-traverses only exact changed seeds so a new API does not inherit every legacy importer of its file. Measured coverage is used when present; otherwise static test reachability is labelled actualCoverage=NOT_AVAILABLE. Pass `diff` for a not-checked-out PR; `files` without a diff remains a conservative fallback.', inputSchema: {type: 'object', properties: {base: {type: 'string', description: 'Base ref, e.g. origin/main or HEAD~1 (default: first existing of origin/HEAD, origin/main, origin/master, main, master)'}, diff: {type: 'string', maxLength: 2097152, description: 'Optional unified diff (prefer --unified=0) for a PR/change that is not checked out; enables symbol-level classification'}, files: {type: 'array', items: {type: 'string'}, maxItems: 500, description: 'Optional repo-relative changed-file hints. Without diff evidence these are classified conservatively rather than guessed additive'}, depth: {type: 'integer', description: 'Max reverse hops, default 2'}, max_nodes: {type: 'integer', description: 'Max impacted nodes to list, default 40'}}}, run: (g, a, ctx) => ti.tChangeImpact(g, a, ctx)},
         {cap: 'graph', name: 'git_history', description: 'Behavioral architecture evidence from bounded local git history: churn × connectivity hotspots, hidden co-change coupling, and expected test/source coupling. Reads numstat only — never commit messages, authors, or source bodies.', inputSchema: {type: 'object', properties: {months: {type: 'integer', enum: [3, 6, 12], default: 6}, max_commits: {type: 'integer', minimum: 1, maximum: 5000, default: 1000}, min_pair_count: {type: 'integer', minimum: 2, maximum: 100, default: 3}, max_pairs: {type: 'integer', minimum: 1, maximum: 500, default: 100}, top_n: {type: 'integer', minimum: 1, maximum: 50, default: 10}}}, run: (g, a, ctx) => thi.tGitHistory(g, a, ctx)},
         {
@@ -84,22 +84,24 @@ function buildTools({tg, ti, th, ta, tar, thi, tc}) {
         },
         {cap: 'graph', name: 'get_community', description: 'Get all nodes in a community by community ID (0-indexed by size).', inputSchema: {type: 'object', properties: {community_id: {type: 'integer', description: 'Community ID (0-indexed by size)'}}, required: ['community_id']}, run: (g, a) => tg.tGetCommunity(g, a)},
         {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: 'health', name: 'find_duplicates', description: "Content-based clone detection over production code (MOSS winnowing over method bodies). 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', description: 'min fragment size, 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: '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: '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)},
         {cap: 'health', name: 'coverage_map', description: 'Map a real existing coverage report onto the graph. If no report exists, return clearly labelled static test reachability (a test imports/reaches a source file) with actualCoverage=NOT_AVAILABLE; reachability is never presented as measured coverage.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max risk hotspots to list, default 15'}, path: {type: 'string', description: 'Optional repo-relative path prefix filter, e.g. src/query'}}}, run: (g, a, ctx) => th.tCoverageMap(g, a, ctx)},
+        {cap: 'health', name: 'hot_path_review', description: 'Rank bounded production-symbol hot paths from parser-derived local complexity, inside-loop allocations/copies/scans/sorts/recursion, graph fan-in/fan-out, and measured coverage or clearly labelled static test reachability. Local syntax cost stays separate from graph risk; this is not profiler data or interprocedural Big-O.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repository-relative path prefix'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 20}, min_score: {type: 'integer', minimum: 0, maximum: 100, default: 0}, cyclomatic_threshold: {type: 'integer', minimum: 2, maximum: 1000, default: 8}, call_threshold: {type: 'integer', minimum: 1, maximum: 10000, default: 12}, loop_depth_threshold: {type: 'integer', minimum: 1, maximum: 10, default: 2}, time_rank_threshold: {type: 'integer', minimum: 0, maximum: 5, default: 2}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and explicitly excluded paths; tests still require include_tests'}}}, run: (g, a, ctx) => th.tHotPathReview(g, a, ctx)},
         {cap: 'graph', name: 'list_communities', description: 'List graph communities named by their dominant folder (largest first) with sample files — a readable module overview; feed the list position into get_community.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max communities to list, default 20'}}}, run: (g, a, ctx) => th.tListCommunities(g, a, ctx)},
-        {cap: 'graph', name: 'module_map', description: 'Folder-level architecture map with file/symbol counts and strongest module dependencies, separating runtime, TypeScript type-only and language compile-only coupling.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
+        {cap: 'graph', name: 'module_map', description: 'Production-first folder architecture map with file/symbol counts and strongest module dependencies, separating runtime, TypeScript type-only and language compile-only coupling.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}, include_non_product: {type: 'boolean', default: false, description: 'Include tests, fixtures, benchmarks, generated output, docs and other classified non-product files; false by default'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
         {cap: 'source', refreshGraph: true, name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web/Spring MVC and WebFlux): method, composed path, handler, and file:line.', inputSchema: {type: 'object', properties: {max_results: {type: 'integer', description: 'Max endpoints to list, default 100'}}}, run: (g, a, ctx) => th.tListEndpoints(g, a, ctx)},
-        {cap: 'build', name: 'rebuild_graph', description: "Rebuild the active full-repository graph and report a structural delta. With scope, build an isolated diagnostic graph without replacing or diffing the full graph; normal graph queries remain pinned to the full repository.", inputSchema: {type: 'object', properties: {mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], default: 'full'}, scope: {type: 'string', description: 'Optional isolated diagnostic path prefix; never replaces the active full graph'}}}, run: (g, a, ctx) => ta.tRebuildGraph(g, a, ctx)},
+        {cap: 'build', name: 'rebuild_graph', description: "Rebuild the active full-repository graph and report a structural delta. Omitted mode/precision preserve the active graph; a first build uses full and the startup precision setting (lsp unless WEAVATRIX_PRECISION=off). The local TypeScript/JavaScript LSP overlay validates bounded ambiguous edges; precision:off is an explicit fallback. With scope, build an isolated diagnostic graph without replacing or diffing the full graph.", inputSchema: {type: 'object', properties: {mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], description: 'Build mode; omit to preserve the active mode (or use full for a first build)'}, precision: {type: 'string', enum: ['lsp', 'off'], description: 'Semantic precision; omit to preserve the active mode (or use the startup setting for a first build)'}, scope: {type: 'string', description: 'Optional isolated diagnostic path prefix; never replaces the active full graph'}}}, run: (g, a, ctx) => ta.tRebuildGraph(g, a, ctx)},
         {cap: 'graph', name: 'graph_diff', description: 'Structural graph diff: compare the current graph with an immutable Git-ref baseline (base_ref such as HEAD~1 or main), or with graph.prev.json from the last rebuild when base_ref is omitted. Reports architecture drift, cycle changes and symbols that lost their last caller.', inputSchema: {type: 'object', properties: {base_ref: {type: 'string', maxLength: 256, description: 'Optional immutable Git baseline to build in isolation, e.g. HEAD~1, main or origin/main; never checks out or mutates the working tree'}, path: {type: 'string', description: 'Optional node-id/path prefix to scope the diff, e.g. src/query'}}}, run: (g, a, ctx) => ti.tGraphDiff(g, a, ctx)},
         {cap: 'graph', name: 'get_architecture_contract', description: 'Return the executable target-architecture contract, quality budgets and ratchet mode that an agent must follow before editing.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => tar.tGetArchitectureContract(g, a, ctx)},
         {cap: 'graph', name: 'prepare_change', description: 'Select active target-architecture rules for an intended set of changed files. Run before a non-trivial edit.', inputSchema: {type: 'object', properties: {intent: {type: 'string'}, files: {type: 'array', items: {type: 'string'}, maxItems: 200}}, required: ['files']}, run: (g, a, ctx) => tar.tPrepareChange(g, a, ctx)},
         {cap: 'health', name: 'verify_architecture', description: 'Verify the fresh graph against the active target contract and ratchet; separates new, existing, fixed and excepted debt.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => tar.tVerifyArchitecture(g, a, ctx)},
         {cap: 'health', name: 'explain_architecture_violation', description: 'Explain one active architecture violation and the governing rule.', inputSchema: {type: 'object', properties: {fingerprint: {type: 'string'}}, required: ['fingerprint']}, run: (g, a, ctx) => tar.tExplainArchitectureViolation(g, a, ctx)},
         {cap: 'health', name: 'propose_architecture_exception', description: 'Prepare, but never apply, a bounded exception proposal for human review.', inputSchema: {type: 'object', properties: {fingerprint: {type: 'string'}, reason: {type: 'string'}, expires: {type: 'string', description: 'Optional YYYY-MM-DD'}}, required: ['fingerprint', 'reason']}, run: (g, a, ctx) => tar.tProposeArchitectureException(g, a, ctx)},
-        {cap: 'retarget', name: 'open_repo', description: 'OFFLINE RETARGET: switch this server to another local Git repository, building its graph when missing. This explicit tool call changes the active repository boundary; pass build:false to probe without building. Omit the retarget capability at registration to pin one repository.', inputSchema: {type: 'object', properties: {path: {type: 'string', description: 'Absolute path to a Git working tree'}, build: {type: 'boolean', description: 'Build the graph when missing (default true)', default: true}, mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], default: 'full'}}, required: ['path']}, run: (g, a, ctx) => ta.tOpenRepo(g, a, ctx)},
+        {cap: 'retarget', name: 'open_repo', description: 'OFFLINE RETARGET: switch this server to another local Git repository, building its graph when missing. This explicit tool call changes the active repository boundary; pass build:false to probe without building. Omitted mode/precision preserve an existing graph; a new graph uses full and the startup precision setting (lsp unless WEAVATRIX_PRECISION=off). Omit the retarget capability at registration to pin one repository.', inputSchema: {type: 'object', properties: {path: {type: 'string', description: 'Absolute path to a Git working tree'}, build: {type: 'boolean', description: 'Build the graph when missing (default true)', default: true}, mode: {type: 'string', enum: ['full', 'no-tests', 'tests-only'], description: 'Optional build mode override; omit to preserve an existing graph'}, precision: {type: 'string', enum: ['lsp', 'off'], description: 'Optional semantic precision override; omit to preserve an existing graph or use the startup setting for a new graph'}} , required: ['path']}, run: (g, a, ctx) => ta.tOpenRepo(g, a, ctx)},
         {cap: 'retarget', name: 'list_known_repos', description: 'OFFLINE RETARGET: list every registered local repository graph from the global per-user registry, regardless of parent folder.', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => ta.tListKnownRepos(g, a, ctx)},
         {cap: 'advisories', name: 'refresh_advisories', description: "NETWORK / explicit advisories profile: refresh the local OSV advisory store for this repo's lockfile-pinned packages (npm/PyPI/Go). Sends package names + versions to OSV.dev — never automatic, never source code. Afterwards run_audit reads the refreshed store fully offline (~/.weavatrix/advisories.json).", inputSchema: {type: 'object', properties: {timeout_ms: {type: 'integer', description: 'Per-request timeout, default 20000'}}}, run: (g, a, ctx) => ta.tRefreshAdvisories(g, a, ctx)},
         {cap: 'hosted', name: 'pull_architecture_contract', description: 'NETWORK / explicit hosted profile: fetch the owner-approved target architecture for the active stable repository UUID, validate it and cache it locally. Sends only the opaque UUID with bearer auth; never source or paths.', inputSchema: {type: 'object', properties: {timeout_ms: {type: 'integer', minimum: 1000, maximum: 120000, default: 30000}}}, run: (g, a, ctx) => ta.tPullArchitectureContract(g, a, ctx)},
@@ -131,16 +133,17 @@ function buildTools({tg, ti, th, 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, ta, tar, thi, tc] = await Promise.all([
+    const [tg, ti, th, ts, 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-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, ta, tar, thi, tc})
+    const all = buildTools({tg, ti, th, ts, 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])