weavatrix 0.3.6 → 0.3.8

package/docs/releases/v0.3.7.md

@@ -0,0 +1,37 @@
+# Weavatrix 0.3.7
+
+0.3.7 fixes three defects surfaced by cross-repository validation: a
+reverse-shell detection gap, an unbounded ripgrep-path probe that could hang the
+server, and a `search_code` path that excluded `node_modules` only through the
+gitignore stack.
+
+## Reverse-shell pre-filter now covers the confirming regex
+
+The malware content sweep uses each rule's `pattern` as the ripgrep pre-filter
+and only then applies the stricter `re` to confirm. The reverse-shell `pattern`
+had drifted narrower than its `re`: it required `SOCK_STREAM` followed by
+`/bin/sh` or `exec`, so socket-backed shells using `connect`, `subprocess`,
+`pty.spawn` or `os.dup2` — and default `socket.socket()` calls with no
+`SOCK_STREAM` literal — were dropped before they could be confirmed. The
+pre-filter is now a superset of the confirming regex, and a new invariant test
+asserts that every payload the confirming regex flags is also surfaced by the
+pre-filter.
+
+A separate, deeper case is deliberately left for a follow-up: multi-line reverse
+shells, where ripgrep's per-line matching cannot span a `socket` call and the
+shell invocation on different lines.
+
+## Bounded ripgrep-path probe
+
+The `where`/`which rg` fallback in the MCP ripgrep resolver ran `spawnSync`
+without a timeout on the main thread, so a slow or unreachable PATH entry (for
+example a disconnected network drive) could hang the server. The probe now runs
+with a three-second timeout and `windowsHide`.
+
+## search_code excludes node_modules explicitly
+
+The `search_code` ripgrep invocation passed `--hidden` with only a `.git`
+exclusion, leaving `node_modules` out of results solely through ripgrep's
+implicit gitignore stack — which fails for repositories that commit their
+dependency tree or lack a gitignore. An explicit `!node_modules` glob is now
+applied; a caller-supplied glob is still appended afterward and wins.

package/docs/releases/v0.3.8.md

@@ -0,0 +1,21 @@
+# Weavatrix 0.3.8
+
+0.3.8 is a documentation and internal-structure release. Tool behavior and
+output are unchanged.
+
+## Slimmer README
+
+The README is refocused on the current release — install, configuration, tools,
+benchmarks and the security model — and the accumulated per-version changelog is
+removed in favor of the existing per-version notes under
+[docs/releases/](../releases/). This also slims the README rendered on the npm
+package page.
+
+## Internal module split
+
+`src/analysis/dead-code-review.js` is split along the repository's existing
+facade convention: the per-candidate record builders (`symbolCandidate`,
+`fileCandidate`) move to `src/analysis/dead-code-review/candidates.js`, while the
+orchestrator and the public `computeDeadCodeReview` export stay in place.
+Importers and returned records are unchanged, and both files are now within the
+300-line owner-module budget.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weavatrix",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "description": "Local repository intelligence MCP for AI coding agents: reusable architecture graph for fast application understanding, Health, dead code, clones, history, blast radius and architecture safeguards.",
   "author": "Sergii Ziborov <sergii.ziborov@gmail.com>",
@@ -40,6 +40,8 @@
     "docs/releases/v0.3.4.md",
     "docs/releases/v0.3.5.md",
     "docs/releases/v0.3.6.md",
+    "docs/releases/v0.3.7.md",
+    "docs/releases/v0.3.8.md",
     "docs/releases/v0.2.19.md",
     "README.md",
     "SECURITY.md",

package/src/analysis/dead-code-review/candidates.js

