weavatrix 0.2.15 → 0.2.16

package/src/mcp/tools-company.mjs

@@ -3,13 +3,15 @@
 // can never pass an arbitrary filesystem path through this tool.
 import {join} from 'node:path'
 import {analyzeHttpContracts} from '../analysis/http-contracts.js'
+import {analyzeTransportContracts} from '../analysis/transport-contracts.js'
 import {buildGraphForRepo} from '../build-graph.js'
 import {graphHomeDir} from '../graph/layout.js'
 import {liveRepositoryRecords} from '../graph/repo-registry.js'
 import {loadGraph} from './graph-context.mjs'
 import {toolResult} from './tool-result.mjs'
+import {contractVerdict, contractVerdictLine} from './company-contract-verdict.mjs'
 
-const CROSS_REPO_HTTP_CONTRACT_V = 2
+const CROSS_REPO_HTTP_CONTRACT_V = 3
 const selectorText = (value) => String(value ?? '').trim()
 
 function selectRecord(records, selector) {
@@ -103,52 +105,6 @@ async function reconcileGraph(record, alias, role, graphHome) {
     }
 }
 
-function verdictFor(analysis) {
-    const endpointsWithCallers = analysis.endpoints.filter((endpoint) => endpoint.callsites.length > 0)
-    const affectedFiles = new Set()
-    const affectedScreens = new Set()
-    for (const endpoint of endpointsWithCallers) {
-        for (const item of endpoint.affected.files || []) affectedFiles.add(`${item.client}\0${item.file}`)
-        for (const item of endpoint.affected.screens || []) affectedScreens.add(`${item.client}\0${item.file}`)
-    }
-    let code = 'NO_ENDPOINTS_MATCHED', risk = 'unknown'
-    if (analysis.totals.endpoints > 0 && analysis.totals.matches === 0) {
-        code = analysis.totals.methodMismatches > 0 ? 'HTTP_METHOD_MISMATCH' : 'NO_STATIC_CLIENT_CALLERS'
-        risk = analysis.totals.methodMismatches > 0 ? 'high' : 'unknown'
-    } else if (analysis.totals.matches > 0 && analysis.totals.methodMismatches > 0) {
-        code = 'CLIENTS_AT_RISK_WITH_METHOD_MISMATCHES'; risk = 'high'
-    } else if (analysis.totals.matches > 0) {
-        code = 'CLIENTS_AT_RISK'; risk = 'medium'
-    }
-    return {
-        code,
-        risk,
-        endpointsWithCallers: endpointsWithCallers.length,
-        callsites: analysis.totals.matches,
-        affectedFiles: affectedFiles.size,
-        affectedScreens: affectedScreens.size,
-        methodMismatches: analysis.totals.methodMismatches,
-        uncertainCalls: analysis.totals.uncertainCalls,
-        notDeadExternalUse: analysis.totals.notDeadExternalUse,
-        notDeadExternalHandlers: analysis.totals.notDeadExternalHandlers,
-        possibleExternalUse: analysis.totals.possibleExternalUse,
-        unknownLiveness: analysis.totals.unknownLiveness,
-    }
-}
-
-function verdictLine(verdict, endpoints) {
-    if (verdict.code === 'NO_ENDPOINTS_MATCHED') {
-        return 'VERDICT NO_ENDPOINTS_MATCHED — no backend endpoint satisfied the requested method/path/change filter.'
-    }
-    if (verdict.code === 'NO_STATIC_CLIENT_CALLERS') {
-        return `VERDICT NO_STATIC_CLIENT_CALLERS — ${endpoints} backend endpoint(s) matched, but no bounded literal/template client call was proven; this is unknown, not proof of no consumers.`
-    }
-    if (verdict.code === 'HTTP_METHOD_MISMATCH') {
-        return `VERDICT HTTP_METHOD_MISMATCH — ${verdict.methodMismatches} client call(s) match the route shape with a different method.`
-    }
-    return `VERDICT ${verdict.code} — ${verdict.callsites} callsite(s) reach ${verdict.endpointsWithCallers} endpoint(s); ${verdict.affectedScreens} screen(s) and ${verdict.affectedFiles} file(s) are in the bounded blast radius.`
-}
-
 export async function tTraceApiContract(_g, args = {}, ctx = {}) {
     const graphHome = ctx.graphHome || graphHomeDir()
     const records = liveRepositoryRecords(graphHome)
@@ -215,7 +171,7 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
     }
 
     try {
-        const analysis = analyzeHttpContracts({
+        let analysis = analyzeHttpContracts({
             backend: {id: backendAlias, repoRoot: backend.repoPath, graph: backendGraph.graph},
             clients: clientGraphs.map((item) => ({id: item.alias, repoRoot: item.record.repoPath, graph: item.graph})),
             method: args.method,
@@ -229,9 +185,25 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
             maxEndpoints: args.max_endpoints,
             maxMatches: args.max_matches,
             maxAffectedFiles: args.max_affected_files,
+            runtimeValues: args.runtime_config,
         })
-        const verdict = verdictFor(analysis)
-        const reasons = [...new Set([...reconciliationReasons, ...(analysis.completeness?.reasons || [])])]
+        const selectedTransport = ['all', 'http', 'graphql', 'grpc', 'event'].includes(args.transport) ? args.transport : 'all'
+        if (!['all', 'http'].includes(selectedTransport)) analysis = {
+            ...analysis, status: 'complete', completeness: {complete: true, reasons: []}, endpoints: [], uncertain: [],
+            totals: {...analysis.totals, endpoints: 0, clientCalls: 0, matches: 0, methodMismatches: 0, uncertainCalls: 0, notDeadExternalUse: 0, notDeadExternalHandlers: 0, possibleExternalUse: 0, unknownLiveness: 0},
+        }
+        const transportAnalysis = selectedTransport === 'http'
+            ? {transportContractsV: 1, transport: 'http', status: 'COMPLETE', completeness: {complete: true, reasons: []}, totals: {contracts: 0, matches: 0, uncertain: 0, filesScanned: 0}, contracts: [], uncertain: []}
+            : analyzeTransportContracts({
+                backend: {id: backendAlias, repoRoot: backend.repoPath, graph: backendGraph.graph},
+                clients: clientGraphs.map((item) => ({id: item.alias, repoRoot: item.record.repoPath, graph: item.graph})),
+                transport: selectedTransport === 'all' ? 'all' : selectedTransport,
+                includeTests: args.include_tests === true,
+                maxImpactDepth: args.max_impact_depth,
+                maxAffectedFiles: args.max_affected_files,
+            })
+        const verdict = contractVerdict(analysis, transportAnalysis)
+        const reasons = [...new Set([...reconciliationReasons, ...(analysis.completeness?.reasons || []), ...(transportAnalysis.completeness?.reasons || [])])]
         const completeness = {
             complete: reasons.length === 0 && analysis.completeness?.complete === true,
             status: reasons.length === 0 && analysis.completeness?.complete === true ? 'COMPLETE' : 'PARTIAL',
@@ -243,8 +215,8 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
             right.affected.files.length - left.affected.files.length ||
             left.path.localeCompare(right.path))
         const lines = [
-            verdictLine(verdict, analysis.totals.endpoints),
-            `Scope: ${backend.label} → ${clients.map(({record}) => record.label).join(', ')}; ${analysis.totals.endpoints} endpoint(s), ${analysis.totals.clientCalls} inspected client call(s), ${analysis.totals.uncertainCalls} uncertain.`,
+            contractVerdictLine(verdict, analysis.totals.endpoints + transportAnalysis.totals.contracts),
+            `Scope: ${backend.label} → ${clients.map(({record}) => record.label).join(', ')}; ${analysis.totals.endpoints} HTTP endpoint(s), ${transportAnalysis.totals.contracts} GraphQL/gRPC/event contract(s), ${analysis.totals.clientCalls} inspected HTTP call(s), ${verdict.uncertainCalls} uncertain.`,
             ...ranked.slice(0, topN).flatMap((endpoint) => {
                 const location = endpoint.file ? ` (${endpoint.backend}:${endpoint.file}${endpoint.line ? `:${endpoint.line}` : ''})` : ''
                 const callsites = endpoint.callsites.slice(0, 3)
@@ -257,8 +229,10 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
                     ...screens,
                 ]
             }),
+            ...transportAnalysis.contracts.filter((contract) => contract.callsites.length).slice(0, topN).map((contract) =>
+                `  ${contract.transport.toUpperCase()} ${contract.service ? `${contract.service}.` : contract.operation ? `${contract.operation} ` : ''}${contract.name} (${contract.file}:${contract.line}) [${contract.liveness}] → ${contract.callsites.length} callsite(s), ${contract.affected.files.length} affected file(s)`),
             completeness.complete
-                ? 'Completeness: complete within the declared repository graphs and static HTTP-call model.'
+                ? 'Completeness: complete within the declared repository graphs and supported static HTTP/GraphQL/gRPC/event models.'
                 : `Completeness: partial — ${completeness.reasons.join('; ')}.`,
         ]
         const result = {
@@ -269,6 +243,7 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
                 clients: clients.map(({record, alias}) => publicRecord(record, alias)),
             },
             ...analysis,
+            transportContracts: transportAnalysis,
             status: completeness.status,
             graphReconciliation,
             completeness,

package/src/mcp/tools-impact-precision.mjs

@@ -0,0 +1,89 @@
+import {isStructuralRelation} from '../graph/relations.js'
+import {querySymbolsPrecision} from '../precision/symbol-query.js'
+
+export function graphWithExactDirectReferences(g, targetId, overlay) {
+    const exact = (overlay?.links || []).filter((link) => String(link?.target || '') === targetId
+        && link.provenance === 'EXACT_LSP')
+    const provenEmpty = overlay?.state === 'COMPLETE'
+        && (overlay?.noReferenceSymbols || []).some((id) => String(id) === targetId)
+    if (overlay?.state !== 'COMPLETE' || (!exact.length && !provenEmpty)) return null
+    const inn = new Map(g.inn)
+    const structural = (g.inn.get(targetId) || []).filter((edge) => isStructuralRelation(edge.relation))
+    inn.set(targetId, [...structural, ...exact.map((link) => ({
+        id: String(link.source),
+        relation: link.relation || 'references',
+        provenance: 'EXACT_LSP',
+        ...(link.typeOnly === true ? {typeOnly: true} : {}),
+        ...(link.compileOnly === true ? {compileOnly: true} : {}),
+    }))])
+    return {...g, inn}
+}
+
+export function refineChangeImpact(g, args, ctx, baseline, computeImpact) {
+    const requested = ['auto', 'graph', 'lsp'].includes(args?.precision) ? args.precision : 'auto'
+    if (requested === 'graph' || !baseline?.result?.seeds?.ids || !ctx?.repoRoot || !ctx?.graphPath
+        || (requested === 'auto' && g.graphPrecisionMode === 'off')) return baseline
+    const targets = baseline.result.seeds.ids.filter((id) => {
+        const node = g.byId.get(String(id))
+        return node?.selection_start && /\.(?:[cm]?[jt]sx?)$/i.test(String(node.source_file || ''))
+    }).slice(0, 16)
+    if (!targets.length) return baseline
+    return (async () => {
+        try {
+            const precision = await querySymbolsPrecision({
+                repoRoot: ctx.repoRoot,
+                graphPath: ctx.graphPath,
+                targetIds: targets,
+                maxReferences: Math.max(100, Math.min(16_384, Number(args.max_references) || 5_000)),
+                timeoutMs: Math.max(1_000, Math.min(60_000, Number(args.timeout_ms) || 45_000)),
+                clientFactory: ctx.precisionClientFactory,
+            })
+            let exactGraph = g
+            const verified = []
+            for (const target of targets) {
+                const next = graphWithExactDirectReferences(exactGraph, String(target), precision.overlay)
+                if (!next) continue
+                exactGraph = next
+                verified.push(String(target))
+            }
+            const value = verified.length ? computeImpact(exactGraph, args, ctx) : baseline
+            const allVerified = verified.length === targets.length
+            const status = allVerified ? 'DIRECT_EXACT_TRANSITIVE_GRAPH' : 'PARTIAL'
+            value.text = [
+                value.text.split('\n')[0],
+                `Semantic precision: ${status}; EXACT_LSP verified direct references for ${verified.length}/${targets.length} changed JavaScript/TypeScript symbol(s). Transitive hops remain graph-backed.`,
+                ...value.text.split('\n').slice(1),
+            ].join('\n')
+            value.result.semanticPrecision = {
+                status,
+                requestedTargets: targets,
+                verifiedTargets: verified,
+                exactDirectEdges: (precision.overlay?.links || []).filter((link) => verified.includes(String(link?.target || ''))).length,
+                transitiveEvidence: 'GRAPH',
+                provider: precision.overlay?.engines?.[0]?.provider || null,
+                elapsedMs: precision.elapsedMs,
+            }
+            if (!allVerified) value.warnings.push({
+                code: 'CHANGE_IMPACT_PRECISION_PARTIAL',
+                message: precision.overlay?.reason || 'Not every changed symbol had complete exact direct-reference evidence.',
+            })
+            return value
+        } catch (error) {
+            const reason = error?.message || 'batch point query failed'
+            baseline.result.semanticPrecision = {
+                status: 'UNAVAILABLE', requestedTargets: targets, verifiedTargets: [],
+                exactDirectEdges: 0, transitiveEvidence: 'GRAPH', reason,
+            }
+            baseline.warnings.push({
+                code: 'CHANGE_IMPACT_PRECISION_UNAVAILABLE',
+                message: `Exact changed-symbol references were unavailable; graph evidence was retained (${reason}).`,
+            })
+            baseline.text = [
+                baseline.text.split('\n')[0],
+                `Semantic precision: UNAVAILABLE; graph evidence retained (${reason}).`,
+                ...baseline.text.split('\n').slice(1),
+            ].join('\n')
+            return baseline
+        }
+    })()
+}

package/src/mcp/tools-impact.mjs

@@ -2,15 +2,13 @@
 // last rebuild (graph_diff), and the blast radius of the current change set (change_impact).
 // Hot-reloadable (re-imported by catalog.mjs on change).
 import {readFileSync} from 'node:fs'
-import {spawnSync} from 'node:child_process'
-import {childProcessEnv} from '../child-env.js'
 import {
     isSymbol, degreeOf, labelOf, resolveNodeInfo, ambiguityNote,
     rawGraph, prevGraphPathFor, edgeEndpoint, diffGraphs, formatGraphDiff,
 } from './graph-context.mjs'
-import {readCoverageForRepo} from '../analysis/coverage-reports.js'
+import {querySymbolPrecision} from '../precision/symbol-query.js'
+import {graphWithExactDirectReferences, refineChangeImpact} from './tools-impact-precision.mjs'
 import {reverseReach} from './graph/reverse-reach.mjs'
-import {gitLines} from './git-output.mjs'
 import {tChangeImpactV2} from './tools-impact-change.mjs'
 import {buildGraphAtGitRef} from '../analysis/git-ref-graph.js'
 
@@ -24,7 +22,7 @@ const impactKind = (entry) => {
 // Transitive blast-radius: who is affected if this node changes. Walks REVERSE dependency edges
 // (calls/imports/inherits — not structural `contains`) out to `depth`. For a symbol, also seeds its
 // containing file, because importers depend on the file rather than the individual symbol.
-export function tGetDependents(g, {label, depth = 3, max_nodes = 40, include_container_importers = false} = {}) {
+function getDependentsFromGraph(g, {label, depth = 3, max_nodes = 40, include_container_importers = false} = {}, precisionNote = null) {
     const info = resolveNodeInfo(g, label)
     const n = info.node
     if (!n) return `No node found matching "${label}".`
@@ -46,18 +44,64 @@ export function tGetDependents(g, {label, depth = 3, max_nodes = 40, include_con
         .filter(([nid]) => !seeds.has(nid))
         .map(([nid, entry]) => ({id: nid, d: entry.depth, entry, deg: degreeOf(g, nid)}))
         .sort((a, b) => a.d - b.d || Number(a.entry.compileOnly) - Number(b.entry.compileOnly) || b.deg - a.deg)
-    if (!ranked.length) return [note, `No dependents found for ${n.label ?? id} within depth ${maxDepth} — nothing in the graph calls, imports, or inherits it.`].filter(Boolean).join('\n')
+    if (!ranked.length) return [note, precisionNote, `No dependents found for ${n.label ?? id} within depth ${maxDepth} — nothing in the graph calls, imports, or inherits it.`].filter(Boolean).join('\n')
     const shown = ranked.slice(0, cap)
     const runtimeCount = ranked.filter((entry) => !entry.entry.compileOnly).length
     const compileCount = ranked.length - runtimeCount
     return [
         note,
+        precisionNote,
         `Dependents of ${n.label ?? id} (reverse calls/imports/inherits, depth ≤${maxDepth}): ${ranked.length} found (${runtimeCount} runtime, ${compileCount} compile-time-only), showing ${shown.length} by proximity + connectivity.`,
         containingFile ? `Includes importers of its containing file ${labelOf(g, containingFile)} by explicit request.` : null,
         ...shown.map((r) => `  [d${r.d} ${impactKind(r.entry)}] ${r.entry.relation || 'rel'} [${r.entry.provenance || 'UNKNOWN'}]  ${labelOf(g, r.id)}  (deg ${r.deg})  [${r.id}]`),
     ].filter(Boolean).join('\n')
 }
 
+export function tGetDependents(g, args = {}, ctx = {}) {
+    const info = resolveNodeInfo(g, args.label)
+    const id = String(info.node?.id || '')
+    const requested = ['auto', 'graph', 'lsp'].includes(args.precision) ? args.precision : 'auto'
+    const canQuery = isSymbol(id) && ctx.repoRoot && ctx.graphPath
+        && (requested === 'lsp' || (requested === 'auto' && g.graphPrecisionMode !== 'off'))
+    if (!canQuery) {
+        const note = isSymbol(id) && requested !== 'graph'
+            ? 'Semantic precision: graph-only; an exact point query was unavailable or disabled.' : null
+        return getDependentsFromGraph(g, args, note)
+    }
+    return (async () => {
+        try {
+            const result = await querySymbolPrecision({
+                repoRoot: ctx.repoRoot,
+                graphPath: ctx.graphPath,
+                targetId: id,
+                maxReferences: Math.max(100, Math.min(5_000, Number(args.max_references) || 1_000)),
+                timeoutMs: Math.max(1_000, Math.min(60_000, Number(args.timeout_ms) || 30_000)),
+                clientFactory: ctx.precisionClientFactory,
+            })
+            const exactGraph = graphWithExactDirectReferences(g, id, result.overlay)
+            if (exactGraph) {
+                const count = (result.overlay.links || []).filter((link) => String(link?.target || '') === id).length
+                return getDependentsFromGraph(
+                    exactGraph,
+                    args,
+                    `Semantic precision: EXACT_LSP point query${result.cached ? ' (cache hit)' : ''}; ${count} classified direct reference edge(s).`,
+                )
+            }
+            return getDependentsFromGraph(
+                g,
+                args,
+                `Semantic precision: ${result.overlay?.state || 'UNAVAILABLE'}; exact absence was not proven, so graph edges are retained (${result.overlay?.reason || 'incomplete project coverage'}).`,
+            )
+        } catch (error) {
+            return getDependentsFromGraph(
+                g,
+                args,
+                `Semantic precision: UNAVAILABLE; graph evidence retained (${error?.message || 'point query failed'}).`,
+            )
+        }
+    })()
+}
+
 // Re-query the last rebuild's before/after pair (graph.prev.json vs graph.json), optionally scoped.
 export async function tGraphDiff(g, args, ctx) {
     const current = rawGraph(ctx)
@@ -106,98 +150,12 @@ export async function tGraphDiff(g, args, ctx) {
 }
 
 // ---- change impact -------------------------------------------------------------------------------
-function resolveImpactBase(repoRoot, requested) {
-    const candidates = requested ? [requested] : ['origin/HEAD', 'origin/main', 'origin/master', 'main', 'master']
-    for (const ref of candidates) {
-        const ok = spawnSync('git', ['-C', repoRoot, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {encoding: 'utf8', timeout: 8000, env: childProcessEnv()})
-        if (ok.status === 0) return ref
-    }
-    return null
-}
-
 // Blast radius of a change, without any GitHub API: diff the CURRENT change (branch
 // commits since the merge-base + staged/unstaged + untracked) against a base ref, map the changed
 // files and their symbols onto the graph, and walk REVERSE dependency edges — everything the change
 // can break, ranked by proximity + connectivity, with file-level test coverage attached so the
 // untested part of the blast radius stands out. The pre-PR review, in one call.
 export function tChangeImpact(g, args, ctx) {
-    return tChangeImpactV2(g, args, ctx)
-}
-
-// Kept private during the v2 rollout so the surrounding get_dependents/graph_diff implementation is
-// untouched; focused tests exercise the exported symbol-aware path above.
-function tChangeImpactLegacy(g, args, ctx) {
-    if (!ctx.repoRoot) return 'change_impact needs the repo root (not provided to this server).'
-    // Explicit file list (e.g. a PR's changed files) skips the local git diff entirely — this is how
-    // a NOT-checked-out PR gets its impact assessed.
-    const explicit = Array.isArray(args.files)
-        ? [...new Set(args.files.map((f) => String(f).replace(/\\/g, '/').trim()).filter(Boolean))]
-        : null
-    let changed
-    let sourceLabel
-    if (explicit) {
-        if (!explicit.length) return 'files was provided but empty — pass repo-relative paths, or omit it to diff the local change.'
-        changed = explicit
-        sourceLabel = `for ${changed.length} provided file(s)`
-    } else {
-        const base = resolveImpactBase(ctx.repoRoot, args.base ? String(args.base).trim() : '')
-        if (!base) return `Could not resolve a base ref${args.base ? ` ("${args.base}")` : ''} — pass base explicitly (e.g. origin/main or HEAD~1).`
-        const committed = gitLines(ctx.repoRoot, ['diff', '--name-only', `${base}...HEAD`])
-        if (committed === null) return `git diff against ${base} failed — is ${ctx.repoRoot} a git repository?`
-        const uncommitted = gitLines(ctx.repoRoot, ['diff', '--name-only', 'HEAD']) || []
-        const untracked = gitLines(ctx.repoRoot, ['ls-files', '--others', '--exclude-standard']) || []
-        changed = [...new Set([...committed, ...uncommitted, ...untracked])]
-        sourceLabel = `vs ${base}`
-        if (!changed.length) return `No changes vs ${base} — working tree clean and no branch commits.`
-    }
-
-    const changedSet = new Set(changed)
-    const seeds = new Set()
-    const unmapped = []
-    for (const file of changed) {
-        if (!g.byId.has(file)) { unmapped.push(file); continue }
-        seeds.add(file)
-        for (const e of g.out.get(file) || []) if (e.relation === 'contains') seeds.add(String(e.id))
-    }
-    if (!seeds.size) {
-        return [
-            `${changed.length} changed file(s) ${sourceLabel}, but none are in the graph — new files or non-code.`,
-            `Run rebuild_graph and retry for the full picture.`,
-            `Changed: ${changed.slice(0, 20).join(', ')}${changed.length > 20 ? ', …' : ''}`,
-        ].join('\n')
-    }
-
-    const maxDepth = Math.max(1, Math.min(4, Number(args.depth) || 2))
-    const cap = Math.max(5, Math.min(120, Number(args.max_nodes) || 40))
-    const reached = reverseReach(g, seeds, maxDepth)
-    const fileOfNode = (id) => { const s = String(id); const h = s.indexOf('#'); return h < 0 ? s : s.slice(0, h) }
-    const impacted = [...reached.entries()]
-        .filter(([nid]) => !seeds.has(nid) && !changedSet.has(fileOfNode(nid)))
-        .map(([nid, entry]) => ({id: nid, d: entry.depth, entry, deg: degreeOf(g, nid), file: fileOfNode(nid)}))
-        .sort((a, b) => a.d - b.d || Number(a.entry.compileOnly) - Number(b.entry.compileOnly) || b.deg - a.deg)
-
-    // coverage overlay from EXISTING reports (fractions 0..1) — see coverage_map for details
-    const knownFiles = (rawGraph(ctx).nodes || []).filter((n) => !String(n.id).includes('#') && n.source_file).map((n) => n.source_file)
-    const coverage = readCoverageForRepo(ctx.repoRoot, knownFiles)
-    const covOf = (file) => coverage.get(String(file).replace(/\\/g, '/'))?.pct ?? null
-    const pctStr = (v) => (v == null ? 'cov n/a' : `cov ${Math.round(v * 100)}%`)
-    const hasCoverage = coverage.size > 0
-
-    const shown = impacted.slice(0, cap)
-    const runtimeImpacted = impacted.filter((entry) => !entry.entry.compileOnly).length
-    const compileImpacted = impacted.length - runtimeImpacted
-    const untestedHotspots = shown.filter((n) => { const c = covOf(n.file); return c != null && c < 0.5 && n.deg >= 5 })
-    return [
-        `Change impact ${sourceLabel}: ${changed.length} changed file(s) → ${seeds.size} graph seed(s) incl. their symbols${unmapped.length ? `; ${unmapped.length} file(s) not in the graph (new/non-code — rebuild_graph refreshes)` : ''}.`,
-        impacted.length
-            ? `${impacted.length} impacted node(s) within ${maxDepth} reverse hop(s) (${runtimeImpacted} runtime, ${compileImpacted} compile-time-only), showing ${shown.length}:`
-            : `Nothing else in the graph depends on the changed code within ${maxDepth} hop(s).`,
-        hasCoverage ? `Coverage: existing report mapped where available.` : `Coverage: unavailable (no supported report found); per-node coverage labels omitted.`,
-        ...shown.map((n) => `  [d${n.d} ${impactKind(n.entry)}] ${n.entry.relation || 'rel'}  ${labelOf(g, n.id)}  (deg ${n.deg}${hasCoverage ? `, ${pctStr(covOf(n.file))}` : ''})  [${n.id}]`),
-        untestedHotspots.length ? `` : null,
-        untestedHotspots.length ? `Untested hotspots in the blast radius (<50% coverage, deg ≥5) — cover these before shipping:` : null,
-        ...untestedHotspots.slice(0, 10).map((n) => `  ${labelOf(g, n.id)}  (${pctStr(covOf(n.file))}, deg ${n.deg})  ${n.file}`),
-        ``,
-        `Drill into any node with get_dependents / read_source; per-symbol coverage via coverage_map.`,
-    ].filter((x) => x != null).join('\n')
+    const baseline = tChangeImpactV2(g, args, ctx)
+    return refineChangeImpact(g, args, ctx, baseline, tChangeImpactV2)
 }

package/src/precision/lsp-overlay/build.js

@@ -51,8 +51,14 @@ function completedOverlay(session) {
       language: 'typescript/javascript',
       capability: 'textDocument/references',
       status: state,
+      configuredPluginsSuppressed: session.semanticInputs.pluginsSuppressed || 0,
+      repoLocalPluginLoads: false,
     }],
     semanticInputFingerprint: session.semanticInputs.fingerprint,
+    pluginPolicy: {
+      configuredPluginsSuppressed: session.semanticInputs.pluginsSuppressed || 0,
+      repoLocalPluginLoads: false,
+    },
     coverage: coverage(session),
     links: session.links,
     referenceEvidence: session.referenceEvidence,
@@ -181,6 +187,10 @@ export async function buildLspPrecisionOverlay({
     return persist(session, baseOverlay(graph, 'COMPLETE', {
       request: session.request,
       semanticInputFingerprint: session.semanticInputs.fingerprint,
+      pluginPolicy: {
+        configuredPluginsSuppressed: session.semanticInputs.pluginsSuppressed || 0,
+        repoLocalPluginLoads: false,
+      },
       reason: 'no eligible JavaScript/TypeScript semantic targets',
     }))
   }

package/src/precision/lsp-overlay/contract.js

@@ -1,6 +1,6 @@
 import {typeScriptLspContract} from '../typescript-lsp-provider.js'
 
-export const PRECISION_OVERLAY_V = 3
+export const PRECISION_OVERLAY_V = 4
 export const PRECISION_FILE = 'precision.json'
 export const JS_TS_FILE = /\.(?:[cm]?[jt]sx?)$/i
 export const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value)

package/src/precision/symbol-query.js

@@ -182,3 +182,42 @@ export async function querySymbolPrecision({
         inFlight.delete(flightKey)
     }
 }
+
+export async function querySymbolsPrecision({
+    repoRoot,
+    graphPath,
+    targetIds,
+    maxReferences = 5_000,
+    timeoutMs = 45_000,
+    clientFactory,
+} = {}) {
+    if (!repoRoot || !graphPath || !Array.isArray(targetIds) || !targetIds.length) {
+        throw new Error('batch symbol precision requires repoRoot, graphPath, and targetIds')
+    }
+    const ids = [...new Set(targetIds.map(String).filter(Boolean))].slice(0, 16)
+    const boundedReferences = boundedInteger(maxReferences, 5_000, 1, 16_384)
+    const boundedTimeout = boundedInteger(timeoutMs, 45_000, 1_000, 60_000)
+    const rawGraph = loadRawGraph(graphPath)
+    const graph = rawGraph.graphPrecisionMode === 'off' ? {...rawGraph, graphPrecisionMode: 'lsp'} : rawGraph
+    const nodes = new Map((graph.nodes || []).map((node) => [String(node?.id || ''), node]))
+    for (const id of ids) {
+        const target = nodes.get(id)
+        if (!target) throw new Error(`precision target is absent from the active graph: ${id}`)
+        if (!target.selection_start || !/\.(?:[cm]?[jt]sx?)$/i.test(String(target.source_file || ''))) {
+            throw new Error(`exact batch precision does not support target: ${id}`)
+        }
+    }
+    const startedAt = Date.now()
+    const overlay = await buildLspPrecisionOverlay({
+        repoRoot,
+        graph,
+        mode: 'lsp',
+        maxSymbols: ids.length,
+        maxReferences: boundedReferences,
+        maxLinks: boundedReferences,
+        timeoutMs: boundedTimeout,
+        targetIds: ids,
+        clientFactory,
+    })
+    return {overlay, targetIds: ids, elapsedMs: Date.now() - startedAt}
+}

package/src/precision/typescript-provider/client.js

@@ -6,11 +6,13 @@ import {
     typeScriptLanguageId,
     typeScriptLspContract,
 } from './discovery.js'
+import {isolateTypeScriptRuntime} from './isolated-runtime.js'
 
 /** Starts Weavatrix's bundled TypeScript server without executing repository configuration. */
 export async function createTypeScriptLspClient({repoRoot, timeoutMs = 10_000} = {}) {
     const discovered = discoverTypeScriptProvider()
     const absoluteRepoRoot = resolve(repoRoot)
+    const isolated = isolateTypeScriptRuntime(discovered.tsserverPath)
     let client
     let reportedTypeScript = null
     try {
@@ -41,11 +43,16 @@ export async function createTypeScriptLspClient({repoRoot, timeoutMs = 10_000} =
             initializationOptions: {
                 hostInfo: 'weavatrix',
                 disableAutomaticTypingAcquisition: true,
-                tsserver: {path: discovered.tsserverPath},
+                tsserver: {path: isolated.tsserverPath},
+                // An explicit empty list keeps the language-server plugin manager
+                // from adding --globalPlugins or --pluginProbeLocations. tsserver's
+                // local-plugin loading remains disabled by default as well.
+                plugins: [],
             },
         })
     } catch (error) {
         client?.kill(error)
+        isolated.cleanup()
         throw error
     }
     return Object.freeze({
@@ -63,7 +70,13 @@ export async function createTypeScriptLspClient({repoRoot, timeoutMs = 10_000} =
         },
         definition(relPath, position) { return client.definition({filePath: relPath, position}) },
         closeDocument(relPath) { return client.closeDocument(relPath) },
-        close(shutdownTimeoutMs = timeoutMs) { return client.shutdown({timeoutMs: shutdownTimeoutMs}) },
-        kill() { client.kill() },
+        async close(shutdownTimeoutMs = timeoutMs) {
+            try { return await client.shutdown({timeoutMs: shutdownTimeoutMs}) }
+            finally { isolated.cleanup() }
+        },
+        kill() {
+            try { client.kill() }
+            finally { isolated.cleanup() }
+        },
     })
 }

package/src/precision/typescript-provider/discovery.js

@@ -4,7 +4,7 @@ import {createRequire} from 'node:module'
 
 const requireFromWeavatrix = createRequire(import.meta.url)
 export const PROVIDER = 'typescript-language-server'
-export const TYPESCRIPT_LSP_CAPABILITY_CONTRACT = 'typescript-references-v3'
+export const TYPESCRIPT_LSP_CAPABILITY_CONTRACT = 'typescript-references-v4-plugin-suppression'
 let discoveredProvider = null
 
 function resolveOwn(specifier) {

package/src/precision/typescript-provider/isolated-runtime.js

@@ -0,0 +1,39 @@
+import {copyFileSync, linkSync, mkdirSync, mkdtempSync, readdirSync, rmSync} from 'node:fs'
+import {tmpdir} from 'node:os'
+import {basename, dirname, join} from 'node:path'
+
+const RUNTIME_FILES = new Set([
+    'tsserver.js', '_tsserver.js', 'typescript.js',
+    'typingsInstaller.js', '_typingsInstaller.js', 'typesMap.json', 'watchGuard.js',
+])
+
+function materialize(source, target) {
+    try { linkSync(source, target) }
+    catch { copyFileSync(source, target) }
+}
+
+export function isolateTypeScriptRuntime(tsserverPath) {
+    const sourceLib = dirname(tsserverPath)
+    const sourceRoot = dirname(sourceLib)
+    const root = mkdtempSync(join(tmpdir(), 'weavatrix-tsserver-'))
+    const lib = join(root, 'lib')
+    mkdirSync(lib, {recursive: true, mode: 0o700})
+    try {
+        materialize(join(sourceRoot, 'package.json'), join(root, 'package.json'))
+        const files = readdirSync(sourceLib).filter((name) =>
+            RUNTIME_FILES.has(name) || /^lib(?:\..+)?\.d\.ts$/i.test(name))
+        for (const name of files) materialize(join(sourceLib, name), join(lib, basename(name)))
+        let cleaned = false
+        return {
+            tsserverPath: join(lib, 'tsserver.js'),
+            cleanup() {
+                if (cleaned) return
+                cleaned = true
+                try { rmSync(root, {recursive: true, force: true}) } catch { /* process cleanup fallback */ }
+            },
+        }
+    } catch (error) {
+        try { rmSync(root, {recursive: true, force: true}) } catch { /* best effort */ }
+        throw error
+    }
+}

package/src/precision/typescript-provider/project-host.js

@@ -154,7 +154,7 @@ export function parseRepoConfig(context, configPath, budget) {
     const state = {
         outsideAccess: false,
         limitExceeded: false,
-        configuredPlugins: false,
+        configuredPlugins: new Set(),
         bytes: 0,
         records: new Map(),
     }
@@ -197,8 +197,9 @@ export function parseRepoConfig(context, configPath, budget) {
             }
             try {
                 const raw = ts.parseConfigFileTextToJson(path, body.toString('utf8')).config
-                if (Array.isArray(raw?.compilerOptions?.plugins) && raw.compilerOptions.plugins.length) {
-                    state.configuredPlugins = true
+                for (const plugin of raw?.compilerOptions?.plugins || []) {
+                    const name = typeof plugin?.name === 'string' ? plugin.name.trim() : ''
+                    if (name) state.configuredPlugins.add(name.slice(0, 256))
                 }
             } catch { /* parser diagnostics below decide safety */ }
             return body.toString('utf8')
@@ -213,8 +214,9 @@ export function parseRepoConfig(context, configPath, budget) {
     try { parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, host) }
     catch { return {complete: false, reason: 'CONFIG_PARSE_FAILED'} }
     const errors = [...diagnostics, ...(parsed?.errors || [])]
-    if (state.configuredPlugins || (Array.isArray(parsed?.options?.plugins) && parsed.options.plugins.length)) {
-        return {complete: false, reason: 'CONFIGURED_TSSERVER_PLUGINS'}
+    for (const plugin of parsed?.options?.plugins || []) {
+        const name = typeof plugin?.name === 'string' ? plugin.name.trim() : ''
+        if (name) state.configuredPlugins.add(name.slice(0, 256))
     }
     if (budget.reason) return {complete: false, reason: budget.reason}
     if (!parsed || state.outsideAccess || state.limitExceeded
@@ -244,6 +246,9 @@ export function parseRepoConfig(context, configPath, budget) {
         projectFiles,
         projectKeys,
         configRecords: state.records,
-        plugins: [],
+        // The bundled provider runs an isolated tsserver copy whose plugin search
+        // root contains only TypeScript runtime files. Keep configured plugin names
+        // as evidence, but never execute them from the inspected repository/bundle.
+        plugins: [...state.configuredPlugins].sort(),
     }
 }