weavatrix 0.2.3 → 0.2.5

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/sync-payload.mjs

@@ -95,7 +95,8 @@ const COMPLEXITY_NUMBERS = [
     'startLine', 'endLine', 'loc', 'params', 'objectFields', 'branches', 'cyclomatic',
     'loops', 'maxLoopDepth', 'returns', 'awaits', 'callCount', 'externalCalls',
     'asyncBoundaries', 'allocations', 'objectLiterals', 'spreadCopies', 'sorts',
-    'linearOps', 'timeRank', 'timeScore', 'memoryRank', 'memoryScore',
+    'linearOps', 'allocationsInLoops', 'copiesInLoops', 'linearOpsInLoops',
+    'sortsInLoops', 'recursionInLoops', 'timeRank', 'timeScore', 'memoryRank', 'memoryScore',
 ];
 
 function sanitizeComplexity(value) {

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 < 4
+            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))