@@ -0,0 +1,194 @@
+// Per-candidate review records for the dead-code review queue, split out of dead-code-review.js so the
+// orchestrator stays within the file budget. The confidence, caveat, evidence and verification model is
+// unchanged; symbolCandidate and fileCandidate are pure over the context built by computeDeadCodeReview.
+import { isFrameworkEntryFile } from "../dead-check.js";
+import {
+  hasDynamicCode, REFLECTION_CODE_RE as REFLECTION_RE, normalizedReviewPath as normalizedPath,
+} from "./policy.js";
+
+const lineOf = (node) => {
+  const match = /@(\d+)$/.exec(String(node?.id || "")) || /L(\d+)/.exec(String(node?.source_location || ""));
+  return match ? Number(match[1]) : 0;
+};
+const bareLabel = (value) => String(value || "").replace(/\s*\(.*$/, "").replace(/[()]/g, "").trim();
+
+function kindOf(node) {
+  const symbolKind = String(node?.symbol_kind || "").toLowerCase();
+  if (symbolKind === "method" || symbolKind === "constructor") return "method";
+  if (["function", "function_definition", "func", "fn"].includes(symbolKind)) return "function";
+  // Old graphs may not retain symbol_kind. Only use call syntax as a compatibility fallback;
+  // member_of alone also describes fields and must never promote them to methods.
+  if (!symbolKind && /\([^)]*\)\s*$/.test(String(node?.label || ""))) return node?.member_of ? "method" : "function";
+  return "symbol";
+}
+
+function isPublicSurface(node) {
+  const visibility = String(node?.visibility || "").toLowerCase();
+  return node?.exported === true || visibility === "public" || visibility === "protected";
+}
+
+export function symbolCandidate(item, node, context) {
+  const file = normalizedPath(item.file);
+  const source = String(context.sources.get(file) || "");
+  const pathInfo = context.classify(file, source);
+  const publicSurface = isPublicSurface(node);
+  const testOnly = item.testOnly === true;
+  const externalEntry = context.entrySet.has(file) || isFrameworkEntryFile(file);
+  const framework = context.frameworkByFile.get(file) || null;
+  const dynamicFile = context.dynamicTargets.has(file) || hasDynamicCode(source, file);
+  const reflectionFile = REFLECTION_RE.test(source);
+  const kind = kindOf(node);
+  const exactNoReference = context.exactNoReferenceIds.has(String(item.id));
+  const internallyScoped = String(node?.visibility || "").toLowerCase() === "private"
+    || (!publicSurface && ["method", "function"].includes(kind));
+  // Static absence alone is never high-confidence dead code. High is reserved for a successfully
+  // queried semantic declaration whose language server also returned no in-workspace references.
+  let confidence = internallyScoped && exactNoReference ? "high" : "medium";
+  const caveats = [];
+
+  if (internallyScoped && !exactNoReference) {
+    caveats.push("No complete exact semantic no-reference result is available for this declaration; static absence remains medium confidence.");
+  }
+
+  if (publicSurface) {
+    confidence = "low";
+    caveats.push("Public/exported APIs can be consumed by downstream packages, interfaces, reflection, dependency injection, templates, or configuration outside this repository.");
+  }
+  if (externalEntry || framework) {
+    confidence = "low";
+    caveats.push(framework?.reason || "This file is an externally entered or framework-owned surface; static inbound edges are not complete usage evidence.");
+  }
+  if (node?.decorated) {
+    confidence = "low";
+    caveats.push("Decorators/annotations can register this symbol without a direct caller.");
+  }
+  if (dynamicFile) {
+    confidence = "low";
+    caveats.push("The declaring file uses or is reached through dynamic loading, so the static graph can miss callers.");
+  }
+  if (reflectionFile || (publicSurface && context.repoSignals.reflection)) {
+    confidence = "low";
+    caveats.push("Reflection is present and may invoke names without a resolvable static edge.");
+  }
+
+  const evidenceTier = confidence === "high" && exactNoReference
+    ? "STRONG_STATIC_EVIDENCE"
+    : confidence === "low" ? "HIGH_UNCERTAINTY" : "BOUNDED_STATIC_EVIDENCE";
+  const remainingChecks = [
+    ...(!exactNoReference ? ["Run an exact language-server reference query for this declaration."] : []),
+    ...(publicSurface ? ["Check downstream/external consumers of the public API."] : []),
+    ...(externalEntry || framework ? ["Inspect framework registration and externally entered call paths."] : []),
+    ...(dynamicFile ? ["Resolve dynamic import/require targets and name-based dispatch."] : []),
+    ...(reflectionFile || (publicSurface && context.repoSignals.reflection) ? ["Inspect reflection/annotation/configuration consumers."] : []),
+    "Run targeted tests after any removal.",
+  ];
+
+  return {
+    id: String(item.id),
+    kind,
+    classification: testOnly ? `test-only-${kind}` : publicSurface ? `public-${kind}` : kind === "method" ? "internal-method" : kind === "function" ? "internal-function" : "unreferenced-symbol",
+    file,
+    line: lineOf(node),
+    symbol: bareLabel(node?.label || item.label),
+    owner: node?.member_of || null,
+    symbolKind: node?.symbol_kind || null,
+    visibility: node?.visibility || (node?.exported ? "exported" : "internal"),
+    confidence,
+    evidenceTier,
+    actionability: evidenceTier === "STRONG_STATIC_EVIDENCE" ? "PRIORITY_MANUAL_REVIEW" : "MANUAL_REVIEW",
+    reason: item.reason,
+    evidence: [
+      ...(testOnly ? [{kind: item.evidence || "graph", fact: `Only test/e2e consumers were found${item.testConsumerFiles?.length ? `: ${item.testConsumerFiles.join(", ")}` : "."}`}]
+        : [{ kind: "graph", fact: "No inbound non-structural graph edge targets this symbol." }, { kind: "source-index", fact: "Its identifier has no second indexed occurrence that establishes a caller." }]),
+      ...(exactNoReference ? [{kind: "exact-lsp", fact: "The active language server returned no in-workspace references for this exact declaration."}] : []),
+    ],
+    caveats,
+    publicApi: publicSurface,
+    externallyEnteredFile: externalEntry,
+    pathClasses: pathInfo.classes || [],
+    matchedPathRule: pathInfo.matchedRule || null,
+    verification: {
+      graphInboundRuntimeEdge: "NOT_FOUND",
+      indexedSecondOccurrence: testOnly ? "TEST_ONLY" : "NOT_FOUND",
+      exactLanguageServerReferences: exactNoReference ? "ZERO_CONFIRMED" : "NOT_CHECKED_OR_INCOMPLETE",
+      recognizedEntryPoint: externalEntry ? "FOUND" : "NOT_FOUND",
+      dynamicLoadingRisk: dynamicFile ? "PRESENT" : "NOT_OBSERVED_IN_DECLARING_FILE",
+      reflectionRisk: reflectionFile || (publicSurface && context.repoSignals.reflection) ? "PRESENT" : "NOT_OBSERVED",
+      publicApi: publicSurface ? "YES" : "NO",
+      decision: "MANUAL_REVIEW_REQUIRED",
+    },
+    remainingChecks,
+    autoDelete: false,
+    reviewAction: testOnly
+      ? "Confirm that no production/config/framework consumer exists; decide whether the declaration is intentional test support or removable with its tests. Never auto-delete."
+      : "Confirm with read_source, get_dependents, exact search, framework/config inspection and tests; never auto-delete.",
+  };
+}
+
+export function fileCandidate(item, symbols, context) {
+  const file = normalizedPath(item.file);
+  const source = String(context.sources.get(file) || "");
+  const pathInfo = context.classify(file, source);
+  const publicSymbols = symbols.filter((symbol) => symbol.publicApi);
+  const dynamicFile = context.dynamicTargets.has(file) || hasDynamicCode(source, file);
+  const reflectionFile = REFLECTION_RE.test(source);
+  // Whole-file liveness always remains at most medium: external launchers/manifests can exist outside
+  // the indexed import graph even when every internal symbol signal is otherwise strong.
+  let confidence = "medium";
+  const caveats = ["Files can be launched by scripts, plugins, manifests, framework conventions, generated consumers, or external tooling without an import edge."];
+  if (publicSymbols.length) {
+    confidence = "low";
+    caveats.push(`${publicSymbols.length} indexed public/exported symbol(s) may be consumed outside this repository.`);
+  }
+  if (dynamicFile) {
+    confidence = "low";
+    caveats.push("Dynamic loading is present in or targets this file.");
+  }
+  if (reflectionFile) {
+    confidence = "low";
+    caveats.push("Reflection is present in this file.");
+  }
+  const remainingChecks = [
+    "Inspect package scripts, manifests, framework/plugin discovery and deployment configuration.",
+    "Check external launchers and consumers outside the indexed repository.",
+    ...(dynamicFile ? ["Resolve dynamic import/require targets."] : []),
+    ...(reflectionFile ? ["Inspect reflection/name-based consumers."] : []),
+    "Run targeted tests after any removal.",
+  ];
+  return {
+    id: `file:${file}`,
+    kind: "file",
+    classification: "unreferenced-file",
+    file,
+    line: 1,
+    symbol: null,
+    owner: null,
+    symbolKind: null,
+    visibility: null,
+    confidence,
+    evidenceTier: confidence === "low" ? "HIGH_UNCERTAINTY" : "BOUNDED_STATIC_EVIDENCE",
+    actionability: "MANUAL_REVIEW",
+    reason: item.reason,
+    evidence: [
+      { kind: "graph", fact: "No indexed module imports this file." },
+      { kind: "symbol-liveness", fact: "Every indexed symbol in the file is statically unreferenced." },
+    ],
+    caveats,
+    publicApi: publicSymbols.length > 0,
+    externallyEnteredFile: false,
+    pathClasses: pathInfo.classes || [],
+    matchedPathRule: pathInfo.matchedRule || null,
+    verification: {
+      graphInboundModuleEdge: "NOT_FOUND",
+      indexedSymbolsReferenced: "NONE",
+      recognizedEntryPoint: "NOT_FOUND",
+      dynamicLoadingRisk: dynamicFile ? "PRESENT" : "NOT_OBSERVED",
+      reflectionRisk: reflectionFile ? "PRESENT" : "NOT_OBSERVED",
+      externalConsumerCheck: "NOT_POSSIBLE_FROM_REPOSITORY_GRAPH",
+      decision: "MANUAL_REVIEW_REQUIRED",
+    },
+    remainingChecks,
+    autoDelete: false,
+    reviewAction: "Verify package scripts, manifests, framework discovery, dynamic loading and external consumers; never auto-delete.",
+  };
+}

