depwire-cli 0.7.1 → 0.9.0

package/dist/{chunk-65H7HCM4.js → chunk-MGMDHXPB.js}

@@ -29,7 +29,8 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isJavaScript = entry.endsWith(".js") || entry.endsWith(".jsx") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
         const isPython = entry.endsWith(".py");
         const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
-        if (isTypeScript || isJavaScript || isPython || isGo) {
+        const isRust = entry.endsWith(".rs");
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -54,6 +55,8 @@ function findProjectRoot(startDir = process.cwd()) {
     // TypeScript
     "go.mod",
     // Go
+    "Cargo.toml",
+    // Rust
     "pyproject.toml",
     // Python (modern)
     "setup.py",
@@ -80,8 +83,8 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
 
 // src/parser/detect.ts
 import { extname as extname3 } from "path";
@@ -109,7 +112,8 @@ async function initParser() {
     "tsx": "tree-sitter-tsx.wasm",
     "javascript": "tree-sitter-javascript.wasm",
     "python": "tree-sitter-python.wasm",
-    "go": "tree-sitter-go.wasm"
+    "go": "tree-sitter-go.wasm",
+    "rust": "tree-sitter-rust.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -1972,12 +1976,429 @@ var goParser = {
   parseFile: parseGoFile
 };
 
+// src/parser/rust.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6, dirname as dirname5, relative as relative3 } from "path";
+function parseRustFile(filePath, sourceCode, projectRoot) {
+  const parser = getParser("rust");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentModule: []
+  };
+  walkNode5(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode5(node, context) {
+  processNode5(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode5(child, context);
+    }
+  }
+}
+function processNode5(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_item":
+      processFunctionItem(node, context);
+      break;
+    case "struct_item":
+      processStructItem(node, context);
+      break;
+    case "enum_item":
+      processEnumItem(node, context);
+      break;
+    case "trait_item":
+      processTraitItem(node, context);
+      break;
+    case "impl_item":
+      processImplItem(node, context);
+      break;
+    case "const_item":
+      processConstItem(node, context);
+      break;
+    case "type_item":
+      processTypeItem(node, context);
+      break;
+    case "use_declaration":
+      processUseDeclaration(node, context);
+      break;
+    case "mod_item":
+      processModItem(node, context);
+      break;
+    case "call_expression":
+      processCallExpression5(node, context);
+      break;
+  }
+}
+function processFunctionItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode5(body, context);
+  }
+  context.currentScope.pop();
+}
+function processStructItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    // Consistent with other parsers
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processEnumItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "enum",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processTraitItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "interface",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processImplItem(node, context) {
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return;
+  const typeName = extractTypeName2(typeNode, context);
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "function_item") {
+      const nameNode = child.childForFieldName("name");
+      if (!nameNode) continue;
+      const name = nodeText4(nameNode, context);
+      const exported = hasVisibility(child, "pub");
+      const symbolId = `${context.filePath}::${typeName}.${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "method",
+        filePath: context.filePath,
+        startLine: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        exported,
+        scope: typeName
+      });
+      context.currentScope.push(`${typeName}.${name}`);
+      const body = child.childForFieldName("body");
+      if (body) {
+        walkNode5(body, context);
+      }
+      context.currentScope.pop();
+    }
+  }
+}
+function processConstItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "constant",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processTypeItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "type_alias",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processUseDeclaration(node, context) {
+  let pathNode = findChildByType5(node, "scoped_identifier");
+  if (!pathNode) {
+    pathNode = findChildByType5(node, "identifier");
+  }
+  if (!pathNode) {
+    pathNode = findChildByType5(node, "use_as_clause");
+    if (pathNode) {
+      pathNode = pathNode.childForFieldName("path");
+    }
+  }
+  if (!pathNode) {
+    return;
+  }
+  let pathText = nodeText4(pathNode, context);
+  if (!pathText.startsWith("crate::") && !pathText.startsWith("super::") && !pathText.startsWith("self::")) {
+    return;
+  }
+  const segments = pathText.split("::");
+  if (segments.length > 1) {
+    segments.pop();
+    pathText = segments.join("::");
+  }
+  const resolvedFiles = resolveRustImport(pathText, context);
+  if (resolvedFiles.length === 0) return;
+  const sourceId = `${context.filePath}::__file__`;
+  for (const targetFile of resolvedFiles) {
+    const targetId = `${targetFile}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processModItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const body = node.childForFieldName("body");
+  if (!body) {
+    const resolvedFiles = resolveModuleFile(name, context);
+    if (resolvedFiles.length > 0) {
+      const sourceId = `${context.filePath}::__file__`;
+      for (const targetFile of resolvedFiles) {
+        const targetId = `${targetFile}::__file__`;
+        context.edges.push({
+          source: sourceId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: node.startPosition.row + 1
+        });
+      }
+    }
+  }
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "module",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processCallExpression5(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  const calleeName = extractCalleeNameFromNode(functionNode, context);
+  if (!calleeName) return;
+  const builtins = ["println!", "print!", "eprintln!", "eprint!", "format!", "panic!", "assert!", "assert_eq!", "assert_ne!", "vec!"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId5(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol4(calleeName, context);
+  if (!calleeId) return;
+  context.edges.push({
+    source: callerId,
+    target: calleeId,
+    kind: "calls",
+    filePath: context.filePath,
+    line: node.startPosition.row + 1
+  });
+}
+function resolveRustImport(importPath, context) {
+  if (importPath.startsWith("crate::")) {
+    const relativePath = importPath.replace("crate::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(context.projectRoot, "src", `${relativePath}.rs`),
+      join6(context.projectRoot, "src", relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  if (importPath.startsWith("super::")) {
+    const currentFileAbs = join6(context.projectRoot, context.filePath);
+    const currentDir = dirname5(currentFileAbs);
+    const parentDir = dirname5(currentDir);
+    const relativePath = importPath.replace("super::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(parentDir, `${relativePath}.rs`),
+      join6(parentDir, relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  if (importPath.startsWith("self::")) {
+    const currentFileAbs = join6(context.projectRoot, context.filePath);
+    const currentDir = dirname5(currentFileAbs);
+    const relativePath = importPath.replace("self::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(currentDir, `${relativePath}.rs`),
+      join6(currentDir, relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  return [];
+}
+function resolveModuleFile(moduleName, context) {
+  const currentFileAbs = join6(context.projectRoot, context.filePath);
+  const currentDir = dirname5(currentFileAbs);
+  const possibleFiles = [
+    join6(currentDir, `${moduleName}.rs`),
+    join6(currentDir, moduleName, "mod.rs")
+  ];
+  return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+}
+function hasVisibility(node, visibility) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "visibility_modifier") {
+      const text = nodeText4(child, { sourceCode: node.text });
+      return text === visibility;
+    }
+  }
+  return false;
+}
+function extractTypeName2(typeNode, context) {
+  if (typeNode.type === "type_identifier") {
+    return nodeText4(typeNode, context);
+  }
+  if (typeNode.type === "generic_type") {
+    const typeId = findChildByType5(typeNode, "type_identifier");
+    if (typeId) {
+      return nodeText4(typeId, context);
+    }
+  }
+  for (let i = 0; i < typeNode.childCount; i++) {
+    const child = typeNode.child(i);
+    if (child && child.type === "type_identifier") {
+      return nodeText4(child, context);
+    }
+  }
+  return null;
+}
+function extractCalleeNameFromNode(functionNode, context) {
+  if (functionNode.type === "identifier") {
+    return nodeText4(functionNode, context);
+  }
+  if (functionNode.type === "field_expression") {
+    const field = functionNode.childForFieldName("field");
+    if (field) {
+      return nodeText4(field, context);
+    }
+  }
+  if (functionNode.type === "scoped_identifier") {
+    const name = functionNode.childForFieldName("name");
+    if (name) {
+      return nodeText4(name, context);
+    }
+  }
+  return null;
+}
+function resolveSymbol4(name, context) {
+  const currentFileId = context.filePath;
+  const symbol = context.symbols.find((s) => s.name === name && s.filePath === currentFileId);
+  if (symbol) {
+    return symbol.id;
+  }
+  if (context.currentScope.length > 0) {
+    for (let i = context.currentScope.length - 1; i >= 0; i--) {
+      const scopedId = `${currentFileId}::${context.currentScope[i]}.${name}`;
+      const scopedSymbol = context.symbols.find((s) => s.id === scopedId);
+      if (scopedSymbol) {
+        return scopedId;
+      }
+    }
+  }
+  return null;
+}
+function findChildByType5(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function nodeText4(node, context) {
+  return context.sourceCode.slice(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId5(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join(".")}`;
+}
+var rustParser = {
+  language: "rust",
+  extensions: [".rs"],
+  parseFile: parseRustFile
+};
+
 // src/parser/detect.ts
 var parsers = [
   typescriptParser,
   pythonParser,
   javascriptParser,
-  goParser
+  goParser,
+  rustParser
 ];
 function getParserForFile(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -2007,12 +2428,12 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join6(projectRoot, file);
+      const fullPath = join7(projectRoot, file);
       if (options?.exclude) {
-        const shouldExclude = options.exclude.some(
+        const shouldExclude2 = options.exclude.some(
           (pattern) => minimatch(file, pattern, { matchBase: true })
         );
-        if (shouldExclude) {
+        if (shouldExclude2) {
           if (options.verbose) {
             console.error(`[Parser] Excluded: ${file}`);
           }
@@ -2033,7 +2454,7 @@ async function parseProject(projectRoot, options) {
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync3(fullPath, "utf-8");
+      const sourceCode = readFileSync4(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -2089,6 +2510,18 @@ function buildGraph(parsedFiles) {
           exported: false
         });
       }
+      if (edge.target.endsWith("::__file__") && !fileNodes.has(edge.target)) {
+        fileNodes.add(edge.target);
+        const filePath = edge.target.replace("::__file__", "");
+        graph.addNode(edge.target, {
+          name: "__file__",
+          kind: "import",
+          filePath,
+          startLine: 1,
+          endLine: 1,
+          exported: false
+        });
+      }
     }
   }
   for (const file of parsedFiles) {
@@ -2414,7 +2847,7 @@ function watchProject(projectRoot, callbacks) {
   const watcher = chokidar.watch(projectRoot, watcherOptions);
   console.error("[Watcher] Attaching event listeners...");
   watcher.on("change", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2422,7 +2855,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileChanged(relativePath);
   });
   watcher.on("add", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2430,7 +2863,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileAdded(relativePath);
   });
   watcher.on("unlink", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2460,10 +2893,10 @@ function watchProject(projectRoot, callbacks) {
 import express from "express";
 import open from "open";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname5, join as join7 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 import { WebSocketServer } from "ws";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname5(__filename);
+var __dirname2 = dirname6(__filename);
 var activeServer = null;
 async function findAvailablePort(startPort, maxAttempts = 10) {
   const net = await import("net");
@@ -2501,7 +2934,7 @@ async function startVizServer(initialVizData, graph, projectRoot, port = 3333, s
   const availablePort = await findAvailablePort(port);
   const app = express();
   let vizData = initialVizData;
-  const publicDir = join7(__dirname2, "viz", "public");
+  const publicDir = join8(__dirname2, "viz", "public");
   app.use(express.static(publicDir));
   app.get("/api/graph", (req, res) => {
     res.json(vizData);
@@ -2617,7 +3050,7 @@ function isProjectLoaded(state) {
 }
 
 // src/graph/updater.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function removeFileFromGraph(graph, filePath) {
   const nodesToRemove = [];
   graph.forEachNode((node, attrs) => {
@@ -2661,7 +3094,7 @@ function addFileToGraph(graph, parsedFile) {
 }
 async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
   removeFileFromGraph(graph, relativeFilePath);
-  const absolutePath = join8(projectRoot, relativeFilePath);
+  const absolutePath = join9(projectRoot, relativeFilePath);
   try {
     const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
     addFileToGraph(graph, parsedFile);
@@ -2671,7 +3104,7 @@ async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -2704,8 +3137,8 @@ function calculateCouplingScore(graph) {
       totalEdges++;
       fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
       fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
-      const sourceDir = dirname6(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname6(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname7(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname7(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -2752,8 +3185,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname6(sourceAttrs.filePath);
-      const targetDir = dirname6(targetAttrs.filePath);
+      const sourceDir = dirname7(sourceAttrs.filePath);
+      const targetDir = dirname7(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -2820,11 +3253,11 @@ function calculateCircularDepsScore(graph) {
   const visited = /* @__PURE__ */ new Set();
   const recStack = /* @__PURE__ */ new Set();
   const cycles = [];
-  function dfs(node, path2) {
+  function dfs(node, path6) {
     if (recStack.has(node)) {
-      const cycleStart = path2.indexOf(node);
+      const cycleStart = path6.indexOf(node);
       if (cycleStart >= 0) {
-        cycles.push(path2.slice(cycleStart));
+        cycles.push(path6.slice(cycleStart));
       }
       return;
     }
@@ -2833,11 +3266,11 @@ function calculateCircularDepsScore(graph) {
     }
     visited.add(node);
     recStack.add(node);
-    path2.push(node);
+    path6.push(node);
     const neighbors = fileGraph.get(node);
     if (neighbors) {
       for (const neighbor of neighbors) {
-        dfs(neighbor, [...path2]);
+        dfs(neighbor, [...path6]);
       }
     }
     recStack.delete(node);
@@ -2939,25 +3372,40 @@ function calculateOrphansScore(graph) {
   });
   const orphanCount = files.size - connectedFiles.size;
   const orphanPercent = files.size > 0 ? orphanCount / files.size * 100 : 0;
+  const totalSymbols = graph.order;
+  let deadSymbolCount = 0;
+  graph.forEachNode((node) => {
+    const inDegree = graph.inDegree(node);
+    if (inDegree === 0) {
+      deadSymbolCount++;
+    }
+  });
+  const deadCodePercent = totalSymbols > 0 ? deadSymbolCount / totalSymbols * 100 : 0;
+  const combinedScore = (orphanPercent + deadCodePercent) / 2;
   let score = 100;
-  if (orphanPercent === 0) {
+  if (combinedScore === 0) {
     score = 100;
-  } else if (orphanPercent <= 5) {
+  } else if (combinedScore <= 5) {
     score = 80;
-  } else if (orphanPercent <= 10) {
+  } else if (combinedScore <= 10) {
     score = 60;
-  } else if (orphanPercent <= 20) {
+  } else if (combinedScore <= 20) {
     score = 40;
   } else {
     score = 20;
   }
   return {
-    name: "Orphan Files",
+    name: "Orphans & Dead Code",
     score,
     weight: 0.1,
     grade: scoreToGrade(score),
-    details: orphanCount === 0 ? "No orphan files" : `${orphanCount} orphan file${orphanCount === 1 ? "" : "s"} (${orphanPercent.toFixed(0)}%)`,
-    metrics: { orphans: orphanCount, percentage: parseFloat(orphanPercent.toFixed(1)) }
+    details: `${orphanCount} orphan file${orphanCount === 1 ? "" : "s"} (${orphanPercent.toFixed(0)}%), ${deadSymbolCount} dead symbols (${deadCodePercent.toFixed(1)}%)`,
+    metrics: {
+      orphans: orphanCount,
+      orphanPercentage: parseFloat(orphanPercent.toFixed(1)),
+      deadSymbols: deadSymbolCount,
+      deadCodePercentage: parseFloat(deadCodePercent.toFixed(1))
+    }
   };
 }
 function calculateDepthScore(graph) {
@@ -3020,8 +3468,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync } from "fs";
-import { join as join9, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync, existsSync as existsSync7, mkdirSync } from "fs";
+import { join as join10, dirname as dirname8 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -3120,7 +3568,7 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
   const entry = {
     timestamp: report.timestamp,
     score: report.overall,
@@ -3132,9 +3580,9 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync6(historyFile)) {
+  if (existsSync7(historyFile)) {
     try {
-      const content = readFileSync4(historyFile, "utf-8");
+      const content = readFileSync5(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -3143,28 +3591,326 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname7(historyFile), { recursive: true });
+  mkdirSync(dirname8(historyFile), { recursive: true });
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
-  if (!existsSync6(historyFile)) {
+  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
+  if (!existsSync7(historyFile)) {
     return [];
   }
   try {
-    const content = readFileSync4(historyFile, "utf-8");
+    const content = readFileSync5(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
   }
 }
 
+// src/dead-code/detector.ts
+import path2 from "path";
+function findDeadSymbols(graph, projectRoot, includeTests = false) {
+  const deadSymbols = [];
+  const context = { graph, projectRoot };
+  for (const node of graph.nodes()) {
+    const attrs = graph.getNodeAttributes(node);
+    if (!attrs.file || !attrs.name) continue;
+    const inDegree = graph.inDegree(node);
+    if (inDegree === 0) {
+      if (shouldExclude(attrs, context, includeTests)) {
+        continue;
+      }
+      deadSymbols.push({
+        name: attrs.name,
+        kind: attrs.kind || "unknown",
+        file: attrs.file,
+        line: attrs.startLine || 0,
+        exported: attrs.exported || false,
+        dependents: 0,
+        confidence: "high",
+        reason: "Zero dependents"
+      });
+    }
+  }
+  return deadSymbols;
+}
+function shouldExclude(attrs, context, includeTests) {
+  const filePath = attrs.file;
+  const relativePath = path2.relative(context.projectRoot, filePath);
+  if (!includeTests && isTestFile(relativePath)) {
+    return true;
+  }
+  if (isEntryPoint(relativePath)) {
+    return true;
+  }
+  if (isConfigFile(relativePath)) {
+    return true;
+  }
+  if (isTypeDeclarationFile(relativePath)) {
+    return true;
+  }
+  if (attrs.kind === "default") {
+    return true;
+  }
+  if (isFrameworkAutoLoadedFile(relativePath)) {
+    return true;
+  }
+  return false;
+}
+function isTestFile(filePath) {
+  return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
+}
+function isEntryPoint(filePath) {
+  const basename6 = path2.basename(filePath);
+  return basename6 === "index.ts" || basename6 === "index.js" || basename6 === "main.ts" || basename6 === "main.js" || basename6 === "app.ts" || basename6 === "app.js" || basename6 === "server.ts" || basename6 === "server.js";
+}
+function isConfigFile(filePath) {
+  return filePath.includes(".config.") || filePath.includes("config/") || filePath.includes("vite.config") || filePath.includes("rollup.config") || filePath.includes("webpack.config");
+}
+function isTypeDeclarationFile(filePath) {
+  return filePath.endsWith(".d.ts");
+}
+function isFrameworkAutoLoadedFile(filePath) {
+  return filePath.includes("/pages/") || filePath.includes("/routes/") || filePath.includes("/middleware/") || filePath.includes("/commands/") || filePath.includes("/api/") || filePath.includes("/app/");
+}
+
+// src/dead-code/classifier.ts
+import path3 from "path";
+function classifyDeadSymbols(symbols, graph) {
+  return symbols.map((symbol) => {
+    const confidence = calculateConfidence(symbol, graph);
+    const reason = generateReason(symbol, confidence);
+    return {
+      ...symbol,
+      confidence,
+      reason
+    };
+  });
+}
+function calculateConfidence(symbol, graph) {
+  if (!symbol.exported && symbol.dependents === 0) {
+    return "high";
+  }
+  if (symbol.exported && symbol.dependents === 0 && !isBarrelFile(symbol.file)) {
+    return "high";
+  }
+  if (symbol.exported && symbol.dependents === 0 && isBarrelFile(symbol.file)) {
+    return "medium";
+  }
+  const dependents = getSymbolDependents(symbol, graph);
+  if (dependents.length === 1 && isTestFile2(dependents[0])) {
+    return "medium";
+  }
+  if (symbol.exported && isPackageEntryPoint(symbol.file)) {
+    return "low";
+  }
+  if ((symbol.kind === "interface" || symbol.kind === "type") && symbol.dependents === 0) {
+    return "low";
+  }
+  if (isLikelyDynamicUsage(symbol)) {
+    return "low";
+  }
+  return "medium";
+}
+function generateReason(symbol, confidence) {
+  if (!symbol.exported && symbol.dependents === 0) {
+    return "Not exported, zero references";
+  }
+  if (symbol.exported && symbol.dependents === 0 && !isBarrelFile(symbol.file)) {
+    return "Exported, zero dependents";
+  }
+  if (symbol.exported && symbol.dependents === 0 && isBarrelFile(symbol.file)) {
+    return "Exported from barrel file, zero dependents (might be used externally)";
+  }
+  if (confidence === "medium") {
+    return "Low usage, might be dead";
+  }
+  if (confidence === "low") {
+    if (symbol.kind === "interface" || symbol.kind === "type") {
+      return "Type with zero dependents (might be used via import type)";
+    }
+    if (isPackageEntryPoint(symbol.file)) {
+      return "Exported from package entry point (might be public API)";
+    }
+    if (isLikelyDynamicUsage(symbol)) {
+      return "In dynamic-use pattern directory (might be auto-loaded)";
+    }
+  }
+  return "Potentially unused";
+}
+function isBarrelFile(filePath) {
+  const basename6 = path3.basename(filePath);
+  return basename6 === "index.ts" || basename6 === "index.js";
+}
+function isTestFile2(filePath) {
+  return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
+}
+function isPackageEntryPoint(filePath) {
+  return filePath.includes("/src/index.") || filePath.includes("/lib/index.") || filePath.endsWith("/index.ts") || filePath.endsWith("/index.js");
+}
+function isLikelyDynamicUsage(symbol) {
+  const filePath = symbol.file;
+  return filePath.includes("/routes/") || filePath.includes("/pages/") || filePath.includes("/middleware/") || filePath.includes("/commands/") || filePath.includes("/handlers/") || filePath.includes("/api/");
+}
+function getSymbolDependents(symbol, graph) {
+  const dependents = [];
+  for (const node of graph.nodes()) {
+    const attrs = graph.getNodeAttributes(node);
+    if (attrs.file === symbol.file && attrs.name === symbol.name) {
+      const inNeighbors = graph.inNeighbors(node);
+      for (const neighbor of inNeighbors) {
+        const neighborAttrs = graph.getNodeAttributes(neighbor);
+        if (neighborAttrs.file) {
+          dependents.push(neighborAttrs.file);
+        }
+      }
+      break;
+    }
+  }
+  return dependents;
+}
+
+// src/dead-code/display.ts
+import chalk from "chalk";
+import path4 from "path";
+function displayDeadCodeReport(report, options, projectRoot) {
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  console.log(chalk.cyan.bold("\n\u{1F50D} Dead Code Analysis\n"));
+  const { high, medium, low } = report.byConfidence;
+  console.log(
+    `Found ${chalk.yellow.bold(report.deadSymbols)} potentially dead symbols (${chalk.red(high)} high, ${chalk.yellow(medium)} medium, ${chalk.gray(low)} low confidence)
+`
+  );
+  const symbolsByConfidence = groupByConfidence(report.symbols);
+  if (symbolsByConfidence.high.length > 0) {
+    displayConfidenceGroup("HIGH", symbolsByConfidence.high, options.verbose, projectRoot);
+  }
+  if (symbolsByConfidence.medium.length > 0) {
+    displayConfidenceGroup("MEDIUM", symbolsByConfidence.medium, options.verbose, projectRoot);
+  }
+  if (symbolsByConfidence.low.length > 0) {
+    displayConfidenceGroup("LOW", symbolsByConfidence.low, options.verbose, projectRoot);
+  }
+  if (options.stats) {
+    displayStats(report);
+  }
+}
+function groupByConfidence(symbols) {
+  return symbols.reduce(
+    (acc, symbol) => {
+      acc[symbol.confidence].push(symbol);
+      return acc;
+    },
+    { high: [], medium: [], low: [] }
+  );
+}
+function displayConfidenceGroup(level, symbols, verbose, projectRoot) {
+  const emoji = level === "HIGH" ? "\u{1F534}" : level === "MEDIUM" ? "\u{1F7E1}" : "\u26AA";
+  const color = level === "HIGH" ? chalk.red : level === "MEDIUM" ? chalk.yellow : chalk.gray;
+  console.log(
+    color.bold(`
+${emoji} ${level} CONFIDENCE `) + chalk.gray(`(${level === "HIGH" ? "definitely" : level === "MEDIUM" ? "probably" : "might be"} dead)`)
+  );
+  const headers = ["Symbol", "Kind", "File", verbose ? "Reason" : ""];
+  const rows = symbols.map((symbol) => {
+    const relativePath = path4.relative(projectRoot, symbol.file);
+    return [
+      chalk.bold(symbol.name),
+      symbol.kind,
+      `${relativePath}:${symbol.line}`,
+      verbose ? symbol.reason : ""
+    ];
+  });
+  displayTable(headers, rows.filter((row) => row[3] !== ""));
+}
+function displayTable(headers, rows) {
+  if (rows.length === 0) return;
+  const columnWidths = headers.map((header2, i) => {
+    const maxRowWidth = Math.max(...rows.map((row) => stripAnsi(row[i]).length));
+    return Math.max(header2.length, maxRowWidth);
+  });
+  const separator = "\u250C" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2510";
+  const headerRow = "\u2502 " + headers.map((h, i) => h.padEnd(columnWidths[i])).join(" \u2502 ") + " \u2502";
+  const divider = "\u251C" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524";
+  const footer = "\u2514" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518";
+  console.log(separator);
+  console.log(headerRow);
+  console.log(divider);
+  for (const row of rows) {
+    const formattedRow = "\u2502 " + row.map((cell, i) => {
+      const stripped = stripAnsi(cell);
+      const padding = columnWidths[i] - stripped.length;
+      return cell + " ".repeat(padding);
+    }).join(" \u2502 ") + " \u2502";
+    console.log(formattedRow);
+  }
+  console.log(footer);
+}
+function displayStats(report) {
+  console.log(chalk.cyan.bold("\n\u{1F4CA} Summary\n"));
+  console.log(`  Total symbols analyzed: ${chalk.bold(report.totalSymbols.toLocaleString())}`);
+  console.log(`  Potentially dead: ${chalk.yellow.bold(report.deadSymbols)} (${report.deadPercentage.toFixed(1)}%)`);
+  console.log(
+    `  By confidence: ${chalk.red(report.byConfidence.high)} high, ${chalk.yellow(report.byConfidence.medium)} medium, ${chalk.gray(report.byConfidence.low)} low`
+  );
+  const estimatedLines = report.deadSymbols * 18;
+  console.log(`  Estimated dead code: ${chalk.gray(`~${estimatedLines.toLocaleString()} lines`)}
+`);
+}
+function stripAnsi(str) {
+  return str.replace(
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    ""
+  );
+}
+
+// src/dead-code/index.ts
+function analyzeDeadCode(graph, projectRoot, options = {}) {
+  const opts = {
+    confidence: options.confidence || "medium",
+    includeTests: options.includeTests || false,
+    verbose: options.verbose || false,
+    stats: options.stats || false,
+    json: options.json || false
+  };
+  const rawDeadSymbols = findDeadSymbols(graph, projectRoot, opts.includeTests);
+  const classifiedSymbols = classifyDeadSymbols(rawDeadSymbols, graph);
+  const filteredSymbols = filterByConfidence(classifiedSymbols, opts.confidence);
+  const totalSymbols = graph.order;
+  const byConfidence = {
+    high: classifiedSymbols.filter((s) => s.confidence === "high").length,
+    medium: classifiedSymbols.filter((s) => s.confidence === "medium").length,
+    low: classifiedSymbols.filter((s) => s.confidence === "low").length
+  };
+  const report = {
+    totalSymbols,
+    deadSymbols: filteredSymbols.length,
+    deadPercentage: filteredSymbols.length / totalSymbols * 100,
+    byConfidence,
+    symbols: filteredSymbols
+  };
+  if (!opts.json) {
+    displayDeadCodeReport(report, opts, projectRoot);
+  }
+  return report;
+}
+function filterByConfidence(symbols, minConfidence) {
+  const confidenceLevels = { high: 3, medium: 2, low: 1 };
+  const minLevel = confidenceLevels[minConfidence];
+  return symbols.filter(
+    (s) => confidenceLevels[s.confidence] >= minLevel
+  );
+}
+
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -3315,7 +4061,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -3340,7 +4086,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -3355,8 +4101,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname8(sourceAttrs.filePath);
-    const targetDir = dirname8(targetAttrs.filePath);
+    const sourceDir = dirname9(sourceAttrs.filePath);
+    const targetDir = dirname9(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4208,20 +4954,20 @@ function findLongestPaths(graph, limit) {
   }
   const allPaths = [];
   const visited = /* @__PURE__ */ new Set();
-  function dfs(file, path2) {
+  function dfs(file, path6) {
     visited.add(file);
-    path2.push(file);
+    path6.push(file);
     const neighbors = fileGraph.get(file);
     if (!neighbors || neighbors.size === 0) {
-      allPaths.push([...path2]);
+      allPaths.push([...path6]);
     } else {
       for (const neighbor of neighbors) {
         if (!visited.has(neighbor)) {
-          dfs(neighbor, path2);
+          dfs(neighbor, path6);
         }
       }
     }
-    path2.pop();
+    path6.pop();
     visited.delete(file);
   }
   for (const root of roots.slice(0, 10)) {
@@ -4337,7 +5083,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4396,7 +5142,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -4500,7 +5246,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -4515,7 +5261,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4530,8 +5276,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname9(sourceAttrs.filePath);
-    const targetDir = dirname9(targetAttrs.filePath);
+    const sourceDir = dirname10(sourceAttrs.filePath);
+    const targetDir = dirname10(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4612,7 +5358,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4666,8 +5412,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname9(files[0]);
-  if (files.every((f) => dirname9(f) === commonDir)) {
+  const commonDir = dirname10(files[0]);
+  if (files.every((f) => dirname10(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -4725,7 +5471,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname10, basename as basename3 } from "path";
+import { dirname as dirname11, basename as basename3 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4829,7 +5575,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname10(file.filePath);
+    const dir = dirname11(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -5472,7 +6218,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname11 } from "path";
+import { basename as basename4, dirname as dirname12 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5499,9 +6245,9 @@ function getFileCount8(graph) {
   });
   return files.size;
 }
-function isTestFile(filePath) {
+function isTestFile3(filePath) {
   const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname11(filePath).toLowerCase();
+  const dirPath = dirname12(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -5513,7 +6259,7 @@ function isTestFile(filePath) {
 function getTestFiles(graph) {
   const testFiles = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    if (isTestFile(attrs.filePath)) {
+    if (isTestFile3(attrs.filePath)) {
       if (!testFiles.has(attrs.filePath)) {
         testFiles.set(attrs.filePath, {
           filePath: attrs.filePath,
@@ -5560,21 +6306,21 @@ function generateTestFileInventory(graph) {
 }
 function matchTestToSource(testFile) {
   const testFileName = basename4(testFile);
-  const testDir = dirname11(testFile);
+  const testDir = dirname12(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname11(testDir);
+    const parentDir = dirname12(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
     const srcDir = testDir.replace(/test[s]?/g, "src");
     possiblePaths.push(srcDir + "/" + sourceFileName);
   }
-  for (const path2 of possiblePaths) {
-    if (!isTestFile(path2)) {
-      return path2;
+  for (const path6 of possiblePaths) {
+    if (!isTestFile3(path6)) {
+      return path6;
     }
   }
   return null;
@@ -5629,7 +6375,7 @@ function generateUntestedFiles(graph) {
     allFiles.add(attrs.filePath);
   });
   for (const file of allFiles) {
-    if (!isTestFile(file)) {
+    if (!isTestFile3(file)) {
       sourceFiles.push(file);
     }
   }
@@ -5688,7 +6434,7 @@ function generateTestCoverageMap(graph) {
     allFiles.add(attrs.filePath);
   });
   for (const file of allFiles) {
-    if (!isTestFile(file)) {
+    if (!isTestFile3(file)) {
       sourceFiles.push(file);
     }
   }
@@ -5740,7 +6486,7 @@ function generateTestStatistics(graph) {
     allFiles.add(attrs.filePath);
   });
   for (const file of allFiles) {
-    if (!isTestFile(file)) {
+    if (!isTestFile3(file)) {
       sourceFiles.push(file);
     }
   }
@@ -5762,7 +6508,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname11(sourceFile).split("/")[0];
+    const dir = dirname12(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -5785,7 +6531,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -6066,7 +6812,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname12(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6148,7 +6894,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6286,7 +7032,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname13(info.filePath);
+    const dir = dirname14(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -6497,8 +7243,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6531,12 +7277,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join10(projectRoot, filePath);
-  if (!existsSync7(fullPath)) {
+  const fullPath = join11(projectRoot, filePath);
+  if (!existsSync8(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync5(fullPath, "utf-8");
+    const content = readFileSync6(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -7005,16 +7751,108 @@ function generateDetailedMetrics(dimensions) {
   return output;
 }
 
+// src/docs/dead-code.ts
+import path5 from "path";
+function generateDeadCode(graph, projectRoot, projectName) {
+  const report = analyzeDeadCode(graph, projectRoot, {
+    confidence: "low",
+    includeTests: false,
+    verbose: true,
+    stats: true,
+    json: true
+  });
+  let output = "";
+  output += header(`${projectName} - Dead Code Analysis`, 1);
+  output += timestamp();
+  output += "\n";
+  output += header("Summary", 2);
+  output += `Total symbols analyzed: **${formatNumber(report.totalSymbols)}**
+
+`;
+  output += `Potentially dead symbols: **${formatNumber(report.deadSymbols)}** (${report.deadPercentage.toFixed(1)}%)
+
+`;
+  output += `- \u{1F534} High confidence (definitely dead): **${report.byConfidence.high}**
+`;
+  output += `- \u{1F7E1} Medium confidence (probably dead): **${report.byConfidence.medium}**
+`;
+  output += `- \u26AA Low confidence (might be dead): **${report.byConfidence.low}**
+
+`;
+  const estimatedLines = report.deadSymbols * 18;
+  output += `Estimated dead code: **~${formatNumber(estimatedLines)} lines**
+
+`;
+  const symbolsByConfidence = groupByConfidence2(report.symbols);
+  if (symbolsByConfidence.high.length > 0) {
+    output += generateConfidenceSection(
+      "High Confidence",
+      "definitely dead",
+      symbolsByConfidence.high,
+      projectRoot
+    );
+  }
+  if (symbolsByConfidence.medium.length > 0) {
+    output += generateConfidenceSection(
+      "Medium Confidence",
+      "probably dead",
+      symbolsByConfidence.medium,
+      projectRoot
+    );
+  }
+  if (symbolsByConfidence.low.length > 0) {
+    output += generateConfidenceSection(
+      "Low Confidence",
+      "might be dead",
+      symbolsByConfidence.low,
+      projectRoot
+    );
+  }
+  output += "\n---\n\n";
+  output += "_This document was auto-generated by Depwire. It reflects the current state of the codebase and should be reviewed before taking action._\n";
+  return output;
+}
+function groupByConfidence2(symbols) {
+  return symbols.reduce(
+    (acc, symbol) => {
+      acc[symbol.confidence].push(symbol);
+      return acc;
+    },
+    { high: [], medium: [], low: [] }
+  );
+}
+function generateConfidenceSection(title, description, symbols, projectRoot) {
+  let output = "";
+  output += header(`${title} (${description})`, 2);
+  output += `Found **${symbols.length}** symbol${symbols.length === 1 ? "" : "s"}.
+
+`;
+  const headers = ["Symbol", "Kind", "File", "Exported", "Reason"];
+  const rows = symbols.map((s) => {
+    const relativePath = path5.relative(projectRoot, s.file);
+    return [
+      code(s.name),
+      s.kind,
+      `${relativePath}:${s.line}`,
+      s.exported ? "Yes" : "No",
+      s.reason
+    ];
+  });
+  output += table(headers, rows);
+  output += "\n";
+  return output;
+}
+
 // src/docs/metadata.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join12 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join11(outputDir, "metadata.json");
-  if (!existsSync8(metadataPath)) {
+  const metadataPath = join12(outputDir, "metadata.json");
+  if (!existsSync9(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync6(metadataPath, "utf-8");
+    const content = readFileSync7(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -7022,7 +7860,7 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join11(outputDir, "metadata.json");
+  const metadataPath = join12(outputDir, "metadata.json");
   writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function createMetadata(version, projectPath, fileCount, symbolCount, edgeCount, docTypes) {
@@ -7065,7 +7903,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync9(options.outputDir)) {
+    if (!existsSync10(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -7088,7 +7926,8 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         "history",
         "current",
         "status",
-        "health"
+        "health",
+        "dead_code"
       ];
     }
     let metadata = null;
@@ -7103,7 +7942,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ARCHITECTURE.md...");
           const content = generateArchitecture(graph, projectRoot, version, parseTime);
-          const filePath = join12(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join13(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -7114,7 +7953,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CONVENTIONS.md...");
           const content = generateConventions(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "CONVENTIONS.md");
+          const filePath = join13(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -7125,7 +7964,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEPENDENCIES.md...");
           const content = generateDependencies(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join13(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -7136,7 +7975,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ONBOARDING.md...");
           const content = generateOnboarding(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "ONBOARDING.md");
+          const filePath = join13(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -7147,7 +7986,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating FILES.md...");
           const content = generateFiles(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "FILES.md");
+          const filePath = join13(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -7158,7 +7997,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating API_SURFACE.md...");
           const content = generateApiSurface(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "API_SURFACE.md");
+          const filePath = join13(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -7169,7 +8008,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ERRORS.md...");
           const content = generateErrors(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "ERRORS.md");
+          const filePath = join13(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -7180,7 +8019,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating TESTS.md...");
           const content = generateTests(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "TESTS.md");
+          const filePath = join13(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -7191,7 +8030,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HISTORY.md...");
           const content = generateHistory(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "HISTORY.md");
+          const filePath = join13(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -7202,7 +8041,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CURRENT.md...");
           const content = generateCurrent(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "CURRENT.md");
+          const filePath = join13(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -7213,7 +8052,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating STATUS.md...");
           const content = generateStatus(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "STATUS.md");
+          const filePath = join13(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -7224,13 +8063,24 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HEALTH.md...");
           const content = generateHealth(graph, projectRoot, version);
-          const filePath = join12(options.outputDir, "HEALTH.md");
+          const filePath = join13(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
           errors.push(`Failed to generate HEALTH.md: ${err}`);
         }
       }
+      if (docsToGenerate.includes("dead_code")) {
+        try {
+          if (options.verbose) console.log("Generating DEAD_CODE.md...");
+          const content = generateDeadCode(graph, projectRoot, version);
+          const filePath = join13(options.outputDir, "DEAD_CODE.md");
+          writeFileSync3(filePath, content, "utf-8");
+          generated.push("DEAD_CODE.md");
+        } catch (err) {
+          errors.push(`Failed to generate DEAD_CODE.md: ${err}`);
+        }
+      }
     } else if (options.format === "json") {
       errors.push("JSON format not yet supported");
     }
@@ -7272,13 +8122,13 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import { dirname as dirname14, join as join15 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname15, join as join16 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
 
 // src/mcp/connect.ts
 import simpleGit from "simple-git";
-import { existsSync as existsSync10 } from "fs";
-import { join as join13, basename as basename5, resolve as resolve2 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join14, basename as basename5, resolve as resolve2 } from "path";
 import { tmpdir, homedir } from "os";
 function validateProjectPath(source) {
   const resolved = resolve2(source);
@@ -7291,11 +8141,11 @@ function validateProjectPath(source) {
     "/boot",
     "/proc",
     "/sys",
-    join13(homedir(), ".ssh"),
-    join13(homedir(), ".gnupg"),
-    join13(homedir(), ".aws"),
-    join13(homedir(), ".config"),
-    join13(homedir(), ".env")
+    join14(homedir(), ".ssh"),
+    join14(homedir(), ".gnupg"),
+    join14(homedir(), ".aws"),
+    join14(homedir(), ".config"),
+    join14(homedir(), ".env")
   ];
   for (const blocked of blockedPaths) {
     if (resolved.startsWith(blocked)) {
@@ -7318,11 +8168,11 @@ async function connectToRepo(source, subdirectory, state) {
         };
       }
       projectName = match[1];
-      const reposDir = join13(tmpdir(), "depwire-repos");
-      const cloneDir = join13(reposDir, projectName);
+      const reposDir = join14(tmpdir(), "depwire-repos");
+      const cloneDir = join14(reposDir, projectName);
       console.error(`Connecting to GitHub repo: ${source}`);
       const git = simpleGit();
-      if (existsSync10(cloneDir)) {
+      if (existsSync11(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -7340,7 +8190,7 @@ async function connectToRepo(source, subdirectory, state) {
           };
         }
       }
-      projectRoot = subdirectory ? join13(cloneDir, subdirectory) : cloneDir;
+      projectRoot = subdirectory ? join14(cloneDir, subdirectory) : cloneDir;
     } else {
       const validation2 = validateProjectPath(source);
       if (!validation2.valid) {
@@ -7349,13 +8199,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync10(source)) {
+      if (!existsSync11(source)) {
         return {
           error: "Directory not found",
           message: `Directory does not exist: ${source}`
         };
       }
-      projectRoot = subdirectory ? join13(source, subdirectory) : source;
+      projectRoot = subdirectory ? join14(source, subdirectory) : source;
       projectName = basename5(projectRoot);
     }
     const validation = validateProjectPath(projectRoot);
@@ -7365,7 +8215,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync10(projectRoot)) {
+    if (!existsSync11(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -7646,24 +8496,24 @@ function getWeekNumber(date) {
 }
 
 // src/temporal/snapshots.ts
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync3, existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
-import { join as join14 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync8, mkdirSync as mkdirSync3, existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join15 } from "path";
 function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync11(outputDir)) {
+  if (!existsSync12(outputDir)) {
     mkdirSync3(outputDir, { recursive: true });
   }
   const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
-  const filepath = join14(outputDir, filename);
+  const filepath = join15(outputDir, filename);
   writeFileSync4(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
 }
 function loadSnapshot(commitHash, outputDir) {
   const shortHash = commitHash.substring(0, 8);
-  const filepath = join14(outputDir, `${shortHash}.json`);
-  if (!existsSync11(filepath)) {
+  const filepath = join15(outputDir, `${shortHash}.json`);
+  if (!existsSync12(filepath)) {
     return null;
   }
   try {
-    const content = readFileSync7(filepath, "utf-8");
+    const content = readFileSync8(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -7689,8 +8539,8 @@ function createSnapshot(graph, commitHash, commitDate, commitMessage, commitAuth
       }
     }
   }
-  const files = Array.from(fileMap.entries()).map(([path2, data]) => ({
-    path: path2,
+  const files = Array.from(fileMap.entries()).map(([path6, data]) => ({
+    path: path6,
     symbols: data.symbols,
     connections: data.inbound + data.outbound
   }));
@@ -7927,6 +8777,21 @@ function getToolsList() {
           }
         }
       }
+    },
+    {
+      name: "find_dead_code",
+      description: "Find potentially dead code \u2014 symbols that are defined but never referenced anywhere in the codebase. Returns symbols categorized by confidence level (high, medium, low). High confidence means definitely unused. Use this to identify cleanup opportunities.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          confidence: {
+            type: "string",
+            enum: ["high", "medium", "low"],
+            description: "Minimum confidence level to return (default: medium)",
+            default: "medium"
+          }
+        }
+      }
     }
   ];
 }
@@ -7989,6 +8854,15 @@ async function handleToolCall(name, args, state) {
       } else {
         result = await handleGetTemporalGraph(state, args.commits || 10, args.strategy || "even");
       }
+    } else if (name === "find_dead_code") {
+      if (!isProjectLoaded(state)) {
+        result = {
+          error: "No project loaded",
+          message: "Use connect_repo to connect to a codebase first"
+        };
+      } else {
+        result = handleFindDeadCode(state, args.confidence || "medium");
+      }
     } else {
       if (!isProjectLoaded(state)) {
         result = {
@@ -8326,7 +9200,7 @@ function handleGetArchitectureSummary(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   const languageBreakdown = {};
   fileSummary.forEach((f) => {
-    const dir = f.filePath.includes("/") ? dirname14(f.filePath) : ".";
+    const dir = f.filePath.includes("/") ? dirname15(f.filePath) : ".";
     if (!dirMap.has(dir)) {
       dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
     }
@@ -8413,8 +9287,8 @@ The server will keep running until you end the MCP session or press Ctrl+C.`;
   };
 }
 async function handleGetProjectDocs(docType, state) {
-  const docsDir = join15(state.projectRoot, ".depwire");
-  if (!existsSync12(docsDir)) {
+  const docsDir = join16(state.projectRoot, ".depwire");
+  if (!existsSync13(docsDir)) {
     const errorMessage = `Project documentation has not been generated yet.
 
 Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
@@ -8444,12 +9318,12 @@ Available document types:
       missing.push(doc);
       continue;
     }
-    const filePath = join15(docsDir, metadata.documents[doc].file);
-    if (!existsSync12(filePath)) {
+    const filePath = join16(docsDir, metadata.documents[doc].file);
+    if (!existsSync13(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -8474,16 +9348,16 @@ Available document types:
 }
 async function handleUpdateProjectDocs(docType, state) {
   const startTime = Date.now();
-  const docsDir = join15(state.projectRoot, ".depwire");
+  const docsDir = join16(state.projectRoot, ".depwire");
   console.error("Regenerating project documentation...");
   const parsedFiles = await parseProject(state.projectRoot);
   const graph = buildGraph(parsedFiles);
   const parseTime = (Date.now() - startTime) / 1e3;
   state.graph = graph;
-  const packageJsonPath = join15(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+  const packageJsonPath = join16(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
   const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync12(docsDir);
+  const docsExist = existsSync13(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -8542,7 +9416,7 @@ async function handleGetTemporalGraph(state, commits, strategy) {
     }
     const sampledCommits = sampleCommits(allCommits, commits, strategy);
     const snapshots = [];
-    const outputDir = join15(projectRoot, ".depwire", "temporal");
+    const outputDir = join16(projectRoot, ".depwire", "temporal");
     for (const commit of sampledCommits) {
       const existing = loadSnapshot(commit.hash, outputDir);
       if (existing) {
@@ -8604,6 +9478,46 @@ async function handleGetTemporalGraph(state, commits, strategy) {
     };
   }
 }
+function handleFindDeadCode(state, confidence) {
+  if (!state.graph || !state.projectRoot) {
+    return {
+      error: "No project loaded",
+      message: "Use connect_repo to connect to a codebase first"
+    };
+  }
+  try {
+    const report = analyzeDeadCode(state.graph, state.projectRoot, {
+      confidence,
+      includeTests: false,
+      verbose: false,
+      stats: false,
+      json: true
+    });
+    return {
+      status: "success",
+      totalSymbols: report.totalSymbols,
+      deadSymbols: report.deadSymbols,
+      deadPercentage: report.deadPercentage,
+      byConfidence: report.byConfidence,
+      symbols: report.symbols.map((s) => ({
+        name: s.name,
+        kind: s.kind,
+        file: s.file,
+        line: s.line,
+        exported: s.exported,
+        dependents: s.dependents,
+        confidence: s.confidence,
+        reason: s.reason
+      })),
+      summary: `Found ${report.deadSymbols} potentially dead symbols (${report.byConfidence.high} high, ${report.byConfidence.medium} medium, ${report.byConfidence.low} low confidence) out of ${report.totalSymbols} total symbols (${report.deadPercentage.toFixed(1)}% dead code).`
+    };
+  } catch (error) {
+    return {
+      error: "Failed to analyze dead code",
+      message: String(error)
+    };
+  }
+}
 
 // src/mcp/server.ts
 async function startMcpServer(state) {
@@ -8652,6 +9566,7 @@ export {
   updateFileInGraph,
   calculateHealthScore,
   getHealthTrend,
+  analyzeDeadCode,
   generateDocs,
   getCommitLog,
   getCurrentBranch,