weavatrix 0.3.14 → 1.0.0

package/src/mcp/tools-endpoints.mjs

@@ -1,207 +0,0 @@
-import {posix} from 'node:path'
-import {analyzeEndpointInventory} from '../analysis/endpoints.js'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-import {sourceExcerpt} from './tools-source.mjs'
-import {toolResult} from './tool-result.mjs'
-
-const NON_PRODUCT = ['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp']
-
-const symbolLine = (node) => Number(String(node?.source_location || '').match(/L(\d+)/)?.[1]
-    || String(node?.id || '').match(/@(\d+)$/)?.[1] || 0)
-
-const symbolName = (node) => String(node?.label || node?.id || '')
-    .replace(/\([^)]*\).*$/, '')
-    .split(/[.#]/).at(-1)
-    .trim()
-
-function codeFiles(graph) {
-    return [...new Set((graph?.nodes || [])
-        .filter((node) => !String(node.id).includes('#') && node.source_file && node.file_type === 'code')
-        .map((node) => node.source_file))]
-}
-
-function endpointCandidates(inventory, args) {
-    const path = String(args.path || '').trim()
-    const method = args.method ? String(args.method).toUpperCase() : null
-    if (!path) return []
-    const eligible = inventory.endpoints.filter((endpoint) => !method || endpoint.method === method)
-    const exact = eligible.filter((endpoint) => endpoint.path === path)
-    return exact.length ? exact : eligible.filter((endpoint) => endpoint.path.endsWith(path))
-}
-
-// A handler_file hint narrows the FULL same-named pool before any scoring, so it can rescue a
-// candidate the ranking would otherwise collapse away. An exact repo-relative match beats suffix
-// matches; comparison is case-insensitive (Windows paths and human-typed hints disagree on casing).
-function matchesHandlerHint(file, hint) {
-    if (!hint) return true
-    const lower = file.toLowerCase()
-    return lower === hint || lower.endsWith(`/${hint}`)
-}
-
-function handlerCandidates(graph, endpoint, hint = '') {
-    if (!endpoint.handler) return []
-    const wanted = endpoint.handler.toLowerCase()
-    const qualifier = String(endpoint.handlerRef || '').split('.').slice(-2, -1)[0]?.toLowerCase() || ''
-    const routeDir = posix.dirname(endpoint.file)
-    // File-level import/re-export bindings at the route file break same-name ties between otherwise
-    // unranked candidates. The bonus deliberately sits BELOW same-directory proximity (+40): a
-    // file-level edge proves coupling, not symbol identity, and must never outrank the conventional
-    // same-package/same-dir handler (Go same-package files have no import edge at all).
-    const importBound = new Set()
-    for (const edge of graph.out.get(endpoint.file) || []) {
-        if (edge.relation !== 'imports' && edge.relation !== 're_exports') continue
-        if (edge.typeOnly === true || edge.barrelProxy === true) continue
-        const targetId = String(edge.id)
-        if (targetId.includes('#')) continue
-        const target = graph.byId.get(targetId)
-        importBound.add(String(target?.source_file || targetId).replace(/\\/g, '/'))
-    }
-    let pool = (graph.nodes || [])
-        .filter((node) => String(node.id).includes('#') && node.source_file && symbolName(node).toLowerCase() === wanted)
-    if (hint) {
-        pool = pool.filter((node) => matchesHandlerHint(String(node.source_file).replace(/\\/g, '/').toLowerCase(), hint))
-        const exact = pool.filter((node) => String(node.source_file).replace(/\\/g, '/').toLowerCase() === hint)
-        if (exact.length) pool = exact
-    }
-    const scored = pool
-        .map((node) => {
-            const file = String(node.source_file).replace(/\\/g, '/')
-            let score = 0
-            const importBoundAtRoute = importBound.has(file)
-            if (file === endpoint.file) score += 100
-            if (importBoundAtRoute) score += 35
-            if (posix.dirname(file) === routeDir) score += 40
-            if (file.startsWith(`${routeDir}/`)) score += 15
-            if (qualifier) {
-                const basename = posix.basename(file).replace(/\.[^.]+$/, '').toLowerCase()
-                if (basename === qualifier || basename.endsWith(`.${qualifier}`) || basename.endsWith(`-${qualifier}`)) score += 60
-            }
-            const line = symbolLine(node)
-            if (file === endpoint.file && line >= endpoint.line && line - endpoint.line <= 250) score += 20
-            return {node, score, importBoundAtRoute}
-        })
-        .sort((a, b) => b.score - a.score || String(a.node.id).localeCompare(String(b.node.id)))
-    if (!scored.length) return []
-    const best = scored[0].score
-    return scored.filter((item) => item.score === best).map(({node, importBoundAtRoute}) => ({node, importBoundAtRoute}))
-}
-
-function traceCalls(graph, start, {maxDepth, maxNodes, includeClassified, classifier}) {
-    const allowed = (node) => {
-        if (!node?.source_file) return false
-        if (includeClassified) return true
-        const info = classifier.explain(node.source_file, {content: ''})
-        return !info?.excluded && !NON_PRODUCT.some((name) => hasPathClass(info, name))
-    }
-    const queue = [{id: String(start.id), depth: 0}]
-    const seen = new Set([String(start.id)])
-    const edges = []
-    let truncated = false
-    for (let cursor = 0; cursor < queue.length; cursor++) {
-        const current = queue[cursor]
-        if (current.depth >= maxDepth) continue
-        const outgoing = (graph.out.get(current.id) || [])
-            .filter((edge) => edge.relation === 'calls' && edge.typeOnly !== true && edge.compileOnly !== true && edge.barrelProxy !== true)
-            .map((edge) => ({edge, target: graph.byId.get(String(edge.id))}))
-            .filter(({target}) => target && String(target.id).includes('#') && allowed(target))
-            .sort((a, b) => (Number(a.edge.line) || 0) - (Number(b.edge.line) || 0) || String(a.target.id).localeCompare(String(b.target.id)))
-        const unique = new Set()
-        for (const {edge, target} of outgoing) {
-            const targetId = String(target.id)
-            if (unique.has(targetId)) continue
-            unique.add(targetId)
-            if (edges.length >= maxNodes - 1) { truncated = true; break }
-            edges.push({
-                from: current.id,
-                to: targetId,
-                depth: current.depth + 1,
-                relation: edge.relation,
-                provenance: edge.provenance || 'UNKNOWN',
-                line: Number(edge.line) || symbolLine(graph.byId.get(current.id)) || 1,
-            })
-            if (!seen.has(targetId)) {
-                seen.add(targetId)
-                queue.push({id: targetId, depth: current.depth + 1})
-            }
-            if (unique.size >= 6) { truncated = outgoing.length > unique.size; break }
-        }
-        if (truncated && edges.length >= maxNodes - 1) break
-    }
-    return {edges, truncated, nodeCount: seen.size}
-}
-
-function endpointLine(endpoint) {
-    const mount = endpoint.mountChain?.length
-        ? endpoint.mountChain.map((item) => `${item.file}:${item.line} ${item.path}`).join(' → ')
-        : 'no static router mount chain'
-    const activation = endpoint.conditional
-        ? `; conditional default ${endpoint.defaultActive === false ? 'inactive' : endpoint.defaultActive === true ? 'active' : 'unknown'}`
-        : ''
-    return `${endpoint.method} ${endpoint.path} → ${endpoint.handler || 'inline/unknown'} (${endpoint.file}:${endpoint.line}; ${endpoint.mountState}/${endpoint.confidence}${activation}; declared ${endpoint.declaredPath}; ${mount})`
-}
-
-export function tTraceEndpoint(graph, args, ctx) {
-    if (!ctx?.repoRoot) return 'Endpoint tracing needs the repo root (not provided to this server).'
-    const inventory = analyzeEndpointInventory(ctx.repoRoot, codeFiles(graph))
-    const candidates = endpointCandidates(inventory, args)
-    if (!candidates.length) return toolResult(`No endpoint matched ${args.method ? `${String(args.method).toUpperCase()} ` : ''}${args.path || '(missing path)'}.`, {
-        status: 'NOT_FOUND', query: {path: args.path || null, method: args.method || null}, inventory: inventory.stats,
-    })
-    if (candidates.length > 1) return toolResult([
-        `Endpoint query is ambiguous (${candidates.length} matches). Pass the exact composed path and method:`,
-        ...candidates.slice(0, 20).map((endpoint) => `  ${endpointLine(endpoint)}`),
-    ].join('\n'), {status: 'AMBIGUOUS', candidates: candidates.slice(0, 20), inventory: inventory.stats}, {
-        completeness: {status: 'PARTIAL', reason: 'ambiguous endpoint'},
-    })
-    const endpoint = candidates[0]
-    const classifier = createPathClassifier(ctx.repoRoot)
-    const classify = (file) => {
-        const info = classifier.explain(file, {content: ''})
-        return {classified: info.excluded || NON_PRODUCT.some((name) => hasPathClass(info, name)), pathClasses: info.classes}
-    }
-    const hint = String(args.handler_file || '').trim().replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
-    let handlers = handlerCandidates(graph, endpoint, hint)
-        .map((item) => ({...item, ...classify(String(item.node.source_file).replace(/\\/g, '/'))}))
-    // Production-first: a classified twin (tests/mocks/…) never ties with a production candidate,
-    // but an all-classified candidate set is kept rather than emptied.
-    if (args.include_classified !== true && handlers.some((item) => !item.classified)) {
-        handlers = handlers.filter((item) => !item.classified)
-    }
-    if (handlers.length !== 1) return toolResult([
-        `Endpoint resolved, but its handler symbol is ${handlers.length ? 'ambiguous' : `not present in the graph${hint ? ` (no candidate matched handler_file "${hint}")` : ''}`}:`,
-        `  ${endpointLine(endpoint)}`,
-        ...handlers.slice(0, 12).map(({node, importBoundAtRoute, pathClasses}) => `  candidate ${node.label || node.id} (${node.source_file}:${symbolLine(node) || '?'}; import-bound at route: ${importBoundAtRoute ? 'yes' : 'no'}${pathClasses.length ? `; classified:${pathClasses.join('+')}` : ''}) [${node.id}]`),
-        ...(handlers.length > 1 ? ['  Next: pass handler_file with the repo-relative path (or an unambiguous path suffix) of the file that declares the intended handler.'] : []),
-    ].join('\n'), {status: handlers.length ? 'AMBIGUOUS_HANDLER' : 'HANDLER_NOT_FOUND', endpoint, handlers: handlers.map(({node, importBoundAtRoute, pathClasses}) => ({...node, importBoundAtRoute, pathClasses}))}, {
-        completeness: {status: 'PARTIAL', reason: handlers.length ? 'ambiguous handler symbol' : 'handler symbol not found'},
-    })
-
-    const maxDepth = Math.max(1, Math.min(4, Number(args.max_depth) || 3))
-    const maxNodes = Math.max(2, Math.min(40, Number(args.max_nodes) || 20))
-    const contextLines = Math.max(0, Math.min(6, Number(args.context_lines) || 2))
-    const maxExcerpts = Math.max(0, Math.min(12, Number(args.max_excerpts) || 6))
-    const handler = handlers[0].node
-    const traced = traceCalls(graph, handler, {
-        maxDepth, maxNodes, includeClassified: args.include_classified === true, classifier,
-    })
-    const excerpts = traced.edges.slice(0, maxExcerpts).map((edge) => {
-        const source = graph.byId.get(edge.from)
-        return sourceExcerpt(ctx.repoRoot, source?.source_file, edge.line, contextLines)
-    }).filter(Boolean)
-    const lines = [
-        `Endpoint trace (${traced.truncated ? 'PARTIAL' : 'COMPLETE'}; depth ≤${maxDepth}, nodes ${traced.nodeCount}/${maxNodes}):`,
-        `  ${endpointLine(endpoint)}`,
-        `  handler ${handler.label || handler.id} (${handler.source_file}:${symbolLine(handler) || '?'}) [${handler.id}]`,
-        traced.edges.length ? 'Call graph:' : 'Call graph: no outgoing call edges from the resolved handler.',
-        ...traced.edges.map((edge) => {
-            const from = graph.byId.get(edge.from), to = graph.byId.get(edge.to)
-            return `  ${'  '.repeat(Math.max(0, edge.depth - 1))}${from?.label || edge.from} → ${to?.label || edge.to} (${from?.source_file}:${edge.line}; ${edge.provenance})`
-        }),
-        ...excerpts.flatMap((excerpt) => ['', `Call-site excerpt (${excerpt.file}:${excerpt.startLine}-${excerpt.endLine}, focus ${excerpt.focusLine}):`, excerpt.text]),
-    ]
-    return toolResult(lines.join('\n'), {
-        status: traced.truncated ? 'PARTIAL' : 'COMPLETE', endpoint, handler: {
-            id: String(handler.id), label: handler.label || String(handler.id), file: handler.source_file, line: symbolLine(handler),
-        }, trace: traced, excerpts, inventory: inventory.stats,
-    }, {completeness: {status: traced.truncated ? 'PARTIAL' : 'COMPLETE', reason: traced.truncated ? 'bounded trace cap reached' : 'bounded outgoing call graph exhausted'}})
-}

package/src/mcp/tools-graph-hubs.mjs

@@ -1,78 +0,0 @@
-// Connectivity-hub reporting, split from the general graph query tools.
-import {connList} from './graph-context.mjs'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-
-const isCompileTimeEdge = (edge) => edge?.typeOnly === true || edge?.compileOnly === true
-const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
-const sourceFileOf = (node) => String(node?.source_file || (node?.file_type === 'code' ? node?.id : '') || '').replace(/\\/g, '/')
-
-export function tGodNodes(g, {top_n = 10, include_classified = false} = {}, ctx = {}) {
-    const n = Math.max(1, Math.min(100, Number(top_n) || 10))
-    const classifier = createPathClassifier(ctx.repoRoot || null)
-    const classificationByFile = new Map()
-    const isNonProduct = (node) => {
-        if (include_classified === true) return false
-        if (node?.test_surface === true) return true
-        const file = sourceFileOf(node)
-        if (!file) return false
-        if (!classificationByFile.has(file)) classificationByFile.set(file, classifier.explain(file))
-        const info = classificationByFile.get(file)
-        return info.excluded || hasPathClass(info, ...NON_PRODUCT_CLASSES)
-    }
-    const excludedIds = new Set(g.nodes.filter(isNonProduct).map((node) => String(node.id)))
-    const scored = g.nodes
-        .filter((node) => !excludedIds.has(String(node.id)))
-        .map((node) => {
-            // Coupling from a suppressed artifact must not inflate an otherwise valid product hub.
-            const rawOuts = (g.out.get(String(node.id)) || []).filter((edge) => !excludedIds.has(String(edge.id)))
-            const rawIns = (g.inn.get(String(node.id)) || []).filter((edge) => !excludedIds.has(String(edge.id)))
-            const outs = connList(rawOuts)
-            const ins = connList(rawIns)
-            const ownedMethods = new Set(rawOuts.filter((e) => e.relation === 'method').map((e) => String(e.id)))
-            const outIds = new Set(outs.map((e) => String(e.id)))
-            const inIds = new Set(ins.map((e) => String(e.id)))
-            const allIds = new Set([...outIds, ...inIds])
-            const runtimeIds = new Set([...outs, ...ins].filter((e) => !isCompileTimeEdge(e)).map((e) => String(e.id)))
-            const compileOnlyIds = new Set([...outs, ...ins].filter(isCompileTimeEdge).map((e) => String(e.id)))
-            for (const id of runtimeIds) compileOnlyIds.delete(id)
-            const occurrences = outs.length + ins.length
-            return {
-                node,
-                deg: allIds.size,
-                runtime: runtimeIds.size,
-                compileOnly: compileOnlyIds.size,
-                out: outIds.size,
-                in: inIds.size,
-                occurrences,
-                ownedMethods: ownedMethods.size,
-            }
-        })
-        .filter((entry) => entry.deg > 0 || entry.ownedMethods > 0)
-        .sort((a, b) => b.runtime - a.runtime || b.deg - a.deg || b.ownedMethods - a.ownedMethods || b.occurrences - a.occurrences)
-    const ranked = scored.slice(0, n)
-    const rankedIds = new Set(ranked.map((entry) => String(entry.node.id)))
-    // Unique neighbors measure coupling, but a large component repeatedly calling the same helper (for
-    // example i18n) can still be a valuable complexity hotspot. Preserve that second lens explicitly
-    // instead of letting repeated sites inflate the coupling rank.
-    const occurrenceHotspots = scored
-        .filter((entry) => !rankedIds.has(String(entry.node.id)))
-        .filter((entry) => entry.occurrences >= 20 && entry.occurrences - entry.deg >= 10)
-        .sort((a, b) => (b.occurrences - b.deg) - (a.occurrences - a.deg) || b.occurrences - a.occurrences)
-        .slice(0, Math.min(5, n))
-    return [
-        `Top ${ranked.length} connectivity hubs (ranked by unique runtime call/import/reference neighbors; structural ownership shown separately):`,
-        ...ranked.map(
-            (r, i) =>
-                `${String(i + 1).padStart(2)}. ${r.node.label ?? r.node.id}  (${r.deg} unique: ${r.runtime} runtime, ${r.compileOnly} compile-only; out ${r.out}, in ${r.in}; ${r.occurrences} edge occurrence${r.occurrences === 1 ? '' : 's'}${r.ownedMethods ? `; owns ${r.ownedMethods} method${r.ownedMethods === 1 ? '' : 's'}` : ''})  [${r.node.id}]`
-        ),
-        `Repeated call sites affect the occurrence count, not the connectivity rank; compile-only neighbors are secondary to runtime coupling.`,
-        occurrenceHotspots.length ? `` : null,
-        occurrenceHotspots.length ? `High occurrence hotspots outside the connectivity rank (repeated call/reference sites; complexity signal, not broader coupling):` : null,
-        ...occurrenceHotspots.map((r) =>
-            `  ${r.node.label ?? r.node.id}  (${r.occurrences} occurrences across ${r.deg} unique neighbors; ${r.occurrences - r.deg} repeats)  [${r.node.id}]`
-        ),
-        excludedIds.size > 0 && include_classified !== true
-            ? `${excludedIds.size} node(s) classified as tests/e2e/generated/build output/mocks/stories/docs/benchmarks/temp or explicitly excluded were omitted; pass include_classified:true to inspect them.`
-            : null,
-    ].filter((line) => line != null).join('\n')
-}

package/src/mcp/tools-graph.mjs

@@ -1,17 +0,0 @@
-// Stable public facade for graph inspection and traversal tools. Propagate the catalog's
-// cache-busting query into owner modules so edits go live without an MCP reconnect.
-const version = new URL(import.meta.url).search
-const load = (path) => import(new URL(`${path}${version}`, import.meta.url).href)
-const [core, query, hubs] = await Promise.all([
-    load('./graph/tools-core.mjs'),
-    load('./graph/tools-query.mjs'),
-    load('./tools-graph-hubs.mjs'),
-])
-
-export const tGraphStats = core.tGraphStats
-export const tGetNode = core.tGetNode
-export const tGetNeighbors = core.tGetNeighbors
-export const tGetCommunity = core.tGetCommunity
-export const tQueryGraph = query.tQueryGraph
-export const tShortestPath = query.tShortestPath
-export const tGodNodes = hubs.tGodNodes

package/src/mcp/tools-health.mjs

@@ -1,24 +0,0 @@
-// Propagate catalog.mjs's cache-busting query to owner modules so development hot reload remains
-// behaviorally identical to the former single-file implementation.
-const version = new URL(import.meta.url).search
-const load = (path) => import(new URL(`${path}${version}`, import.meta.url).href)
-const [duplicates, deadCode, auditFormat, audit, structure, endpoints] = await Promise.all([
-  load('./health/duplicates.mjs'),
-  load('./health/dead-code.mjs'),
-  load('./health/audit-format.mjs'),
-  load('./health/audit.mjs'),
-  load('./health/structure.mjs'),
-  load('./health/endpoints.mjs'),
-])
-
-export const tFindDuplicates = duplicates.tFindDuplicates
-export const tFindDeadCode = deadCode.tFindDeadCode
-export const auditFindingPathScope = auditFormat.auditFindingPathScope
-export const formatAuditFinding = auditFormat.formatAuditFinding
-export const isDependencyAuditFinding = auditFormat.isDependencyAuditFinding
-export const tRunAudit = audit.tRunAudit
-export const tCoverageMap = structure.tCoverageMap
-export const tHotPathReview = structure.tHotPathReview
-export const tListCommunities = structure.tListCommunities
-export const tModuleMap = structure.tModuleMap
-export const tListEndpoints = endpoints.tListEndpoints

package/src/mcp/tools-history.mjs

@@ -1,28 +0,0 @@
-// Behavioral architecture evidence from bounded, local git history.
-import {analyzeGitHistory, boundGitHistoryAnalytics, formatGitHistoryAnalytics} from '../analysis/git-history.js'
-import {toolResult} from './tool-result.mjs'
-
-export function gitHistoryToolResult(result, args = {}) {
-    const bounded = boundGitHistoryAnalytics(result, {topN: args.top_n})
-    return toolResult(formatGitHistoryAnalytics(bounded.result, {topN: args.top_n}), bounded.result, {
-        page: bounded.page,
-        completeness: {
-            status: result.status,
-            complete: result.completeness?.complete === true,
-            reasons: result.completeness?.reasons || [],
-        },
-    })
-}
-
-export async function tGitHistory(g, args = {}, ctx) {
-    if (!ctx?.repoRoot) return toolResult('Git history intelligence is unavailable: no repository root is active.', {status: 'unavailable'})
-    const result = await analyzeGitHistory({
-        repoRoot: ctx.repoRoot,
-        graph: g,
-        months: args.months,
-        maxCommits: args.max_commits,
-        maxPairs: args.max_pairs,
-        minPairCount: args.min_pair_count,
-    })
-    return gitHistoryToolResult(result, args)
-}

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

@@ -1,220 +0,0 @@
-// Symbol-aware change_impact implementation, isolated from the other hot impact tools so its
-// classifier/evidence contract can be tested without perturbing get_dependents or graph_diff.
-import {runGit} from '../git-exec.js'
-import {fileOfId} from '../graph/node-id.js'
-import {classifyChangeImpact} from '../analysis/change-classification.js'
-import {readCoverageForRepo} from '../analysis/coverage-reports.js'
-import {computeStaticTestReachability} from '../analysis/static-test-reachability.js'
-import {degreeOf, labelOf, rawGraph} from './graph-context.mjs'
-import {reverseReach} from './graph/reverse-reach.mjs'
-import {gitLines} from './git-output.mjs'
-import {toolResult} from './tool-result.mjs'
-
-function gitValue(repoRoot, args) {
-    const result = runGit(repoRoot, args)
-    if (result.status !== 0) return null
-    return String(result.stdout || '').trim() || null
-}
-
-function resolveImpactBase(repoRoot, requested) {
-    const candidates = requested ? [requested] : ['origin/HEAD', 'origin/main', 'origin/master', 'main', 'master']
-    for (const ref of candidates) {
-        const value = gitValue(repoRoot, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
-        if (value) return ref
-    }
-    return null
-}
-
-const impactKind = (entry) => entry?.runtimeDepth != null
-    ? (entry.compileDepth != null ? `runtime + compile-time(d${entry.compileDepth})` : 'runtime')
-    : 'compile-time'
-
-const partialResult = (text, reason, status = 'UNAVAILABLE') => toolResult(text, {
-    status,
-    verdict: 'HIGH',
-    reasons: [reason],
-    changes: [],
-    seeds: {ids: [], unmappedIds: []},
-    blastRadius: {impacted: 0, runtime: 0, compileTimeOnly: 0, nodes: []},
-}, {completeness: {status: 'PARTIAL', reason}})
-
-export function tChangeImpactV2(g, args = {}, ctx = {}) {
-    if (!ctx.repoRoot) return partialResult(
-        'HIGH — change impact unavailable\nNo repository root is active; no diff can be classified safely.',
-        'Repository root unavailable.'
-    )
-
-    const explicit = Array.isArray(args.files)
-        ? [...new Set(args.files.map((file) => String(file).replace(/\\/g, '/').trim()).filter(Boolean))]
-        : null
-    if (explicit && !explicit.length) return partialResult(
-        'HIGH — invalid change set\nfiles was provided but empty; pass repo-relative paths, or omit it to diff local changes.',
-        'Explicit files list was empty.',
-        'INVALID'
-    )
-
-    const graph = rawGraph(ctx)
-    const providedDiff = typeof args.diff === 'string'
-    let sourceLabel
-    let classification
-    if (providedDiff) {
-        sourceLabel = explicit ? `from provided unified diff + ${explicit.length} file hint(s)` : 'from provided unified diff'
-        classification = classifyChangeImpact({repoRoot: ctx.repoRoot, graph, diffText: args.diff, files: explicit || []})
-    } else if (explicit) {
-        sourceLabel = `for ${explicit.length} provided file(s) (no diff; conservative fallback)`
-        classification = classifyChangeImpact({repoRoot: ctx.repoRoot, graph, files: explicit})
-    } else {
-        const base = resolveImpactBase(ctx.repoRoot, args.base ? String(args.base).trim() : '')
-        if (!base) return partialResult(
-            `HIGH — change impact unavailable\nCould not resolve base ref${args.base ? ` "${args.base}"` : ''}; pass base explicitly (for example origin/main or HEAD~1).`,
-            'Base ref could not be resolved.'
-        )
-        const mergeBase = gitValue(ctx.repoRoot, ['merge-base', base, 'HEAD']) || base
-        const untracked = gitLines(ctx.repoRoot, ['ls-files', '--others', '--exclude-standard']) || []
-        sourceLabel = `vs ${base}${mergeBase !== base ? ` (merge-base ${mergeBase.slice(0, 12)})` : ''}`
-        classification = classifyChangeImpact({repoRoot: ctx.repoRoot, graph, base: mergeBase, files: untracked})
-    }
-
-    if (!classification.files.length) return toolResult(`LOW — change impact ${sourceLabel}\nNo textual or untracked changes were found.`, {
-        status: 'COMPLETE',
-        verdict: 'LOW',
-        reasons: classification.reasons,
-        changes: [],
-        seeds: {ids: [], unmappedIds: []},
-        blastRadius: {impacted: 0, runtime: 0, compileTimeOnly: 0, nodes: []},
-    }, {completeness: {status: 'COMPLETE'}})
-
-    const changed = [...new Set(classification.files
-        .flatMap((file) => [file.oldPath, file.newPath])
-        .filter((file) => file && file !== '(diff unavailable)'))]
-    const changedSet = new Set(changed)
-    const seedIds = classification.seedIds.filter((id) => g.byId.has(String(id)))
-    const seeds = new Set(seedIds)
-    const unmappedSeedIds = classification.seedIds.filter((id) => !g.byId.has(String(id)))
-    const unmappedFiles = classification.files
-        .filter((file) => ![file.oldPath, file.newPath].some((path) => path && g.byId.has(String(path))))
-        .map((file) => file.path)
-
-    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 = seeds.size ? reverseReach(g, seeds, maxDepth) : new Map()
-    const impacted = [...reached.entries()]
-        .filter(([id]) => !seeds.has(id) && !changedSet.has(fileOfId(id)))
-        .map(([id, entry]) => ({id, depth: entry.depth, entry, degree: degreeOf(g, id), file: fileOfId(id)}))
-        .sort((left, right) => left.depth - right.depth
-            || Number(left.entry.compileOnly) - Number(right.entry.compileOnly)
-            || right.degree - left.degree
-            || left.id.localeCompare(right.id))
-
-    // Measured coverage wins. Static reachability stays separately labelled and never becomes a
-    // synthetic coverage percentage.
-    const knownFiles = (graph.nodes || []).filter((node) => !String(node.id).includes('#') && node.source_file).map((node) => node.source_file)
-    const coverage = readCoverageForRepo(ctx.repoRoot, knownFiles)
-    const coverageOf = (file) => coverage.get(String(file).replace(/\\/g, '/'))?.pct ?? null
-    const hasCoverage = coverage.size > 0
-    const staticTests = computeStaticTestReachability(graph, {repoRoot: ctx.repoRoot})
-    const staticByFile = new Map(staticTests.reachable.map((entry) => [entry.file, entry.nearestTests[0]]))
-    const staticUnreachable = new Set(staticTests.unreachable)
-    const testEvidenceFor = (file) => {
-        const normalized = String(file).replace(/\\/g, '/')
-        const actualCoverage = coverageOf(normalized)
-        const nearest = staticByFile.get(normalized)
-        return {
-            actualCoverage,
-            staticTestReachability: nearest ? {
-                status: 'REACHABLE',
-                test: nearest.test,
-                distance: nearest.distance,
-                confidence: nearest.confidence,
-                path: nearest.path,
-            } : staticUnreachable.has(normalized) ? {status: 'NO_PATH'} : {status: 'NOT_INDEXED'},
-        }
-    }
-    const evidenceLabel = (file) => {
-        const evidence = testEvidenceFor(file)
-        if (evidence.actualCoverage != null) return `cov ${Math.round(evidence.actualCoverage * 100)}%`
-        const reachability = evidence.staticTestReachability
-        if (reachability.status === 'REACHABLE') return `static-test d${reachability.distance} ${reachability.confidence}`
-        return reachability.status === 'NO_PATH' ? 'no static test path' : 'test evidence n/a'
-    }
-
-    const shown = impacted.slice(0, cap)
-    const runtimeImpacted = impacted.filter((entry) => !entry.entry.compileOnly).length
-    const compileImpacted = impacted.length - runtimeImpacted
-    const coverageHotspots = hasCoverage
-        ? shown.filter((node) => { const value = coverageOf(node.file); return value != null && value < 0.5 && node.degree >= 5 })
-        : []
-    const nodes = shown.map((node) => ({
-        id: node.id,
-        label: labelOf(g, node.id),
-        file: node.file,
-        depth: node.depth,
-        kind: impactKind(node.entry),
-        relation: node.entry.relation || 'rel',
-        degree: node.degree,
-        testEvidence: testEvidenceFor(node.file),
-    }))
-    const changeLines = classification.files.slice(0, 30).flatMap((file) => [
-        `  [${file.classification}] ${file.path} — ${file.reason} (${file.seedIds.length} seed${file.seedIds.length === 1 ? '' : 's'})`,
-        ...file.symbols.slice(0, 8).map((symbol) => `      ↳ [${symbol.classification}] ${symbol.label} [${symbol.id}]`),
-    ])
-    const warnings = []
-    if (!classification.ok) warnings.push({code: 'CHANGE_CLASSIFICATION_PARTIAL', message: classification.reasons.join(' ')})
-    if (unmappedFiles.length) warnings.push({code: 'CHANGED_FILES_UNMAPPED', message: `${unmappedFiles.length} changed file(s) are absent from the current graph.`})
-    if (unmappedSeedIds.length) warnings.push({code: 'CHANGE_SEEDS_UNMAPPED', message: `${unmappedSeedIds.length} classified seed(s) are absent from the current graph.`})
-
-    const text = [
-        `${classification.verdict} — symbol-aware change impact ${sourceLabel}`,
-        ...classification.reasons.map((reason) => `Reason: ${reason}`),
-        `Changed evidence: ${classification.files.length} file(s), ${classification.summary.symbols} mapped symbol(s) → ${seeds.size} exact graph seed(s).`,
-        ...changeLines,
-        classification.files.length > 30 ? `  … +${classification.files.length - 30} more changed files` : null,
-        '',
-        impacted.length
-            ? `Blast radius: ${impacted.length} impacted node(s) within ${maxDepth} reverse hop(s) (${runtimeImpacted} runtime, ${compileImpacted} compile-time-only), showing ${shown.length}:`
-            : seeds.size ? `Blast radius: nothing else depends on the exact changed symbols within ${maxDepth} hop(s).` : `Blast radius: 0 — additive, metadata-only, and test-only changes do not inherit the containing file's legacy importers.`,
-        hasCoverage
-            ? 'Test evidence: measured coverage is shown where mapped; static reachability remains separate in structured output.'
-            : `Test evidence: actualCoverage NOT_AVAILABLE; static paths only (${staticTests.reachableFiles}/${staticTests.productFiles} product files reachable from indexed tests).`,
-        ...shown.map((node) => `  [d${node.depth} ${impactKind(node.entry)}] ${node.entry.relation || 'rel'}  ${labelOf(g, node.id)}  (deg ${node.degree}, ${evidenceLabel(node.file)})  [${node.id}]`),
-        coverageHotspots.length ? '' : null,
-        coverageHotspots.length ? 'Measured-coverage hotspots in the blast radius (<50%, deg ≥5):' : null,
-        ...coverageHotspots.slice(0, 10).map((node) => `  ${labelOf(g, node.id)}  (cov ${Math.round(coverageOf(node.file) * 100)}%, deg ${node.degree})  ${node.file}`),
-        '',
-        'Drill into an impacted node with get_dependents/read_source; coverage_map distinguishes measured coverage from static reachability.',
-    ].filter((line) => line != null).join('\n')
-
-    const complete = classification.ok && !unmappedFiles.length && !unmappedSeedIds.length
-    return toolResult(text, {
-        status: complete ? 'COMPLETE' : 'PARTIAL',
-        verdict: classification.verdict,
-        reasons: classification.reasons,
-        source: {label: sourceLabel, kind: classification.source},
-        changes: classification.files,
-        classification: {summary: classification.summary, bounds: classification.bounds},
-        seeds: {ids: [...seeds].sort(), unmappedIds: unmappedSeedIds},
-        blastRadius: {
-            depth: maxDepth,
-            impacted: impacted.length,
-            runtime: runtimeImpacted,
-            compileTimeOnly: compileImpacted,
-            nodes,
-        },
-        testEvidence: {
-            actualCoverage: hasCoverage ? 'AVAILABLE' : 'NOT_AVAILABLE',
-            changedFiles: changed.slice(0, 500).map((file) => ({file, ...testEvidenceFor(file)})),
-            staticTestReachability: {
-                kind: staticTests.kind,
-                testFiles: staticTests.testFiles,
-                productFiles: staticTests.productFiles,
-                reachableFiles: staticTests.reachableFiles,
-                bounds: staticTests.bounds,
-            },
-        },
-        unmappedFiles,
-    }, {
-        warnings,
-        page: {shown: shown.length, total: impacted.length, capped: shown.length < impacted.length},
-        completeness: {status: complete ? 'COMPLETE' : 'PARTIAL'},
-    })
-}