weavatrix 0.2.3 → 0.2.4

package/src/mcp/catalog.mjs

@@ -33,7 +33,7 @@ function buildTools({tg, ti, th, ta, tar, thi, tc}) {
         {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)},
@@ -90,16 +90,16 @@ function buildTools({tg, ti, th, ta, tar, thi, tc}) {
         {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: '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)},

package/src/mcp/graph-context.mjs

@@ -9,10 +9,17 @@ import {childProcessEnv} from '../child-env.js'
 import {resolveRepoPath} from '../repo-path.js'
 import {isStructuralRelation} from '../graph/relations.js'
 import {edgeProvenance} from '../graph/edge-provenance.js'
+import {mergePrecisionOverlay, precisionSemanticInputsMatch, readPrecisionOverlay} from '../precision/lsp-overlay.js'
+import {createPathClassifier, hasPathClass} from '../path-classification.js'
 
 // ---- graph load + indexes -----------------------------------------------------------------------
-export function loadGraph(path) {
-    const raw = JSON.parse(readFileSync(path, 'utf8'))
+export function loadGraph(path, {repoRoot = null} = {}) {
+    const saved = JSON.parse(readFileSync(path, 'utf8'))
+    const overlay = readPrecisionOverlay(path, saved)
+    const safeOverlay = repoRoot && typeof overlay?.semanticInputFingerprint === 'string'
+        && !precisionSemanticInputsMatch(overlay, repoRoot, saved)
+        ? null : overlay
+    const raw = mergePrecisionOverlay(saved, safeOverlay)
     const nodes = Array.isArray(raw.nodes) ? raw.nodes : []
     const links = Array.isArray(raw.links) ? raw.links : []
     const byId = new Map()
@@ -66,6 +73,9 @@ export function loadGraph(path) {
         repositoryFreshnessBuilderVersion: typeof raw.repositoryFreshnessBuilderVersion === 'string' ? raw.repositoryFreshnessBuilderVersion : null,
         repositoryFreshnessProbe: typeof raw.repositoryFreshnessProbe === 'string' ? raw.repositoryFreshnessProbe : null,
         repositoryFreshnessMode: typeof raw.repositoryFreshnessMode === 'string' ? raw.repositoryFreshnessMode : null,
+        graphPrecisionMode: raw.graphPrecisionMode === 'off' ? 'off' : 'lsp',
+        precisionOverlayV: Number(raw.precisionOverlayV) || 0,
+        precision: raw.precision || null,
     }
 }
 
@@ -121,22 +131,113 @@ const bestByDegree = (g, list) =>
 
 const QUERY_STOP = new Set('a an and are around architecture code do does explain find for from how in is me of or project repository show the through to trace what where which with'.split(' '))
 const QUERY_INTENTS = [
-    ['bootstrap', ['bootstrap', 'startup', 'entrypoint', 'entry', 'main', 'root', 'app', 'index']],
+    ['bootstrap', ['bootstrap', 'startup', 'entrypoint', 'entry', 'main', 'root', 'app', 'application', 'applications', 'index', 'server', 'cli']],
+    ['tool-execution', ['tool', 'tools', 'tooling', 'mcp', 'execution', 'execute', 'invocation', 'invoke', 'dispatch', 'dispatcher', 'handler', 'catalog', 'registry']],
     ['auth', ['auth', 'authentication', 'authorization', 'login', 'session', 'authgate']],
     ['routing', ['routing', 'router', 'routes', 'route', 'navigation']],
     ['layout', ['layout', 'layouts', 'shell']],
     ['api', ['api', 'apis', 'endpoint', 'endpoints', 'client']],
     ['state', ['state', 'store', 'stores', 'reducer', 'context']],
 ]
-const INTENT_BY_TERM = new Map(QUERY_INTENTS.flatMap(([id, terms]) => terms.map((term) => [term, {id, terms}])))
+const INTENT_BY_TERM = new Map(QUERY_INTENTS
+    .filter(([id]) => id !== 'tool-execution')
+    .flatMap(([id, terms]) => terms.map((term) => [term, {id, terms}])))
+const TOOL_EXECUTION_TERMS = QUERY_INTENTS.find(([id]) => id === 'tool-execution')[1]
+const TOOL_EXECUTION_TRIGGERS = new Set(['tool', 'tools', 'tooling', 'mcp'])
 const wordsOf = (value) => String(value ?? '').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)
 const normPath = (value) => String(value ?? '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
+const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const CLASS_QUERY_TERMS = Object.freeze({
+    test: ['test', 'tests', 'testing', 'spec', 'specs', 'unit'],
+    e2e: ['e2e', 'playwright', 'cypress'],
+    generated: ['generated', 'autogenerated', 'dist'],
+    mock: ['mock', 'mocks', 'fixture', 'fixtures', 'fake'],
+    story: ['story', 'stories', 'storybook'],
+    docs: ['doc', 'docs', 'documentation', 'readme', 'guide'],
+    benchmark: ['benchmark', 'benchmarks', 'bench'],
+    temp: ['temp', 'temporary', 'tmp'],
+})
+const CODE_FILE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|kt|kts|cs|rb|php)$/i
+const DATA_OR_PROSE_RE = /\.(?:json|ya?ml|toml|ini|md|mdx|rst|adoc|html?|css|scss|less|svg)$/i
+
+const sourceFileOf = (node) => {
+    const source = node?.source_file || String(node?.id ?? '').split('#', 1)[0]
+    return normPath(source)
+}
+
+function requestedPathClasses(query) {
+    const words = new Set(wordsOf(query))
+    const requested = new Set()
+    for (const [category, terms] of Object.entries(CLASS_QUERY_TERMS)) {
+        if (terms.some((term) => words.has(term))) requested.add(category)
+    }
+    // E2E is also classified as test. Conversely, a broad request for tests should be allowed to
+    // surface all test kinds instead of silently hiding integration/e2e files.
+    if (requested.has('test')) requested.add('e2e')
+    if (requested.has('e2e')) requested.add('test')
+    return requested
+}
+
+function isQueryEligible(node, requestedClasses, classificationCache, classifier) {
+    const source = sourceFileOf(node)
+    if (!source) return true
+    // Query ranking needs path/config classes, not generated-header inspection. Supplying bounded
+    // content avoids opening every source file in a large repository merely to choose a few seeds.
+    if (!classificationCache.has(source)) classificationCache.set(source, classifier.explain(source, {content: ''}))
+    const info = classificationCache.get(source)
+    const classified = NON_PRODUCT_CLASSES.filter((category) => hasPathClass(info, category))
+    return classified.length === 0 || classified.some((category) => requestedClasses.has(category))
+}
+
+// A graph query has no repository filesystem context, so it cannot safely execute package scripts or
+// guess a package.json beside an arbitrary graph path. Prefer evidence already present in the graph:
+// conventional executable paths, explicit entry metadata when a builder provides it, and entry-like
+// topology (few importers, real outgoing runtime links).
+function entrypointSignal(g, node, source, stem) {
+    if (isSymbol(node.id) || !CODE_FILE_RE.test(source)) return 0
+    const segments = source.split('/')
+    const depth = segments.length
+    let score = 0
+    if (node.entrypoint === true || node.is_entrypoint === true || node.declared_entry === true) score = 72
+    if (/^bin\//.test(source) || /\/(?:bin|cmd)\//.test(source)) score = Math.max(score, 62)
+    if (depth <= 2 && /^(?:index|main|app|server|cli|bootstrap|entry|run)$/.test(stem)) score = Math.max(score, 60)
+    if (depth <= 2 && /(?:^|[-_.])(?:main|server|cli|bootstrap|entry)(?:$|[-_.])/.test(stem)) score = Math.max(score, 57)
+    if (depth <= 3 && /^(?:main|app|server|cli|bootstrap|entry|run)$/.test(stem)) score = Math.max(score, 52)
+    const incoming = uniqueConnCount(g.inn.get(String(node.id)))
+    const outgoing = uniqueConnCount(g.out.get(String(node.id)))
+    if (score && incoming === 0 && outgoing > 0) score += Math.min(7, 2 + outgoing)
+    return score
+}
+
+function toolExecutionSignal(node, source, words, stem) {
+    if (!CODE_FILE_RE.test(source)) return 0
+    let score = 0
+    if (/(^|\/)(?:mcp(?:[-_.][^/]*)?|tools?)(?:\/|[-_.])/.test(source)) score = Math.max(score, 51)
+    // Dispatch/catalog files explain how the tool set is assembled and invoked; individual
+    // `tools-*` modules explain only one capability. Prefer the control plane for broad questions.
+    if (/^(?:catalog|dispatch(?:er)?|registry)$/.test(stem)) score = Math.max(score, 68)
+    if (/^(?:tool[-_.]?(?:handler|runner|executor)|tools?[-_.])/.test(stem)) score = Math.max(score, 55)
+    if ([...words].some((word) => /^(?:dispatch|dispatcher|toolcall|toolhandler|executetool|invoketool|calltool)$/.test(word))) score = Math.max(score, 64)
+    if (source.includes('/mcp/') || stem.includes('mcp-server')) score = Math.max(score, 48)
+    return score
+}
 
 function queryConcepts(query) {
+    const tokens = wordsOf(query)
+    const toolExecution = tokens.some((token) => TOOL_EXECUTION_TRIGGERS.has(token))
+    const explanatoryWork = tokens.some((token) => token === 'how' || token === 'explain')
     const seen = new Set()
     const concepts = []
-    for (const raw of wordsOf(query)) {
+    for (const raw of tokens) {
         if (raw.length < 2 || QUERY_STOP.has(raw)) continue
+        if (explanatoryWork && (raw === 'work' || raw === 'works' || raw === 'working')) continue
+        if (toolExecution && TOOL_EXECUTION_TERMS.includes(raw)) {
+            if (seen.has('tool-execution')) continue
+            const trigger = tokens.find((token) => TOOL_EXECUTION_TRIGGERS.has(token)) || raw
+            seen.add('tool-execution')
+            concepts.push({id: 'tool-execution', raw: trigger, terms: [trigger, ...TOOL_EXECUTION_TERMS.filter((term) => term !== trigger)]})
+            continue
+        }
         const intent = INTENT_BY_TERM.get(raw)
         const id = intent?.id || raw
         if (seen.has(id)) continue
@@ -146,10 +247,10 @@ function queryConcepts(query) {
     return concepts
 }
 
-function conceptScore(g, node, concept) {
+function conceptScore(g, node, concept, queryContext) {
     const id = normPath(node.id)
     const label = String(node.label ?? '').toLowerCase()
-    const source = normPath(node.source_file)
+    const source = sourceFileOf(node)
     const stem = (label.split('/').pop() || '').replace(/\.[^.]+$/, '')
     const words = new Set(wordsOf(`${node.id} ${node.label ?? ''} ${node.source_file ?? ''}`))
     const segments = new Set(source.split('/').flatMap((part) => wordsOf(part.replace(/\.[^.]+$/, ''))))
@@ -159,22 +260,38 @@ function conceptScore(g, node, concept) {
         if (label === term || stem === term) match = Math.max(match, primary ? 60 : 42)
         else if (segments.has(term)) match = Math.max(match, primary ? 48 : 36)
         else if (words.has(term)) match = Math.max(match, primary ? 36 : 25)
-        else if (term.length >= 4 && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
+        else if (term.length >= 4 && term !== 'tool' && term !== 'tools' && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
     })
-    if (!match) return 0
     const fileNode = !isSymbol(node.id)
     const depth = source ? source.split('/').length : 9
-    const entryBoost = concept.id === 'bootstrap' && /^(bootstrap|main|app|index|root)$/.test(stem) ? 10 : 0
-    return match + (fileNode ? 7 : 0) + Math.max(0, 4 - depth) + entryBoost + Math.min(2, degreeOf(g, node.id) / 40)
+    if (concept.id === 'bootstrap') match = Math.max(match, entrypointSignal(g, node, source, stem))
+    if (concept.id === 'tool-execution') match = Math.max(match, toolExecutionSignal(node, source, words, stem))
+    if (!match) return 0
+    let score = match + (fileNode ? 7 : 0) + Math.max(0, 4 - depth) + Math.min(2, degreeOf(g, node.id) / 40)
+    if ((concept.id === 'bootstrap' || concept.id === 'tool-execution') && DATA_OR_PROSE_RE.test(source)) score -= 34
+    if ((concept.id === 'bootstrap' || concept.id === 'tool-execution') && !fileNode) score -= 18
+    if (queryContext.runtimeIntent && !queryContext.maintenanceIntent && /^(?:scripts?|tools?\/scripts?)\//.test(source)) score -= 32
+    // A web/demo index can be a legitimate entry point, but it is not the server/tool entry point of
+    // a backend/tool-execution question. Keep it queryable for explicit UI/site questions while
+    // preventing it from beating the executable and dispatcher merely because its basename is index.
+    if (queryContext.runtimeIntent && /^(?:site|website|public|static|assets)\//.test(source)) score -= 28
+    return Math.max(0, score)
 }
 
 // Natural-language graph search keeps one strong candidate per concept before filling by aggregate
 // score. This prevents a broad architecture question from spending every seed on one dense API area.
-export function findSeeds(g, query, limit = 8) {
+export function findSeeds(g, query, limit = 8, {repoRoot = null} = {}) {
     const concepts = queryConcepts(query)
     if (!concepts.length || limit <= 0) return []
-    const rows = g.nodes.map((node) => {
-        const scores = concepts.map((concept) => conceptScore(g, node, concept))
+    const requestedClasses = requestedPathClasses(query)
+    const queryContext = {
+        runtimeIntent: concepts.some((concept) => concept.id === 'bootstrap' || concept.id === 'tool-execution'),
+        maintenanceIntent: wordsOf(query).some((word) => ['script', 'scripts', 'build', 'release', 'publish', 'packaging'].includes(word)),
+    }
+    const classifier = createPathClassifier(repoRoot)
+    const classificationCache = new Map()
+    const rows = g.nodes.filter((node) => isQueryEligible(node, requestedClasses, classificationCache, classifier)).map((node) => {
+        const scores = concepts.map((concept) => conceptScore(g, node, concept, queryContext))
         return {node, scores, total: Math.max(...scores) + scores.reduce((sum, score) => sum + score, 0) / 10}
     })
     const chosen = []
@@ -291,4 +408,16 @@ export function rawGraph(ctx) {
     return rawGraphCache.data
 }
 
+// Consumers that need semantic precision use the revision-matched effective graph. Structural Git
+// baselines and graph_diff deliberately keep using rawGraph so provider availability cannot fabricate
+// architecture drift.
+export function effectiveRawGraph(ctx) {
+    const raw = rawGraph(ctx)
+    const overlay = readPrecisionOverlay(ctx.graphPath, raw)
+    const safeOverlay = ctx?.repoRoot && typeof overlay?.semanticInputFingerprint === 'string'
+        && !precisionSemanticInputsMatch(overlay, ctx.repoRoot, raw)
+        ? null : overlay
+    return mergePrecisionOverlay(raw, safeOverlay)
+}
+
 export {prevGraphPathFor, edgeEndpoint, fileOfId, diffGraphs, formatGraphDiff} from './graph-diff.mjs'

package/src/mcp/tools-actions.mjs

@@ -4,7 +4,7 @@
 import {readFileSync, writeFileSync, existsSync, statSync, realpathSync} from 'node:fs'
 import {dirname, join, isAbsolute} from 'node:path'
 import {prevGraphPathFor, diffGraphs, formatGraphDiff, graphStaleness} from './graph-context.mjs'
-import {buildGraphForRepo} from '../build-graph.js'
+import {buildGraphForRepo, defaultPrecisionMode} from '../build-graph.js'
 import {graphHomeDir, graphOutDirForModule, graphOutDirForRepo} from '../graph/layout.js'
 import {liveRepositoryRecords, registerRepository, repositoryRecord} from '../graph/repo-registry.js'
 import {refreshAdvisories, storeMeta, DEFAULT_STORE} from '../security/advisory-store.js'
@@ -12,6 +12,7 @@ import {collectInstalled} from '../security/installed.js'
 import {createSyncPayload, createSyncPayloadV3, MAX_SYNC_BODY_BYTES} from './sync-payload.mjs'
 import {createEvidenceSnapshot} from './evidence-snapshot.mjs'
 import {writeCachedArchitectureContract} from '../analysis/architecture-contract.js'
+import {precisionSemanticInputsMatch, readPrecisionOverlay} from '../precision/lsp-overlay.js'
 
 const MAX_SYNC_GRAPH_FILE_BYTES = 64 * 1024 * 1024
 
@@ -23,11 +24,14 @@ function syncRepoLabel(repoRoot) {
 
 export async function tRebuildGraph(g, args, ctx) {
     if (!ctx.repoRoot) return 'Rebuild needs the repo root (not provided to this server).'
-    const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : 'full'
+    const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode)
+        ? args.mode
+        : ['no-tests', 'tests-only', 'full'].includes(g?.graphBuildMode) ? g.graphBuildMode : 'full'
+    const precision = args.precision === 'off' ? 'off' : args.precision === 'lsp' ? 'lsp' : (g?.graphPrecisionMode || defaultPrecisionMode())
     const scope = String(args.scope || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '')
     if (scope) {
         const scopedDir = graphOutDirForModule(ctx.repoRoot, scope)
-        const scoped = await buildGraphForRepo(ctx.repoRoot, {mode, scope, outDir: scopedDir})
+        const scoped = await buildGraphForRepo(ctx.repoRoot, {mode, scope, precision, outDir: scopedDir})
         if (!scoped || !scoped.ok) return `Scoped graph build failed: ${(scoped && scoped.error) || 'unknown error'}`
         return [
             `Built an isolated scoped graph for ${scope} (${mode}). ${scoped.log || ''}.`,
@@ -38,18 +42,21 @@ export async function tRebuildGraph(g, args, ctx) {
     // snapshot the outgoing state: bytes → graph.prev.json (for graph_diff later), struct → inline delta
     let prevBytes = null
     try { prevBytes = readFileSync(ctx.graphPath) } catch { /* first build — nothing to diff against */ }
-    const before = g?.nodes ? {
-        nodes: g.nodes, links: g.links,
-        edgeTypesV: g.edgeTypesV || 0,
-        edgeProvenanceV: g.edgeProvenanceV || 0,
-        barrelResolutionV: g.barrelResolutionV || 0,
-        extractorSchemaV: g.extractorSchemaV || 0,
-    } : null
-    const res = await buildGraphForRepo(ctx.repoRoot, {mode, scope: '', outDir: ctx.graphPath ? dirname(ctx.graphPath) : undefined})
+    let before = null
+    try { before = prevBytes ? JSON.parse(prevBytes.toString('utf8')) : null } catch { before = null }
+    const res = await buildGraphForRepo(ctx.repoRoot, {mode, scope: '', precision, outDir: ctx.graphPath ? dirname(ctx.graphPath) : undefined})
     if (!res || !res.ok) return `Graph rebuild failed: ${(res && res.error) || 'unknown error'}`
     if (prevBytes) { try { writeFileSync(prevGraphPathFor(ctx.graphPath), prevBytes) } catch { /* snapshot is best-effort */ } }
     const fresh = ctx.reload() // refresh THIS server's in-memory graph so subsequent tool calls see the new graph
-    const delta = before && fresh ? formatGraphDiff(diffGraphs(before, fresh)) : null
+    let afterStatic = null
+    try { afterStatic = JSON.parse(readFileSync(ctx.graphPath, 'utf8')) } catch { /* reload already reports the failure */ }
+    const beforeMode = ['full', 'no-tests', 'tests-only'].includes(before?.graphBuildMode) ? before.graphBuildMode : 'full'
+    const afterMode = ['full', 'no-tests', 'tests-only'].includes(afterStatic?.graphBuildMode) ? afterStatic.graphBuildMode : 'full'
+    const delta = before && afterStatic
+        ? beforeMode === afterMode
+            ? formatGraphDiff(diffGraphs(before, afterStatic))
+            : `Structural delta not computed: build mode changed from ${beforeMode} to ${afterMode}, so the node/edge universes are not comparable.`
+        : null
     return [
         `Rebuilt the graph (${mode}). ${res.log || ''}. In-memory graph reloaded — graph tools now reflect it.`,
         delta
@@ -68,25 +75,52 @@ export async function tOpenRepo(g, args, ctx) {
     try { if (!statSync(repoPath).isDirectory()) return `Not a directory: ${requestedPath}` } catch { return `Path not found: ${requestedPath}` }
     if (!existsSync(join(repoPath, '.git'))) return `Not a Git repository: ${requestedPath}`
     const graphPath = join(graphOutDirForRepo(repoPath), 'graph.json')
+    const graphExists = existsSync(graphPath)
+    const requestedMode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : null
+    const requestedPrecision = ['lsp', 'off'].includes(args.precision) ? args.precision : null
     let built = false
     let upgrade = false
-    if (existsSync(graphPath)) {
+    let schemaUpgrade = false
+    let precisionUpgrade = false
+    let savedMode = 'full'
+    let savedPrecision = defaultPrecisionMode()
+    if (graphExists) {
         try {
             const saved = JSON.parse(readFileSync(graphPath, 'utf8'))
-            upgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
+            savedMode = ['no-tests', 'tests-only', 'full'].includes(saved.graphBuildMode) ? saved.graphBuildMode : 'full'
+            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 < 3
+            if (savedPrecision === 'lsp') {
+                const overlay = readPrecisionOverlay(graphPath, saved)
+                precisionUpgrade = !overlay || (typeof overlay.semanticInputFingerprint === 'string'
+                    && !precisionSemanticInputsMatch(overlay, repoPath, saved))
+            }
+            upgrade = schemaUpgrade || precisionUpgrade
         } catch {
             upgrade = true
         }
     }
-    if (!existsSync(graphPath) || upgrade) {
+    const modeMismatch = graphExists && requestedMode != null && requestedMode !== savedMode
+    const precisionMismatch = graphExists && requestedPrecision != null && requestedPrecision !== savedPrecision
+    if (!graphExists || upgrade || modeMismatch || precisionMismatch) {
         if (args.build === false) {
+            if (modeMismatch && !upgrade) {
+                return `The existing graph for ${repoPath} was built in ${savedMode}, but ${requestedMode} was requested. Re-call without build:false to rebuild it before switching.`
+            }
+            if (precisionMismatch && !upgrade) {
+                return `The existing graph for ${repoPath} uses semantic precision ${savedPrecision}, but ${requestedPrecision} was requested. Re-call without build:false to rebuild it before switching.`
+            }
             return upgrade
-                ? `The existing graph for ${repoPath} predates current typed-edge/provenance metadata. Re-call without build:false to upgrade it before switching.`
+                ? precisionUpgrade && !schemaUpgrade
+                    ? `The existing graph for ${repoPath} lacks current revision-matched semantic precision evidence. Re-call without build:false to refresh it before switching.`
+                    : `The existing graph for ${repoPath} predates current typed-edge/provenance metadata. Re-call without build:false to upgrade it before switching.`
                 : `No graph yet for ${repoPath} (expected at ${graphPath}). Re-call without build:false to build one — large repos can take minutes.`
         }
-        const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : 'full'
-        const res = await buildGraphForRepo(repoPath, {mode, scope: ''})
+        const mode = requestedMode || (graphExists ? savedMode : 'full')
+        const precision = requestedPrecision || (graphExists ? savedPrecision : defaultPrecisionMode())
+        const res = await buildGraphForRepo(repoPath, {mode, scope: '', precision})
         if (!res || !res.ok) return `Graph build failed for ${repoPath}: ${(res && res.error) || 'unknown error'}`
         built = true
     }
@@ -101,8 +135,13 @@ export async function tOpenRepo(g, args, ctx) {
         return `Failed to load ${graphPath} — still targeting the previous repo (${prev.repoRoot || 'none'}).`
     }
     registerRepository({repoPath, graphDir: graphOutDirForRepo(repoPath), graphHome: graphHomeDir()})
-    const buildNote = built ? (upgrade ? ' (graph upgraded to current edge metadata)' : ' (graph built fresh)') : ''
-    return `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`
+    const buildNote = built ? (upgrade ? ' (graph upgraded to current edge/precision metadata)' : modeMismatch ? ' (graph rebuilt in the requested mode)' : precisionMismatch ? ' (semantic precision mode updated)' : ' (graph built fresh)') : ''
+    return [
+        `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`,
+        `Graph: ${graphPath}`,
+        `Build mode: ${loaded.graphBuildMode || 'full'}`,
+        `Semantic precision: ${loaded.precision?.state || 'UNAVAILABLE'} (${loaded.precision?.verifiedEdges || 0} EXACT_LSP edge(s))`,
+    ].join('\n')
 }
 
 // Sibling repos that already have a built graph in the central weavatrix-graphs folder — open_repo candidates.

package/src/mcp/tools-company.mjs

@@ -48,10 +48,17 @@ function safeRefreshReason(record, error) {
 }
 
 async function reconcileGraph(record, alias, role, graphHome) {
+    let registeredGraph = null
+    try { registeredGraph = loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}) } catch { /* refresh may repair it */ }
+    const buildMode = ['full', 'no-tests', 'tests-only'].includes(registeredGraph?.graphBuildMode)
+        ? registeredGraph.graphBuildMode
+        : 'full'
+    const precision = registeredGraph?.graphPrecisionMode === 'off' ? 'off' : 'lsp'
     let build
     try {
         build = await buildGraphForRepo(record.repoPath, {
-            mode: 'full',
+            mode: buildMode,
+            precision,
             scope: '',
             outDir: record.graphDir,
             graphHome,
@@ -64,6 +71,7 @@ async function reconcileGraph(record, alias, role, graphHome) {
     const publicStatus = {
         role,
         repository: publicRecord(record, alias),
+        buildMode,
         status: build?.ok ? (refreshKind === 'none' ? 'CURRENT' : 'REFRESHED') : 'STALE_FALLBACK',
         refresh: build?.ok ? {
             kind: refreshKind || 'full',
@@ -73,7 +81,7 @@ async function reconcileGraph(record, alias, role, graphHome) {
     }
     if (build?.ok) {
         try {
-            return {record, alias, graph: loadGraph(join(record.graphDir, 'graph.json')), publicStatus}
+            return {record, alias, graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}), publicStatus}
         } catch (error) {
             const reason = `refreshed graph could not be loaded: ${safeRefreshReason(record, error)}`
             return {record, alias, graph: null, reason, publicStatus: {...publicStatus, status: 'FAILED', reason}}
@@ -85,7 +93,7 @@ async function reconcileGraph(record, alias, role, graphHome) {
         return {
             record,
             alias,
-            graph: loadGraph(join(record.graphDir, 'graph.json')),
+            graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}),
             reason: `${reason}; stale registered graph used`,
             publicStatus: {...publicStatus, reason: `${reason}; stale registered graph used`},
         }

package/src/mcp/tools-graph.mjs

@@ -36,13 +36,17 @@ export function tGraphStats(g, ctx) {
             .join(', ')
     const freshness = ctx ? graphStaleness(ctx) : null
     const provenance = summarizeEdgeProvenance(g.links)
+    const precision = g.precision || {state: 'UNAVAILABLE', verifiedEdges: 0, candidates: 0, queried: 0, reason: 'no revision-matched precision overlay'}
     return [
         `Graph summary`,
         ctx?.repoRoot ? `- Repo: ${ctx.repoRoot}` : null,
+        ctx?.graphPath ? `- Graph: ${ctx.graphPath}` : null,
+        `- Build mode: ${g.graphBuildMode || 'full'}`,
         `- Nodes: ${g.nodes.length} (${files} files, ${symbols} symbols)`,
         `- Edges: ${g.links.length}`,
         g.edgeTypesV ? `- Typed-edge metadata: v${g.edgeTypesV} (${typeOnlyEdges} type-only, ${compileOnlyEdges} compile-only edges)` : `- Typed-edge metadata: unavailable (rebuild_graph required)`,
         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)`,
         `- Relations: ${fmt(relCount)}`,
         Object.keys(confCount).length ? `- Legacy confidence: ${fmt(confCount)}` : null,
@@ -67,7 +71,7 @@ export function tGetNode(g, {label} = {}, ctx) {
     const sample = (list, dir) =>
         list
             .slice(0, 12)
-            .map((e) => `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]`)
+            .map((e) => `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${e.relation || 'rel'} [${e.provenance || 'UNKNOWN'}]  ${labelOf(g, e.id)}  [${e.id}]`)
             .join('\n') || '  (none)'
     return [
         note,
@@ -92,8 +96,10 @@ function dedupeEdges(list) {
     for (const e of list) {
         const key = `${e.relation || 'rel'}|${compileKind(e) || 'runtime'}|${e.id}`
         const cur = grouped.get(key)
-        if (cur) cur.count += 1
-        else grouped.set(key, {id: e.id, relation: e.relation, typeOnly: e.typeOnly === true, compileOnly: e.compileOnly === true, count: 1})
+        if (cur) {
+            cur.count += 1
+            cur.provenance.add(e.provenance || 'UNKNOWN')
+        } else grouped.set(key, {id: e.id, relation: e.relation, typeOnly: e.typeOnly === true, compileOnly: e.compileOnly === true, provenance: new Set([e.provenance || 'UNKNOWN']), count: 1})
     }
     return [...grouped.values()]
 }
@@ -112,7 +118,7 @@ export function tGetNeighbors(g, {label, relation_filter} = {}, ctx) {
     const outs = dedupeEdges(outsRaw)
     const ins = dedupeEdges(insRaw)
     const line = (e, dir) =>
-        `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${e.relation || 'rel'}  ${labelOf(g, e.id)}  [${e.id}]${e.count > 1 ? `  (${e.count} sites)` : ''}`
+        `  ${dir === 'out' ? '→' : '←'} ${compileKind(e) ? `${compileKind(e)} ` : ''}${e.relation || 'rel'} [${[...e.provenance].sort().join('+')}]  ${labelOf(g, e.id)}  [${e.id}]${e.count > 1 ? `  (${e.count} sites)` : ''}`
     return [
         note,
         `Neighbors of ${n.label ?? id}${rf ? ` (relation=${rf})` : ''}: ${outs.length + ins.length} unique (${outsRaw.length + insRaw.length} edges)`,
@@ -157,13 +163,13 @@ export function tGetCommunity(g, {community_id} = {}) {
 // A plain BFS/DFS flood dumps every reached node (thousands on a real graph) at near-zero signal.
 // Instead: traverse to record reach + distance-from-seed, then show only the closest, most-connected
 // slice as a coherent subgraph (edges kept only among shown nodes). Honest about what was trimmed.
-export function tQueryGraph(g, {question, mode = 'bfs', depth = 3, context_filter, seed_files, augment_seeds = false, token_budget = 2000} = {}) {
+export function tQueryGraph(g, {question, mode = 'bfs', depth = 3, context_filter, seed_files, augment_seeds = false, token_budget = 2000} = {}, toolCtx = {}) {
     const pinned = resolveSeedFiles(g, seed_files)
     // Exact seed files are a control surface, not a hint: by default they disable fuzzy keyword seeds.
     // Callers can opt back into augmentation when they explicitly want both behaviors.
     const automatic = pinned.seeds.length && augment_seeds !== true
         ? []
-        : findSeeds(g, question, Math.max(0, 8 - pinned.seeds.length))
+        : findSeeds(g, question, Math.max(0, 8 - pinned.seeds.length), {repoRoot: toolCtx.repoRoot || null})
     const seeds = [...pinned.seeds, ...automatic.filter((node) => !pinned.seeds.some((seed) => String(seed.id) === String(node.id)))]
     if (!seeds.length) return `No nodes matched "${question}".`
     const maxDepth = Math.max(1, Math.min(6, Number(depth) || 3))