package/src/analysis/dead-code-review.js

@@ -1,200 +1,16 @@
 // Conservative, source-free review queue for statically unreferenced code. This deliberately builds
 // on computeDead instead of inventing a second liveness model. Candidates are evidence for review,
 // never deletion instructions: framework entry, dynamic loading, reflection and public API surfaces
-// lower confidence and remain explicit in the returned record.
-import { computeDead, isFrameworkEntryFile } from "./dead-check.js";
+// lower confidence and remain explicit in the returned record. Per-candidate record shapes live in
+// dead-code-review/candidates.js; this module owns collection, filtering and the summary envelope.
+import { computeDead } from "./dead-check.js";
 import { createPathClassifier } from "../path-classification.js";
 import {
   DEAD_CODE_CONFIDENCE_RANK as CONFIDENCE_RANK, hasDynamicCode,
   REFLECTION_CODE_RE as REFLECTION_RE, deadCodePathAllowed as pathAllowed,
   normalizedReviewPath as normalizedPath,
 } from './dead-code-review/policy.js'
-const lineOf = (node) => {
-  const match = /@(\d+)$/.exec(String(node?.id || "")) || /L(\d+)/.exec(String(node?.source_location || ""));
-  return match ? Number(match[1]) : 0;
-};
-const bareLabel = (value) => String(value || "").replace(/\s*\(.*$/, "").replace(/[()]/g, "").trim();
-
-function kindOf(node) {
-  const symbolKind = String(node?.symbol_kind || "").toLowerCase();
-  if (symbolKind === "method" || symbolKind === "constructor") return "method";
-  if (["function", "function_definition", "func", "fn"].includes(symbolKind)) return "function";
-  // Old graphs may not retain symbol_kind. Only use call syntax as a compatibility fallback;
-  // member_of alone also describes fields and must never promote them to methods.
-  if (!symbolKind && /\([^)]*\)\s*$/.test(String(node?.label || ""))) return node?.member_of ? "method" : "function";
-  return "symbol";
-}
-
-function isPublicSurface(node) {
-  const visibility = String(node?.visibility || "").toLowerCase();
-  return node?.exported === true || visibility === "public" || visibility === "protected";
-}
-
-function symbolCandidate(item, node, context) {
-  const file = normalizedPath(item.file);
-  const source = String(context.sources.get(file) || "");
-  const pathInfo = context.classify(file, source);
-  const publicSurface = isPublicSurface(node);
-  const testOnly = item.testOnly === true;
-  const externalEntry = context.entrySet.has(file) || isFrameworkEntryFile(file);
-  const framework = context.frameworkByFile.get(file) || null;
-  const dynamicFile = context.dynamicTargets.has(file) || hasDynamicCode(source, file);
-  const reflectionFile = REFLECTION_RE.test(source);
-  const kind = kindOf(node);
-  const exactNoReference = context.exactNoReferenceIds.has(String(item.id));
-  const internallyScoped = String(node?.visibility || "").toLowerCase() === "private"
-    || (!publicSurface && ["method", "function"].includes(kind));
-  // Static absence alone is never high-confidence dead code. High is reserved for a successfully
-  // queried semantic declaration whose language server also returned no in-workspace references.
-  let confidence = internallyScoped && exactNoReference ? "high" : "medium";
-  const caveats = [];
-
-  if (internallyScoped && !exactNoReference) {
-    caveats.push("No complete exact semantic no-reference result is available for this declaration; static absence remains medium confidence.");
-  }
-
-  if (publicSurface) {
-    confidence = "low";
-    caveats.push("Public/exported APIs can be consumed by downstream packages, interfaces, reflection, dependency injection, templates, or configuration outside this repository.");
-  }
-  if (externalEntry || framework) {
-    confidence = "low";
-    caveats.push(framework?.reason || "This file is an externally entered or framework-owned surface; static inbound edges are not complete usage evidence.");
-  }
-  if (node?.decorated) {
-    confidence = "low";
-    caveats.push("Decorators/annotations can register this symbol without a direct caller.");
-  }
-  if (dynamicFile) {
-    confidence = "low";
-    caveats.push("The declaring file uses or is reached through dynamic loading, so the static graph can miss callers.");
-  }
-  if (reflectionFile || (publicSurface && context.repoSignals.reflection)) {
-    confidence = "low";
-    caveats.push("Reflection is present and may invoke names without a resolvable static edge.");
-  }
-
-  const evidenceTier = confidence === "high" && exactNoReference
-    ? "STRONG_STATIC_EVIDENCE"
-    : confidence === "low" ? "HIGH_UNCERTAINTY" : "BOUNDED_STATIC_EVIDENCE";
-  const remainingChecks = [
-    ...(!exactNoReference ? ["Run an exact language-server reference query for this declaration."] : []),
-    ...(publicSurface ? ["Check downstream/external consumers of the public API."] : []),
-    ...(externalEntry || framework ? ["Inspect framework registration and externally entered call paths."] : []),
-    ...(dynamicFile ? ["Resolve dynamic import/require targets and name-based dispatch."] : []),
-    ...(reflectionFile || (publicSurface && context.repoSignals.reflection) ? ["Inspect reflection/annotation/configuration consumers."] : []),
-    "Run targeted tests after any removal.",
-  ];
-
-  return {
-    id: String(item.id),
-    kind,
-    classification: testOnly ? `test-only-${kind}` : publicSurface ? `public-${kind}` : kind === "method" ? "internal-method" : kind === "function" ? "internal-function" : "unreferenced-symbol",
-    file,
-    line: lineOf(node),
-    symbol: bareLabel(node?.label || item.label),
-    owner: node?.member_of || null,
-    symbolKind: node?.symbol_kind || null,
-    visibility: node?.visibility || (node?.exported ? "exported" : "internal"),
-    confidence,
-    evidenceTier,
-    actionability: evidenceTier === "STRONG_STATIC_EVIDENCE" ? "PRIORITY_MANUAL_REVIEW" : "MANUAL_REVIEW",
-    reason: item.reason,
-    evidence: [
-      ...(testOnly ? [{kind: item.evidence || "graph", fact: `Only test/e2e consumers were found${item.testConsumerFiles?.length ? `: ${item.testConsumerFiles.join(", ")}` : "."}`}]
-        : [{ kind: "graph", fact: "No inbound non-structural graph edge targets this symbol." }, { kind: "source-index", fact: "Its identifier has no second indexed occurrence that establishes a caller." }]),
-      ...(exactNoReference ? [{kind: "exact-lsp", fact: "The active language server returned no in-workspace references for this exact declaration."}] : []),
-    ],
-    caveats,
-    publicApi: publicSurface,
-    externallyEnteredFile: externalEntry,
-    pathClasses: pathInfo.classes || [],
-    matchedPathRule: pathInfo.matchedRule || null,
-    verification: {
-      graphInboundRuntimeEdge: "NOT_FOUND",
-      indexedSecondOccurrence: testOnly ? "TEST_ONLY" : "NOT_FOUND",
-      exactLanguageServerReferences: exactNoReference ? "ZERO_CONFIRMED" : "NOT_CHECKED_OR_INCOMPLETE",
-      recognizedEntryPoint: externalEntry ? "FOUND" : "NOT_FOUND",
-      dynamicLoadingRisk: dynamicFile ? "PRESENT" : "NOT_OBSERVED_IN_DECLARING_FILE",
-      reflectionRisk: reflectionFile || (publicSurface && context.repoSignals.reflection) ? "PRESENT" : "NOT_OBSERVED",
-      publicApi: publicSurface ? "YES" : "NO",
-      decision: "MANUAL_REVIEW_REQUIRED",
-    },
-    remainingChecks,
-    autoDelete: false,
-    reviewAction: testOnly
-      ? "Confirm that no production/config/framework consumer exists; decide whether the declaration is intentional test support or removable with its tests. Never auto-delete."
-      : "Confirm with read_source, get_dependents, exact search, framework/config inspection and tests; never auto-delete.",
-  };
-}
-
-function fileCandidate(item, symbols, context) {
-  const file = normalizedPath(item.file);
-  const source = String(context.sources.get(file) || "");
-  const pathInfo = context.classify(file, source);
-  const publicSymbols = symbols.filter((symbol) => symbol.publicApi);
-  const dynamicFile = context.dynamicTargets.has(file) || hasDynamicCode(source, file);
-  const reflectionFile = REFLECTION_RE.test(source);
-  // Whole-file liveness always remains at most medium: external launchers/manifests can exist outside
-  // the indexed import graph even when every internal symbol signal is otherwise strong.
-  let confidence = "medium";
-  const caveats = ["Files can be launched by scripts, plugins, manifests, framework conventions, generated consumers, or external tooling without an import edge."];
-  if (publicSymbols.length) {
-    confidence = "low";
-    caveats.push(`${publicSymbols.length} indexed public/exported symbol(s) may be consumed outside this repository.`);
-  }
-  if (dynamicFile) {
-    confidence = "low";
-    caveats.push("Dynamic loading is present in or targets this file.");
-  }
-  if (reflectionFile) {
-    confidence = "low";
-    caveats.push("Reflection is present in this file.");
-  }
-  const remainingChecks = [
-    "Inspect package scripts, manifests, framework/plugin discovery and deployment configuration.",
-    "Check external launchers and consumers outside the indexed repository.",
-    ...(dynamicFile ? ["Resolve dynamic import/require targets."] : []),
-    ...(reflectionFile ? ["Inspect reflection/name-based consumers."] : []),
-    "Run targeted tests after any removal.",
-  ];
-  return {
-    id: `file:${file}`,
-    kind: "file",
-    classification: "unreferenced-file",
-    file,
-    line: 1,
-    symbol: null,
-    owner: null,
-    symbolKind: null,
-    visibility: null,
-    confidence,
-    evidenceTier: confidence === "low" ? "HIGH_UNCERTAINTY" : "BOUNDED_STATIC_EVIDENCE",
-    actionability: "MANUAL_REVIEW",
-    reason: item.reason,
-    evidence: [
-      { kind: "graph", fact: "No indexed module imports this file." },
-      { kind: "symbol-liveness", fact: "Every indexed symbol in the file is statically unreferenced." },
-    ],
-    caveats,
-    publicApi: publicSymbols.length > 0,
-    externallyEnteredFile: false,
-    pathClasses: pathInfo.classes || [],
-    matchedPathRule: pathInfo.matchedRule || null,
-    verification: {
-      graphInboundModuleEdge: "NOT_FOUND",
-      indexedSymbolsReferenced: "NONE",
-      recognizedEntryPoint: "NOT_FOUND",
-      dynamicLoadingRisk: dynamicFile ? "PRESENT" : "NOT_OBSERVED",
-      reflectionRisk: reflectionFile ? "PRESENT" : "NOT_OBSERVED",
-      externalConsumerCheck: "NOT_POSSIBLE_FROM_REPOSITORY_GRAPH",
-      decision: "MANUAL_REVIEW_REQUIRED",
-    },
-    remainingChecks,
-    autoDelete: false,
-    reviewAction: "Verify package scripts, manifests, framework discovery, dynamic loading and external consumers; never auto-delete.",
-  };
-}
+import { symbolCandidate, fileCandidate } from './dead-code-review/candidates.js'
 
 // Pure review model. Filesystem collection/entry inference stays in the MCP adapter so tests can pass
 // exact source maps and convention evidence without touching the working tree.

