weavatrix 0.2.6 → 0.2.8

package/src/analysis/hot-path-review.js

@@ -109,8 +109,9 @@ export function computeHotPathReview(graph, options = {}) {
         calls: boundedInt(options.callThreshold, 12, 1, 10000),
         loopDepth: boundedInt(options.loopDepthThreshold, 2, 1, 10),
         timeRank: boundedInt(options.timeRankThreshold, 2, 0, 5),
-        minScore: boundedInt(options.minScore, 0, 0, 100),
+        minScore: boundedInt(options.minScore, 85, 0, 100),
     }
+    const defaultFocus = options.minScore == null
     const topN = boundedInt(options.topN, 20, 1, 100)
     const classifier = createPathClassifier(options.repoRoot || null)
     const knownFiles = [...new Set((graph?.nodes || []).map((node) => normalize(node?.source_file)).filter(Boolean))]
@@ -152,8 +153,19 @@ export function computeHotPathReview(graph, options = {}) {
         const nearest = staticByFile.get(file)?.nearestTests?.[0] || null
         const coverageRisk = actualCoverage == null ? 0 : (1 - actualCoverage) * 100
         const score = round(clamp(syntaxScore * 0.72 + graphScore * 0.2 + coverageRisk * 0.08))
-        if (score < thresholds.minScore) continue
         const directHotEvidence = Array.isArray(complexity.hotEvidence) ? complexity.hotEvidence.slice(0, 12) : []
+        // The default queue is intentionally narrow. A small, locally expensive function can still be
+        // important even with little graph fan-in, so retain only a bounded strong-local fallback. An
+        // explicit minScore disables this fallback and gives the caller a strict numeric gate.
+        const bodyLines = startLine > 0 && endLine >= startLine ? endLine - startLine + 1 : Number.POSITIVE_INFINITY
+        const strongLocalEvidence = defaultFocus && directHotEvidence.length > 0 && bodyLines <= 80 && (
+            Number(complexity.recursionInLoops || 0) > 0
+            || (bodyLines <= 40 && (
+                Number(complexity.sortsInLoops || 0) > 0
+                || (Number(complexity.timeRank || 0) >= 4 && Number(complexity.maxLoopDepth || 0) >= 2)
+            ))
+        )
+        if (score < thresholds.minScore && !strongLocalEvidence) continue
         const confidence = directHotEvidence.length ? 'HIGH' : complexity.recursion ? 'LOW' : 'MEDIUM'
         candidates.push({
             id: String(node.id),
@@ -164,6 +176,7 @@ export function computeHotPathReview(graph, options = {}) {
             endLine,
             classification: entry.classification,
             score,
+            selection: score >= thresholds.minScore ? 'SCORE_THRESHOLD' : 'STRONG_LOCAL_EVIDENCE',
             confidence,
             localSyntax: {
                 score: syntaxScore,
@@ -207,6 +220,11 @@ export function computeHotPathReview(graph, options = {}) {
             includeClassified: options.includeClassified === true,
         },
         thresholds,
+        selectionPolicy: {
+            mode: defaultFocus ? 'FOCUSED_DEFAULT' : 'EXPLICIT_SCORE_THRESHOLD',
+            strongLocalFallback: defaultFocus,
+            broadenWith: 'Set min_score lower (0 restores the full diagnostic candidate set).',
+        },
         analyzedSymbols: eligible.length,
         candidateSymbols: candidates.length,
         coverage: measuredCoverage.size

package/src/analysis/internal-audit.collect.js

@@ -3,7 +3,7 @@
 import { readFileSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
-import { parseRequirementsNames, parsePyprojectDeps, parsePipfileDeps } from "./manifests.js";
+import { parseRequirementsNames, parsePyprojectDeps, parsePipfileDeps, pep503 } from "./manifests.js";
 import { createRepoBoundary } from "../repo-path.js";
 import { childProcessEnv } from "../child-env.js";
 import { filterWeavatrixIgnored } from "../path-ignore.js";
@@ -254,28 +254,61 @@ export function workspacePkgNames(repoRoot, pkg) {
 
 export const TEST_FILE_RE = /(^|[/])(test|tests|__tests__|spec|e2e|__mocks__)([/]|$)|[._-](test|spec)\.[a-z0-9]+$/i;
 
-// Python declared deps: root requirements*.txt/.in + requirements/ dir + pyproject.toml + Pipfile.
+// Python declared deps are owned by the nearest manifest root, matching nested service/monorepo
+// layouts. `requirements/*.txt` belongs to the directory above `requirements`; a colocated
+// requirements.txt, pyproject.toml or Pipfile owns its own directory.
 // present=false (no manifest at all) softens missing-dep findings instead of suppressing them.
 export function collectPyManifest(repoRoot) {
-  const deps = [];
-  let present = false;
-  let names = [];
   const boundary = createRepoBoundary(repoRoot);
-  try { names = readdirSync(boundary.root).filter((n) => /^requirements[\w.-]*\.(txt|in)$/i.test(n)); } catch { /* unreadable root */ }
-  try {
-    const requirements = boundary.resolve("requirements");
-    if (requirements.ok) names.push(...readdirSync(requirements.path).filter((n) => /\.(txt|in)$/i.test(n)).map((n) => `requirements/${n}`));
-  } catch { /* no requirements dir */ }
-  for (const n of names) {
-    const t = readRepoText(boundary, n);
+  const scopes = new Map();
+  const scopeFor = (root) => {
+    const normalized = normRoot(root);
+    if (!scopes.has(normalized)) scopes.set(normalized, { root: normalized, present: false, deps: [], manifests: [] });
+    return scopes.get(normalized);
+  };
+  const addManifest = (root, manifest, parsedDeps, present = true) => {
+    if (!present) return;
+    const scope = scopeFor(root);
+    scope.present = true;
+    scope.manifests.push(manifest);
+    scope.deps.push(...parsedDeps.map((dep) => ({ ...dep, manifest })));
+  };
+  const files = listRepoFiles(repoRoot);
+  for (const file of files.filter((name) => /(^|\/)requirements[\w.-]*\.(?:txt|in)$/i.test(name)
+    || /(^|\/)requirements\/[^/]+\.(?:txt|in)$/i.test(name))) {
+    const t = readRepoText(boundary, file);
     if (t == null) continue;
-    present = true;
-    const dev = /dev|test|lint|doc|ci/i.test(n.replace(/^requirements[/\\]?/i, ""));
-    for (const d of parseRequirementsNames(t)) deps.push({ ...d, dev });
+    const parent = normRoot(dirname(file));
+    const root = /(^|\/)requirements$/i.test(parent) ? normRoot(dirname(parent)) : parent;
+    const dev = /dev|test|lint|doc|ci/i.test(file.slice(file.lastIndexOf("/") + 1));
+    addManifest(root, file, parseRequirementsNames(t).map((dep) => ({ ...dep, dev })));
   }
-  const pp = readRepoText(boundary, "pyproject.toml");
-  if (pp != null) { const r = parsePyprojectDeps(pp); if (r.present) { present = true; deps.push(...r.deps); } }
-  const pf = readRepoText(boundary, "Pipfile");
-  if (pf != null) { const r = parsePipfileDeps(pf); if (r.present) { present = true; deps.push(...r.deps); } }
-  return { present, deps };
+  for (const file of files.filter((name) => /(^|\/)pyproject\.toml$/i.test(name))) {
+    const parsed = parsePyprojectDeps(readRepoText(boundary, file));
+    addManifest(dirname(file), file, parsed.deps, parsed.present);
+  }
+  for (const file of files.filter((name) => /(^|\/)Pipfile$/i.test(name))) {
+    const parsed = parsePipfileDeps(readRepoText(boundary, file));
+    addManifest(dirname(file), file, parsed.deps, parsed.present);
+  }
+  const normalizedScopes = [...scopes.values()]
+    .map((scope) => {
+      const seen = new Set();
+      return {
+        ...scope,
+        manifests: [...new Set(scope.manifests)].sort(),
+        deps: scope.deps.filter((dep) => {
+          const key = pep503(dep.name);
+          if (!key || seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        }),
+      };
+    })
+    .sort((left, right) => right.root.length - left.root.length || left.root.localeCompare(right.root));
+  return {
+    present: normalizedScopes.some((scope) => scope.present),
+    deps: normalizedScopes.flatMap((scope) => scope.deps),
+    scopes: normalizedScopes,
+  };
 }

package/src/analysis/internal-audit.run.js

@@ -300,15 +300,20 @@ export async function runInternalAudit(repoPath, { graph, advisoryStorePath, ski
     findings: sorted,
     dependencyReport: {
       status: dependencyStatus,
+      evidenceModel: "MANIFEST_PLUS_INDEXED_SOURCE",
+      perFindingVerification: true,
+      verificationCoverage: { npm: "COMPLETE_FOR_GRAPH_SCOPE", go: "SUMMARY_ONLY", python: "SUMMARY_ONLY" },
       declared: dep.declared.size + goDep.declared.size + pyDep.declared.size,
       importedPackages: importedPackages.size,
       importRecords: externalImports.length,
       unused: dependencyFindings.filter((finding) => finding.rule === "unused-dep").length,
       missing: dependencyFindings.filter((finding) => finding.rule === "missing-dep").length,
       duplicateDeclarations: dependencyFindings.filter((finding) => finding.rule === "duplicate-dep").length,
+      unusedRequiringReview: dependencyFindings.filter((finding) => finding.rule === "unused-dep" && finding.verification?.decision === "REVIEW_REQUIRED").length,
+      missingWithSourceEvidence: dependencyFindings.filter((finding) => finding.rule === "missing-dep" && finding.verification?.indexedSourceImports?.status === "FOUND").length,
       packageScopes: packageScopes.length,
       reason: dependencyStatus === "COMPLETE"
-        ? "All discovered dependency manifests were compared with the complete indexed import set."
+        ? "All discovered dependency manifests were compared with the complete indexed import set; every npm unused/missing/duplicate finding carries manifest and source/config verification state."
         : "The dependency result is scoped to a partial graph and is not a repository-wide clean bill.",
     },
     deadReport: {

package/src/analysis/task-retrieval.js

@@ -0,0 +1,116 @@
+import {createPathClassifier, hasPathClass} from '../path-classification.js'
+
+const words = (value) => new Set(String(value || '').toLowerCase().match(/[\p{L}_$][\p{L}\p{N}_$-]{2,}/gu) || [])
+const fileOf = (node) => String(node?.source_file || (String(node?.id || '').includes('#') ? String(node.id).split('#')[0] : node?.id || '')).replace(/\\/g, '/')
+const isSymbol = (id) => String(id || '').includes('#')
+const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const CLASS_TERMS = Object.freeze({
+  test: ['test', 'tests', 'testing', 'spec', 'coverage', 'verify'],
+  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 INTENT_TRANSLATIONS = [
+  [/авториз|аутентиф|логин|сесси|токен/iu, 'auth authentication login session token'],
+  [/маршрут|роут|эндпоинт|апи|http/iu, 'route router endpoint api http'],
+  [/тест|покрыти/iu, 'test spec coverage verify'],
+  [/к[эе]ш|хранилищ/iu, 'cache store storage'],
+  [/баз[аы]|запрос|sql/iu, 'database query sql'],
+  [/конфиг|настройк/iu, 'config settings configuration'],
+  [/безопас|вредонос|секрет/iu, 'security malware secret'],
+  [/зависим|импорт/iu, 'dependency import module'],
+  [/дублик|клон/iu, 'duplicate clone'],
+]
+
+export function expandTaskQuery(task) {
+  const text = String(task || '')
+  const expansions = INTENT_TRANSLATIONS.filter(([pattern]) => pattern.test(text)).map(([, value]) => value)
+  return [...new Set([text, ...expansions])].join(' ')
+}
+
+function overlapScore(taskWords, node) {
+  const haystack = words(`${node?.label || ''} ${node?.id || ''} ${node?.symbol_kind || ''}`)
+  let score = 0
+  for (const word of taskWords) if (haystack.has(word)) score += 8
+  return score
+}
+
+function addCandidate(map, node, score, reason) {
+  if (!node?.id) return
+  const id = String(node.id)
+  const current = map.get(id) || {node, score: 0, reasons: new Set()}
+  current.score += score
+  current.reasons.add(reason)
+  map.set(id, current)
+}
+
+function containedSymbols(g, node) {
+  if (isSymbol(node?.id)) return [node]
+  return (g.out.get(String(node?.id)) || [])
+    .filter((edge) => edge.relation === 'contains')
+    .map((edge) => g.byId.get(String(edge.id)))
+    .filter(Boolean)
+}
+
+// Combines intent-expanded search seeds with exact changed symbols. The result deliberately stays
+// deterministic and source-free; exact LSP/source evidence is collected by context_bundle later.
+export function retrieveTaskContext(g, {
+  task, semanticSeeds = [], changedSeedIds = [], maxSymbols = 3, repoRoot = null, includeClassified = false,
+} = {}) {
+  const expandedTask = expandTaskQuery(task)
+  const taskWords = words(expandedTask)
+  const requestedClasses = new Set(Object.entries(CLASS_TERMS)
+    .filter(([, terms]) => terms.some((term) => taskWords.has(term)))
+    .map(([name]) => name))
+  if (requestedClasses.has('test')) requestedClasses.add('e2e')
+  if (requestedClasses.has('e2e')) requestedClasses.add('test')
+  const classifier = createPathClassifier(repoRoot)
+  const classificationCache = new Map()
+  const changedFiles = new Set((changedSeedIds || []).map((id) => fileOf(g.byId.get(String(id)) || {id})))
+  const pathAllowed = (node) => {
+    const file = fileOf(node)
+    if (!file || changedFiles.has(file) || includeClassified === true) return true
+    if (!classificationCache.has(file)) classificationCache.set(file, classifier.explain(file, {content: ''}))
+    const info = classificationCache.get(file)
+    const classes = NON_PRODUCT_CLASSES.filter((name) => hasPathClass(info, name))
+    if (!info?.excluded && !classes.length) return true
+    return classes.some((name) => requestedClasses.has(name))
+  }
+  const candidates = new Map()
+  for (const id of changedSeedIds || []) {
+    const node = g.byId.get(String(id))
+    if (node) addCandidate(candidates, node, 100 + overlapScore(taskWords, node), 'changed-symbol')
+  }
+  for (const seed of semanticSeeds || []) addCandidate(candidates, seed, 45 + overlapScore(taskWords, seed), 'task-intent')
+
+  for (const candidate of [...candidates.values()]) {
+    for (const symbol of containedSymbols(g, candidate.node)) {
+      const degree = (g.out.get(String(symbol.id)) || []).length + (g.inn.get(String(symbol.id)) || []).length
+      addCandidate(candidates, symbol, 22 + overlapScore(taskWords, symbol) + Math.min(12, degree), `symbol-in:${fileOf(candidate.node)}`)
+    }
+  }
+
+  const symbolCandidates = [...candidates.values()].filter((item) => isSymbol(item.node.id))
+  const ranked = symbolCandidates
+    .filter((item) => pathAllowed(item.node))
+    .sort((left, right) => right.score - left.score || String(left.node.id).localeCompare(String(right.node.id)))
+  const limit = Math.max(1, Math.min(5, Number(maxSymbols) || 3))
+  return {
+    method: 'intent-expanded graph retrieval + exact changed-symbol seeds',
+    status: ranked.length ? 'COMPLETE' : 'NO_SYMBOLS',
+    selected: ranked.slice(0, limit).map((item) => ({
+      id: String(item.node.id), label: item.node.label || String(item.node.id), file: fileOf(item.node),
+      kind: item.node.symbol_kind || null, score: item.score, reasons: [...item.reasons].sort(),
+    })),
+    candidateCount: ranked.length,
+    suppressedClassified: symbolCandidates.length - ranked.length,
+    pathPolicy: includeClassified === true
+      ? {mode: 'ALL_CLASSIFIED'}
+      : {mode: 'PRODUCTION_FIRST', requestedClasses: [...requestedClasses].sort(), changedFilesPinned: changedFiles.size},
+  }
+}

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

@@ -4,23 +4,43 @@
 // `crate/self/super` paths resolve to repo-local .rs or */mod.rs files. External crates deliberately stay out
 // of this adapter; Cargo dependency analysis owns them.
 const SYMS_CORE = `
-  (function_item name: (identifier) @method)
-  (struct_item name: (type_identifier) @class)
-  (enum_item name: (type_identifier) @class)
-  (trait_item name: (type_identifier) @class)
-  (type_item name: (type_identifier) @class)
-  (mod_item name: (identifier) @class)
-  (const_item name: (identifier) @field)
-  (static_item name: (identifier) @field)`;
+  (function_item name: (identifier) @function)
+  (struct_item name: (type_identifier) @struct)
+  (enum_item name: (type_identifier) @enum)
+  (trait_item name: (type_identifier) @trait)
+  (type_item name: (type_identifier) @type)
+  (mod_item name: (identifier) @module)
+  (const_item name: (identifier) @constant)
+  (static_item name: (identifier) @static)`;
 // Grammar-version-dependent node types, compiled SEPARATELY (one unknown type voids its whole query).
 const SYMS_OPTIONAL = [
-  `(macro_definition name: (identifier) @method)`,
-  `(union_item name: (type_identifier) @class)`,
+  `(function_signature_item name: (identifier) @function)`,
+  `(macro_definition name: (identifier) @macro)`,
+  `(union_item name: (type_identifier) @union)`,
 ];
 
 const cleanSegment = (part) => String(part || "").trim().replace(/^r#/, "");
 const pathParts = (node) => String(node?.text || "").split("::").map(cleanSegment).filter(Boolean);
 const under = (node, type) => { for (let p = node?.parent; p; p = p.parent) if (p.type === type) return true; return false; };
+const ancestor = (node, types) => {
+  for (let parent = node?.parent; parent; parent = parent.parent) if (types.has(parent.type)) return parent;
+  return null;
+};
+const memberOwners = new Set(["impl_item", "trait_item"]);
+const publicVisibility = (declaration, owner) => {
+  if (owner?.type === "trait_item") return "public";
+  const source = String(declaration?.text || "").trimStart();
+  if (/^pub\s/.test(source)) return "public";
+  if (/^pub\s*\(/.test(source)) return "protected";
+  return "private";
+};
+const ownerName = (owner, field) => {
+  if (!owner) return "";
+  if (owner.type === "trait_item") return field(owner, "name")?.text || "";
+  const type = field(owner, "type")?.text || "";
+  const withoutGenerics = type.replace(/<[^<>]*>/g, "");
+  return (withoutGenerics.match(/[A-Za-z_]\w*/g) || []).at(-1) || "";
+};
 
 function pathAttribute(modNode) {
   for (let prev = modNode?.previousNamedSibling; prev?.type === "attribute_item"; prev = prev.previousNamedSibling) {
@@ -93,12 +113,29 @@ export default {
   ],
 
   pass1(ctx) {
-    const { grammar, tree, fileRel, caps, addSym, addImportEdge, imports, resolveRustMod, resolveRustPath } = ctx;
+    const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, imports, resolveRustMod, resolveRustPath, links, nameToId } = ctx;
+    const owned = [];
     for (const src of [SYMS_CORE, ...SYMS_OPTIONAL]) {
       for (const cap of caps(grammar, src, tree.rootNode)) {
-        addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
+        const declaration = cap.node.parent;
+        const owner = cap.name === "function" ? ancestor(cap.node, memberOwners) : null;
+        const memberOf = ownerName(owner, field);
+        const symbolKind = cap.name === "function" ? (memberOf ? "method" : "function") : cap.name;
+        const visibility = publicVisibility(declaration, owner);
+        const id = addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "function", {
+          sourceNode: declaration,
+          selectionNode: cap.node,
+          symbolKind,
+          ...(memberOf ? { memberOf, visibility } : { moduleDeclaration: true }),
+          ...(!memberOf && visibility === "public" ? { exported: true } : {}),
+        });
+        if (id && memberOf) owned.push({owner: memberOf, id});
       }
     }
+    for (const member of owned) {
+      const ownerId = nameToId.get(member.owner);
+      if (ownerId && ownerId !== member.id) links.push({source: ownerId, target: member.id, relation: "method", confidence: "EXTRACTED"});
+    }
 
     // File dependency edges are intentionally unique per source/target/relation. A qualified path can be
     // nested in another qualified path and often repeats an existing `mod`/`use`; counting occurrences would

package/src/mcp/catalog.mjs

@@ -26,19 +26,38 @@ const PROFILE_CAPS = Object.freeze({
 
 // The files whose mtime the stdio shell watches for hot reload — keep in sync with the imports in
 // loadHotApi below (catalog.mjs itself is last: a change here re-derives the whole table).
-export const HOT_FILES = ['tools-graph.mjs', 'tools-impact.mjs', 'tools-health.mjs', 'tools-source.mjs', 'tools-context.mjs', 'tools-actions.mjs', 'tools-architecture.mjs', 'tools-history.mjs', 'tools-company.mjs', 'catalog.mjs']
+export const HOT_FILES = ['tools-graph.mjs', 'tools-impact.mjs', 'tools-health.mjs', 'tools-source.mjs', 'tools-context.mjs', 'tools-actions.mjs', 'tools-architecture.mjs', 'tools-history.mjs', 'tools-company.mjs', 'tools-verified-change.mjs', 'catalog.mjs']
 
-function buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc}) {
+function buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc, tv, caps}) {
     const tools = [
         {cap: 'graph', name: 'graph_stats', description: 'Return summary statistics: node count, edge count, communities, versioned edge-provenance/legacy-confidence breakdowns, and graph build time vs repo HEAD (staleness).', inputSchema: {type: 'object', properties: {}}, run: (g, a, ctx) => tg.tGraphStats(g, ctx)},
         {cap: 'graph', name: 'get_node', description: 'Get full details for a specific node by label or ID.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID to look up'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNode(g, a, ctx)},
         {cap: 'graph', name: 'get_neighbors', description: 'Get all direct neighbors of a node with edge details (1 hop, call sites deduped). For transitive impact use get_dependents; for the impact of your current branch changes use change_impact.', inputSchema: {type: 'object', properties: {label: {type: 'string'}, relation_filter: {type: 'string', description: 'Optional: filter by relation type'}}, required: ['label']}, run: (g, a, ctx) => tg.tGetNeighbors(g, a, ctx)},
-        {cap: 'graph', name: 'query_graph', description: 'Explore the graph around a concept (BFS/DFS). Returns a focused, ranked subgraph — the closest, most-connected nodes near the matched seeds, with edges among them — not the full flood; states how many nodes were reached vs shown.', inputSchema: {type: 'object', properties: {question: {type: 'string', description: 'Natural language question or keyword search'}, mode: {type: 'string', enum: ['bfs', 'dfs'], default: 'bfs'}, depth: {type: 'integer', default: 3}, context_filter: {type: 'array', items: {type: 'string'}}, seed_files: {type: 'array', items: {type: 'string'}, maxItems: 12, description: 'Optional exact repo-relative file paths. When resolved, these are the only seeds unless augment_seeds is true'}, augment_seeds: {type: 'boolean', default: false, description: 'With seed_files, also add fuzzy question-derived seeds; false keeps traversal strictly pinned'}, token_budget: {type: 'integer', description: 'Higher budget shows more nodes/edges', default: 2000}}, required: ['question']}, run: (g, a, ctx) => tg.tQueryGraph(g, a, ctx)},
+        {cap: 'graph', name: 'query_graph', description: 'Explore a focused production-first graph around a concept (BFS/DFS). Exact seed files stay pinned; classified paths and unreferenced constant/field leaves are suppressed unless the question or explicit flags request them. Reports policy and suppression instead of silently flooding the result.', inputSchema: {type: 'object', properties: {question: {type: 'string', description: 'Natural language question or keyword search'}, mode: {type: 'string', enum: ['bfs', 'dfs'], default: 'bfs'}, depth: {type: 'integer', default: 3}, context_filter: {type: 'array', items: {type: 'string'}}, seed_files: {type: 'array', items: {type: 'string'}, maxItems: 12, description: 'Optional exact repo-relative file paths. When resolved, these are the only seeds unless augment_seeds is true'}, augment_seeds: {type: 'boolean', default: false, description: 'With seed_files, also add fuzzy question-derived seeds; false keeps traversal strictly pinned'}, include_classified: {type: 'boolean', default: false, description: 'Allow traversal through tests/e2e/generated/mocks/stories/docs/benchmarks/temp and explicitly excluded paths. An explicit class term in the question enables only that class.'}, include_low_signal: {type: 'boolean', default: false, description: 'Include unreferenced constant/field leaf symbols that do not match a query term'}, token_budget: {type: 'integer', description: 'Higher budget shows more nodes/edges', default: 2000}}, required: ['question']}, run: (g, a, ctx) => tg.tQueryGraph(g, a, ctx)},
         {cap: 'graph', name: 'god_nodes', description: 'Rank production-code connectivity hubs by unique call/import/reference neighbors, with class/method ownership reported separately from runtime connectivity. Repeated call sites do not inflate the rank; classified tests, generated/build output and other non-product paths are excluded by default.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', default: 10}, include_classified: {type: 'boolean', default: false, description: 'Include tests/e2e/generated/build output/mocks/stories/docs/benchmarks/temp and paths explicitly excluded by repository classification'}}}, run: (g, a, ctx) => tg.tGodNodes(g, a, ctx)},
         {cap: 'graph', name: 'shortest_path', description: 'Find the shortest path between two concepts in the knowledge graph.', inputSchema: {type: 'object', properties: {source: {type: 'string'}, target: {type: 'string'}, max_hops: {type: 'integer', default: 8}}, required: ['source', 'target']}, run: (g, a) => tg.tShortestPath(g, a)},
         {cap: 'graph', name: 'get_dependents', description: 'Transitive blast-radius of ONE node: everything that calls/imports/inherits it, directly or through intermediaries (reverse edges, ranked by proximity then connectivity). Symbol queries stay symbol-precise by default; set include_container_importers only for a conservative module-wide radius. Use before refactoring; get_neighbors shows only 1 hop, change_impact covers your whole current diff at once.', inputSchema: {type: 'object', properties: {label: {type: 'string', description: 'Node label or ID'}, depth: {type: 'integer', description: 'Max reverse hops, default 3', default: 3}, max_nodes: {type: 'integer', description: 'Max dependents to list, default 40', default: 40}, include_container_importers: {type: 'boolean', description: 'Also seed importers of the symbol containing file (broader, conservative; default false)', default: false}}, required: ['label']}, run: (g, a) => ti.tGetDependents(g, a)},
         {cap: 'graph', name: 'change_impact', description: 'Verdict-first, symbol-aware blast radius. Parses a zero-context git diff, distinguishes additive exports from signature/body/removal risk, and reverse-traverses only exact changed seeds so a new API does not inherit every legacy importer of its file. Measured coverage is used when present; otherwise static test reachability is labelled actualCoverage=NOT_AVAILABLE. Pass `diff` for a not-checked-out PR; `files` without a diff remains a conservative fallback.', inputSchema: {type: 'object', properties: {base: {type: 'string', description: 'Base ref, e.g. origin/main or HEAD~1 (default: first existing of origin/HEAD, origin/main, origin/master, main, master)'}, diff: {type: 'string', maxLength: 2097152, description: 'Optional unified diff (prefer --unified=0) for a PR/change that is not checked out; enables symbol-level classification'}, files: {type: 'array', items: {type: 'string'}, maxItems: 500, description: 'Optional repo-relative changed-file hints. Without diff evidence these are classified conservatively rather than guessed additive'}, depth: {type: 'integer', description: 'Max reverse hops, default 2'}, max_nodes: {type: 'integer', description: 'Max impacted nodes to list, default 40'}}}, run: (g, a, ctx) => ti.tChangeImpact(g, a, ctx)},
         {cap: 'graph', name: 'git_history', description: 'Behavioral architecture evidence from bounded local git history: churn × connectivity hotspots, hidden co-change coupling, and expected test/source coupling. Reads numstat only — never commit messages, authors, or source bodies.', inputSchema: {type: 'object', properties: {months: {type: 'integer', enum: [3, 6, 12], default: 6}, max_commits: {type: 'integer', minimum: 1, maximum: 5000, default: 1000}, min_pair_count: {type: 'integer', minimum: 2, maximum: 100, default: 3}, max_pairs: {type: 'integer', minimum: 1, maximum: 500, default: 100}, top_n: {type: 'integer', minimum: 1, maximum: 50, default: 10}}}, run: (g, a, ctx) => thi.tGitHistory(g, a, ctx)},
+        {
+            cap: 'graph', refreshGraph: true, name: 'verified_change',
+            description: 'Proof-carrying change workflow. Given a natural-language task and current diff/files, returns compact edit contexts, bounded call-argument data-flow, blast radius, graph/architecture/duplicate/API ratchets, affected tests, and one PASS/BLOCKED/UNKNOWN verdict. Package tests run only when explicitly requested and WEAVATRIX_ALLOW_TEST_RUNS=1.',
+            inputSchema: {type: 'object', additionalProperties: false, properties: {
+                task: {type: 'string', minLength: 1, maxLength: 4000}, phase: {type: 'string', enum: ['plan', 'verify'], default: 'plan'},
+                base_ref: {type: 'string', maxLength: 200, default: 'HEAD'}, diff: {type: 'string', maxLength: 2097152}, files: {type: 'array', items: {type: 'string'}, maxItems: 500},
+                precision: {type: 'string', enum: ['auto', 'graph', 'lsp'], default: 'auto'}, max_symbols: {type: 'integer', minimum: 1, maximum: 5, default: 3},
+                impact_depth: {type: 'integer', minimum: 1, maximum: 4, default: 2}, max_impact_nodes: {type: 'integer', minimum: 5, maximum: 120, default: 40},
+                data_flow_depth: {type: 'integer', minimum: 1, maximum: 3, default: 2}, max_data_flow_edges: {type: 'integer', minimum: 1, maximum: 60, default: 30},
+                duplicate_ratchet: {type: 'boolean', default: true},
+                api_contract: {type: 'object', additionalProperties: true, properties: {backend: {type: 'string'}, clients: {type: 'array', items: {type: 'string'}, minItems: 1, maxItems: 20}, method: {type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']}, path: {type: 'string', maxLength: 2048}, changed_files: {type: 'array', items: {type: 'string'}, maxItems: 500}}, required: ['backend', 'clients']},
+                tests: {type: 'array', maxItems: 5, items: {type: 'object', additionalProperties: false, properties: {script: {type: 'string', maxLength: 120}, args: {type: 'array', maxItems: 40, items: {type: 'string', maxLength: 300}}}, required: ['script']}},
+                run_tests: {type: 'boolean', default: false}, test_timeout_ms: {type: 'integer', minimum: 1000, maximum: 300000, default: 60000},
+            }, required: ['task']},
+            run: (g, a, ctx) => tv.tVerifiedChange(g, a, ctx, {
+                impact: ti.tChangeImpact, context: tb.tContextBundle, inspect: ts.tInspectSymbol,
+                prepareChange: tar.tPrepareChange, verifyArchitecture: tar.tVerifyArchitecture, traceApi: tc.tTraceApiContract,
+            }, {source: caps.has('source'), health: caps.has('health'), crossrepo: caps.has('crossrepo')}),
+        },
         {
             cap: 'crossrepo',
             name: 'trace_api_contract',
@@ -91,7 +110,7 @@ function buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc}) {
         {cap: 'health', name: 'find_dead_code', description: 'Conservative review queue for statically unreferenced files, functions, methods and symbols. Returns confidence, reason, bounded evidence and explicit framework/dynamic/reflection/public-API caveats; never an auto-delete verdict. Tests, generated code, mocks, stories, docs, benchmarks and temporary roots are excluded by default.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repo-relative path prefix'}, kinds: {type: 'array', items: {type: 'string', enum: ['file', 'function', 'method', 'symbol']}, maxItems: 4, uniqueItems: true, description: 'Optional candidate kinds; defaults to all'}, min_confidence: {type: 'string', enum: ['high', 'medium', 'low'], default: 'medium', description: 'Minimum confidence to include. low explicitly includes public/framework/dynamic review candidates'}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and paths explicitly classified as excluded; tests still require include_tests'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 30}}}, run: (g, a, ctx) => th.tFindDeadCode(g, a, ctx)},
         {cap: 'health', name: 'run_audit', description: 'Full internal health audit. With base_ref, builds and audits an immutable Git checkout, derives changed files, and compares stable deterministic finding IDs; debt defaults to genuinely new findings. Supply-chain checks remain explicitly uncomparable across the source-only baseline. changed_files without base_ref is only changed-scope, never a new-debt claim.', inputSchema: {type: 'object', properties: {category: {type: 'string', enum: ['unused', 'structure', 'vulnerability', 'malware'], description: 'Only findings of this category'}, min_severity: {type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'], description: 'Minimum severity to include'}, max_findings: {type: 'integer', description: 'Max findings to list, default 30'}, include_malware_scan: {type: 'boolean', description: 'Also grep installed packages for malware heuristics (slow)', default: false}, base_ref: {type: 'string', maxLength: 200, description: 'Optional immutable Git baseline (for example HEAD~1 or origin/main). Enables honest new/existing/fixed debt comparison'}, changed_files: {type: 'array', items: {type: 'string'}, minItems: 1, maxItems: 500, description: 'Optional explicit repo-relative scope. Without base_ref this is changed-scope only; when omitted with base_ref, files are derived from the Git diff'}, debt: {type: 'string', enum: ['new', 'existing', 'all'], default: 'new', description: 'Baseline comparison view. Defaults to genuinely new deterministic findings when base_ref is present'}}}, run: (g, a, ctx) => th.tRunAudit(g, a, ctx)},
         {cap: 'health', name: 'coverage_map', description: 'Map a real existing coverage report onto the graph. If no report exists, return clearly labelled static test reachability (a test imports/reaches a source file) with actualCoverage=NOT_AVAILABLE; reachability is never presented as measured coverage.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max risk hotspots to list, default 15'}, path: {type: 'string', description: 'Optional repo-relative path prefix filter, e.g. src/query'}}}, run: (g, a, ctx) => th.tCoverageMap(g, a, ctx)},
-        {cap: 'health', name: 'hot_path_review', description: 'Rank bounded production-symbol hot paths from parser-derived local complexity, inside-loop allocations/copies/scans/sorts/recursion, graph fan-in/fan-out, and measured coverage or clearly labelled static test reachability. Local syntax cost stays separate from graph risk; this is not profiler data or interprocedural Big-O.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repository-relative path prefix'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 20}, min_score: {type: 'integer', minimum: 0, maximum: 100, default: 0}, cyclomatic_threshold: {type: 'integer', minimum: 2, maximum: 1000, default: 8}, call_threshold: {type: 'integer', minimum: 1, maximum: 10000, default: 12}, loop_depth_threshold: {type: 'integer', minimum: 1, maximum: 10, default: 2}, time_rank_threshold: {type: 'integer', minimum: 0, maximum: 5, default: 2}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and explicitly excluded paths; tests still require include_tests'}}}, run: (g, a, ctx) => th.tHotPathReview(g, a, ctx)},
+        {cap: 'health', name: 'hot_path_review', description: 'Rank a focused production-symbol hot-path queue from parser-derived local complexity, inside-loop allocations/copies/scans/sorts/recursion, graph fan-in/fan-out, and measured coverage or clearly labelled static test reachability. The default score gate is 85 with a narrow strong-local fallback; set min_score=0 for the full diagnostic queue. This is not profiler data or interprocedural Big-O.', inputSchema: {type: 'object', properties: {path: {type: 'string', maxLength: 1024, description: 'Optional repository-relative path prefix'}, top_n: {type: 'integer', minimum: 1, maximum: 100, default: 20}, min_score: {type: 'integer', minimum: 0, maximum: 100, default: 85, description: 'Focused default is 85; lower explicitly to broaden, or use 0 for every threshold-matching diagnostic candidate'}, cyclomatic_threshold: {type: 'integer', minimum: 2, maximum: 1000, default: 8}, call_threshold: {type: 'integer', minimum: 1, maximum: 10000, default: 12}, loop_depth_threshold: {type: 'integer', minimum: 1, maximum: 10, default: 2}, time_rank_threshold: {type: 'integer', minimum: 0, maximum: 5, default: 2}, include_tests: {type: 'boolean', default: false}, include_classified: {type: 'boolean', default: false, description: 'Include generated/mock/story/docs/benchmark/temp and explicitly excluded paths; tests still require include_tests'}}}, run: (g, a, ctx) => th.tHotPathReview(g, a, ctx)},
         {cap: 'graph', name: 'list_communities', description: 'List graph communities named by their dominant folder (largest first) with sample files — a readable module overview; feed the list position into get_community.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max communities to list, default 20'}}}, run: (g, a, ctx) => th.tListCommunities(g, a, ctx)},
         {cap: 'graph', name: 'module_map', description: 'Production-first folder architecture map with file/symbol counts and strongest module dependencies, separating runtime, TypeScript type-only and language compile-only coupling.', inputSchema: {type: 'object', properties: {top_n: {type: 'integer', description: 'Max modules to list, default 25'}, include_non_product: {type: 'boolean', default: false, description: 'Include tests, fixtures, benchmarks, generated output, docs and other classified non-product files; false by default'}}}, run: (g, a, ctx) => th.tModuleMap(g, a, ctx)},
         {cap: 'source', refreshGraph: true, name: 'list_endpoints', description: 'Inventory of HTTP endpoints defined in the repo (Express/Fastify/Nest/Flask/FastAPI/Go mux/Rust axum and actix-web/Spring MVC and WebFlux): method, composed path, handler, and file:line.', inputSchema: {type: 'object', properties: {max_results: {type: 'integer', description: 'Max endpoints to list, default 100'}}}, run: (g, a, ctx) => th.tListEndpoints(g, a, ctx)},
@@ -134,7 +153,7 @@ function buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc}) {
 // present string (even '') is an explicit selection, so "select nothing" really exposes nothing.
 export async function loadHotApi(version, capsArg) {
     const v = version ? `?v=${version}` : ''
-    const [tg, ti, th, ts, tb, ta, tar, thi, tc] = await Promise.all([
+    const [tg, ti, th, ts, tb, ta, tar, thi, tc, tv] = await Promise.all([
         import(new URL(`./tools-graph.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-impact.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-health.mjs${v}`, import.meta.url).href),
@@ -144,12 +163,13 @@ export async function loadHotApi(version, capsArg) {
         import(new URL(`./tools-architecture.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-history.mjs${v}`, import.meta.url).href),
         import(new URL(`./tools-company.mjs${v}`, import.meta.url).href),
+        import(new URL(`./tools-verified-change.mjs${v}`, import.meta.url).href),
     ])
-    const all = buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc})
     const raw = capsArg == null ? 'offline' : String(capsArg).trim()
     const selected = PROFILE_CAPS[raw] || raw.split(',').map((s) => s.trim()).filter(Boolean)
         .flatMap((cap) => cap === 'online' ? ['advisories', 'hosted'] : [cap])
     const caps = new Set(selected)
+    const all = buildTools({tg, ti, th, ts, tb, ta, tar, thi, tc, tv, caps})
     const tools = all.filter((t) => caps.has(t.cap))
     return {
         tools,

package/src/mcp/graph-context.mjs

@@ -163,13 +163,37 @@ const CLASS_QUERY_TERMS = Object.freeze({
 })
 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 LANGUAGE_EXTENSIONS = Object.freeze({
+    rust: ['rs'], python: ['py', 'pyi'], typescript: ['ts', 'tsx', 'mts', 'cts'],
+    javascript: ['js', 'jsx', 'mjs', 'cjs'], go: ['go'], java: ['java'], csharp: ['cs'],
+})
+
+function requestedLanguages(query) {
+    const raw = String(query || '')
+    const words = new Set(wordsOf(query))
+    const requested = new Set()
+    if (words.has('rust')) requested.add('rust')
+    if (words.has('python') || words.has('py')) requested.add('python')
+    if (words.has('typescript') || words.has('ts') || /typescript/i.test(raw)) requested.add('typescript')
+    if (words.has('javascript') || words.has('js') || words.has('nodejs') || /javascript|node\.?js/i.test(raw)) requested.add('javascript')
+    if (words.has('golang') || /(?:^|[^A-Za-z])Go(?:[^A-Za-z]|$)/.test(raw)) requested.add('go')
+    if (words.has('java')) requested.add('java')
+    if (words.has('csharp') || words.has('dotnet') || /csharp|(?:^|[^A-Za-z])C#(?:[^A-Za-z]|$)/i.test(raw)) requested.add('csharp')
+    return new Set([...requested].flatMap((language) => LANGUAGE_EXTENSIONS[language]))
+}
+
+const matchesLanguage = (node, extensions) => {
+    if (!extensions.size) return true
+    const match = /\.([^.\/]+)$/.exec(sourceFileOf(node))
+    return !!match && extensions.has(match[1].toLowerCase())
+}
 
 const sourceFileOf = (node) => {
     const source = node?.source_file || String(node?.id ?? '').split('#', 1)[0]
     return normPath(source)
 }
 
-function requestedPathClasses(query) {
+export function requestedPathClasses(query) {
     const words = new Set(wordsOf(query))
     const requested = new Set()
     for (const [category, terms] of Object.entries(CLASS_QUERY_TERMS)) {
@@ -266,6 +290,14 @@ function conceptScore(g, node, concept, queryContext) {
         else if (words.has(term)) match = Math.max(match, primary ? 36 : 25)
         else if (term.length >= 4 && term !== 'tool' && term !== 'tools' && (id.includes(term) || label.includes(term))) match = Math.max(match, primary ? 12 : 7)
     })
+    const extension = (/\.([^.\/]+)$/.exec(source) || [])[1] || ''
+    const languageConcept = {
+        rust: ['rs'], python: ['py', 'pyi'], py: ['py', 'pyi'],
+        typescript: ['ts', 'tsx', 'mts', 'cts'], ts: ['ts', 'tsx', 'mts', 'cts'],
+        javascript: ['js', 'jsx', 'mjs', 'cjs'], js: ['js', 'jsx', 'mjs', 'cjs'], nodejs: ['js', 'jsx', 'mjs', 'cjs'],
+        golang: ['go'], go: ['go'], java: ['java'], csharp: ['cs'], dotnet: ['cs'],
+    }[concept.raw]
+    if (languageConcept?.includes(extension) && queryContext.languageExtensions.has(extension)) match = Math.max(match, 58)
     const fileNode = !isSymbol(node.id)
     const depth = source ? source.split('/').length : 9
     if (concept.id === 'bootstrap') match = Math.max(match, entrypointSignal(g, node, source, stem))
@@ -288,13 +320,16 @@ export function findSeeds(g, query, limit = 8, {repoRoot = null} = {}) {
     const concepts = queryConcepts(query)
     if (!concepts.length || limit <= 0) return []
     const requestedClasses = requestedPathClasses(query)
+    const languageExtensions = requestedLanguages(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)),
+        languageExtensions,
     }
     const classifier = createPathClassifier(repoRoot)
     const classificationCache = new Map()
-    const rows = g.nodes.filter((node) => isQueryEligible(node, requestedClasses, classificationCache, classifier)).map((node) => {
+    const rows = g.nodes.filter((node) => matchesLanguage(node, languageExtensions)
+        && 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}
     })