package/src/mcp-rg.mjs

@@ -43,7 +43,7 @@ export function createRgResolver(selfDir) {
         } catch { /* optional packaged ripgrep path */ }
         for (const c of editorRgCandidates()) if (existsSync(c)) return (rgPath = c)
         try {
-            const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {encoding: 'utf8', env: childProcessEnv()})
+            const probe = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['rg'], {encoding: 'utf8', env: childProcessEnv(), timeout: 3000, windowsHide: true})
             const p = probe.status === 0 ? probe.stdout.split(/\r?\n/)[0].trim() : ''
             if (p && existsSync(p)) return (rgPath = p)
         } catch { /* optional PATH probe */ }

package/src/mcp-source-tools.mjs

@@ -14,7 +14,10 @@ const MAX_SOURCE_CONTEXT_LINES = 1000
 function rgSearch(repoRoot, resolveRg, query, { isRegex, glob, maxResults }, spawnRg = spawnSync) {
     const rg = resolveRg()
     if (!rg) return null
-    const args = ['--line-number', '--no-heading', '--color', 'never', '--hidden', '-g', '!.git/**', '-m', '100', '-i']
+    // Exclude node_modules explicitly: --hidden + the default gitignore stack is the only thing that
+    // keeps a dependency tree out, which fails for repos that commit node_modules or lack a gitignore.
+    // A caller-supplied glob is appended after this and still wins (rg: last matching glob decides).
+    const args = ['--line-number', '--no-heading', '--color', 'never', '--hidden', '-g', '!.git/**', '-g', '!node_modules', '-m', '100', '-i']
     if (!isRegex) args.push('--fixed-strings')
     if (glob) args.push('-g', glob)
     // Run from the repository root and search `.` so path globs such as `src/**` are evaluated

package/src/security/registry-sig.rules.js

@@ -35,7 +35,10 @@ export const CONTENT_RULES = [
     nearZeroFp: true,
     // canonical reverse/bind shells — a shell wired to a socket. Essentially never legitimate inside a
     // published package: /dev/tcp redirection, netcat -e, interactive-shell redirect, mkfifo pipe shell.
-    pattern: "/dev/tcp/[0-9]|\\bnc(at)?\\s+-e\\b|\\b(ba)?sh\\s+-i\\b\\s*(2)?>&|mkfifo\\b.{0,60}(ba)?sh\\b|0<&196|socket\\.socket\\(.{0,40}(SOCK_STREAM).{0,80}(/bin/sh|exec)",
+    // The rg pre-filter must stay a superset of `re` below: rg surfaces lines matching this string and
+    // only then is `re` applied to confirm, so a narrower pre-filter silently drops real reverse shells
+    // (e.g. socket + pty.spawn / os.dup2 / subprocess, or a default socket.socket() without SOCK_STREAM).
+    pattern: "/dev/tcp/[0-9]|\\bnc(at)?\\s+-e\\b|\\b(ba)?sh\\s+-i\\b\\s*(2)?>&|mkfifo\\b.{0,60}(ba)?sh\\b|0<&196|socket\\.socket\\(.{0,120}(connect|SOCK_STREAM).{0,180}(/bin/sh|subprocess|pty\\.spawn|os\\.dup2)",
     re: /\/dev\/tcp\/[0-9]|\bnc(at)?\s+-e\b|\b(ba)?sh\s+-i\b\s*(2)?>&|mkfifo\b[\s\S]{0,60}?\b(ba)?sh\b|0<&196|socket\.socket\([\s\S]{0,120}?(connect|SOCK_STREAM)[\s\S]{0,180}?(\/bin\/sh|subprocess|pty\.spawn|os\.dup2)/i,
     what: "reverse/bind-shell pattern (interactive shell wired to a socket)",
   },