opencode-swarm 7.85.0 → 7.86.0

package/dist/cli/{guardrail-explain-w4txg349.js → guardrail-explain-rtd1x26f.js}

@@ -1,8 +1,8 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-x7qck34v.js";
-import"./index-yhqt45de.js";
+} from "./index-7r2b453y.js";
+import"./index-5q66xc88.js";
 import"./index-vq2321gg.js";
 import"./index-yhsmmv2z.js";
 import"./index-d9fbxaqd.js";

package/dist/cli/{index-yhqt45de.js → index-5q66xc88.js}

@@ -879,7 +879,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.85.0",
+  version: "7.86.0",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -27978,7 +27978,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-qqabjns2.js");
+    const { buildHelpText } = await import("./index-jwz50183.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -27987,7 +27987,7 @@ async function handleHelpCommand(ctx) {
     return _internals41.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals41.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-qqabjns2.js");
+  const { buildHelpText: fullHelp } = await import("./index-jwz50183.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -28120,7 +28120,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-w4txg349.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-rtd1x26f.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",

package/dist/cli/{index-x7qck34v.js → index-7r2b453y.js}

@@ -12,7 +12,7 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-yhqt45de.js";
+} from "./index-5q66xc88.js";
 import {
   checkFileAuthority,
   classifyFile,

package/dist/cli/{index-qqabjns2.js → index-jwz50183.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-x7qck34v.js";
+} from "./index-7r2b453y.js";
 import {
   handleGuardrailLog
 } from "./index-5cb86007.js";
@@ -76,7 +76,7 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-yhqt45de.js";
+} from "./index-5q66xc88.js";
 import"./index-vq2321gg.js";
 import"./index-yhsmmv2z.js";
 import"./index-d9fbxaqd.js";

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   getPluginLockFilePaths,
   package_default,
   resolveCommand
-} from "./index-yhqt45de.js";
+} from "./index-5q66xc88.js";
 import"./index-vq2321gg.js";
 import"./index-yhsmmv2z.js";
 import"./index-d9fbxaqd.js";

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.85.0",
+    version: "7.86.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -45068,7 +45068,7 @@ function recordSessionStart(directory, startMs) {
     const filePath = path32.join(sessionDir, SESSION_START_FILE);
     const line = JSON.stringify({ startMs, ts: Date.now() });
     mkdirSync11(sessionDir, { recursive: true });
-    writeFileSync6(filePath, line + `
+    writeFileSync6(filePath, `${line}
 `, { flag: "a" });
   } catch {}
 }
@@ -113317,7 +113317,25 @@ function safeRealpathSync(targetPath, fallback, realpathResolver = realpathSync1
 // src/tools/repo-graph/types.ts
 import * as path117 from "node:path";
 var REPO_GRAPH_FILENAME = "repo-graph.json";
-var GRAPH_SCHEMA_VERSION = "1.0.0";
+var GRAPH_SCHEMA_VERSION = "1.1.0";
+function isSchemaVersionAtLeast(version5, minimum) {
+  const parse10 = (v) => v.split(".").map((part) => {
+    const n = Number.parseInt(part, 10);
+    return Number.isFinite(n) ? n : 0;
+  });
+  const a = parse10(version5 ?? "");
+  const b = parse10(minimum);
+  const len = Math.max(a.length, b.length);
+  for (let i2 = 0;i2 < len; i2++) {
+    const av = a[i2] ?? 0;
+    const bv = b[i2] ?? 0;
+    if (av > bv)
+      return true;
+    if (av < bv)
+      return false;
+  }
+  return true;
+}
 var FILE_ROLE_VALUES = [
   "api_route",
   "middleware",
@@ -113492,6 +113510,19 @@ function validateGraphNode(node) {
       throw new Error(`Invalid node: imports contains control characters (file=${node.filePath}, value="${preview}")`);
     }
   }
+  if (node.exportLines !== undefined) {
+    if (typeof node.exportLines !== "object" || node.exportLines === null || Array.isArray(node.exportLines)) {
+      throw new Error("Invalid node: exportLines must be an object");
+    }
+    for (const [name2, line] of Object.entries(node.exportLines)) {
+      if (containsControlChars(name2)) {
+        throw new Error("Invalid node: exportLines key contains control characters");
+      }
+      if (typeof line !== "number" || !Number.isFinite(line) || line < 0) {
+        throw new Error("Invalid node: exportLines values must be non-negative numbers");
+      }
+    }
+  }
   if (node.ontology !== undefined) {
     validateOntologyStrings(node);
   }
@@ -113609,6 +113640,19 @@ function validateGraphEdge(edge) {
       }
     }
   }
+  if (edge.usedSymbols !== undefined) {
+    if (!Array.isArray(edge.usedSymbols)) {
+      throw new Error("Invalid edge: usedSymbols must be an array");
+    }
+    for (const symbol3 of edge.usedSymbols) {
+      if (typeof symbol3 !== "string") {
+        throw new Error("Invalid edge: usedSymbols must be an array of strings");
+      }
+      if (containsControlChars(symbol3)) {
+        throw new Error("Invalid edge: usedSymbols contains control characters");
+      }
+    }
+  }
 }
 
 // src/tools/repo-graph/builder.ts
@@ -113617,7 +113661,9 @@ var _internals74 = {
   extractTSSymbols,
   extractPythonSymbols,
   parseFileImports,
-  extractFileOntology
+  extractFileOntology,
+  stripComments: stripComments2,
+  computeUsedSymbols
 };
 var SKIP_DIRECTORIES3 = new Set([
   "node_modules",
@@ -113914,11 +113960,89 @@ function parseFileImports(rawContent) {
     imports.push({
       specifier: modulePath,
       importType,
-      importedSymbols: parseImportedSymbols(matchedString, importType)
+      importedSymbols: parseImportedSymbols(matchedString, importType),
+      bindings: parseImportBindings(matchedString, importType),
+      reExport: /^\s*export\b/.test(matchedString)
     });
   }
   return imports;
 }
+function parseImportBindings(matchedString, importType) {
+  if (importType === "namespace")
+    return [];
+  if (importType === "default") {
+    const defaultMatch = matchedString.match(/^import\s+(\w+)\s+from\s+['"`]/);
+    return defaultMatch ? [{ imported: "default", local: defaultMatch[1] }] : [];
+  }
+  if (importType !== "named")
+    return [];
+  const braceMatch = matchedString.match(/\{\s*([\s\S]*?)\s*\}/);
+  if (!braceMatch)
+    return [];
+  const bindings = [];
+  const seen = new Set;
+  for (const rawPart of braceMatch[1].split(",")) {
+    const part = rawPart.trim().replace(/^type\s+/, "");
+    if (!part)
+      continue;
+    const aliasSplit = part.split(/\s+as\s+/i);
+    const imported = aliasSplit[0].trim();
+    const local = (aliasSplit[1] ?? aliasSplit[0]).trim();
+    if (!/^[A-Za-z_$][\w$]*$/.test(imported))
+      continue;
+    if (!/^[A-Za-z_$][\w$]*$/.test(local))
+      continue;
+    if (seen.has(imported))
+      continue;
+    seen.add(imported);
+    bindings.push({ imported, local });
+  }
+  return bindings;
+}
+var SAFE_USAGE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function computeUsedSymbols(strippedContent, bindings) {
+  if (bindings.length === 0)
+    return [];
+  const used = new Set;
+  for (const binding of bindings) {
+    if (!SAFE_USAGE_IDENTIFIER.test(binding.local)) {
+      used.add(binding.imported);
+      continue;
+    }
+    const re = new RegExp(`\\b${binding.local}\\b`, "g");
+    let count = 0;
+    for (const _match of strippedContent.matchAll(re)) {
+      count++;
+      if (count > 1)
+        break;
+    }
+    if (count > 1)
+      used.add(binding.imported);
+  }
+  return [...used].sort((a, b) => a.localeCompare(b));
+}
+function usedSymbolsForImport(parsed, strippedContent) {
+  if (parsed.importType === "namespace" || parsed.importType === "sideeffect" || parsed.importType === "require") {
+    return;
+  }
+  if (parsed.reExport) {
+    return [...new Set(parsed.bindings.map((b) => b.imported))].sort((a, b) => a.localeCompare(b));
+  }
+  return computeUsedSymbols(strippedContent, parsed.bindings);
+}
+function collectExports(symbols2) {
+  const exported = symbols2.filter((s) => s.exported);
+  const exports = exported.map((s) => s.signature === `default ${s.name}` ? "default" : s.name);
+  const exportLines = {};
+  for (let i2 = 0;i2 < exported.length; i2++) {
+    const s = exported[i2];
+    const name2 = exports[i2];
+    if (typeof s.line === "number" && Number.isFinite(s.line) && exportLines[name2] === undefined) {
+      exportLines[name2] = s.line;
+    }
+  }
+  return { exports, exportLines };
+}
 function parseImportedSymbols(matchedString, importType) {
   if (importType === "namespace")
     return ["*"];
@@ -114062,22 +114186,23 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   }
   const ext = path118.extname(filePath).toLowerCase();
   let exports = [];
+  let exportLines = {};
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
       const relativePath = path118.relative(absoluteRoot, filePath);
-      const symbols2 = _internals74.extractTSSymbols(relativePath, absoluteRoot);
-      exports = symbols2.filter((s) => s.exported).map((s) => s.name);
+      ({ exports, exportLines } = collectExports(_internals74.extractTSSymbols(relativePath, absoluteRoot)));
     } else if (ext === ".py") {
       const relativePath = path118.relative(absoluteRoot, filePath);
-      const symbols2 = _internals74.extractPythonSymbols(relativePath, absoluteRoot);
-      exports = symbols2.filter((s) => s.exported).map((s) => s.name);
+      ({ exports, exportLines } = collectExports(_internals74.extractPythonSymbols(relativePath, absoluteRoot)));
     }
     const parsedImports = _internals74.parseFileImports(content);
+    const strippedForUsage = parsedImports.length > 0 ? _internals74.stripComments(content) : "";
     const moduleName = toModuleName(filePath, absoluteRoot);
     const node = {
       filePath,
       moduleName,
       exports,
+      ...Object.keys(exportLines).length > 0 ? { exportLines } : {},
       imports: parsedImports.map((p) => p.specifier),
       language: getLanguage(filePath),
       mtime: fileStats.mtime.toISOString(),
@@ -114095,12 +114220,14 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
     for (const parsed of sortedImports) {
       const resolvedTarget = resolveModuleSpecifier(absoluteRoot, filePath, parsed.specifier);
       if (resolvedTarget !== null) {
+        const usedSymbols = usedSymbolsForImport(parsed, strippedForUsage);
         edges.push({
           source: filePath,
           target: resolvedTarget,
           importSpecifier: parsed.specifier,
           importType: parsed.importType,
-          importedSymbols: parsed.importedSymbols
+          importedSymbols: parsed.importedSymbols,
+          ...usedSymbols !== undefined ? { usedSymbols } : {}
         });
       }
     }
@@ -114356,6 +114483,113 @@ function getSymbolConsumers(graph, filePath, symbolName) {
   refs.sort((a, b) => a.file.localeCompare(b.file));
   return refs;
 }
+function getCallers(graph, filePath, symbolName) {
+  const node = getGraphNode(graph, filePath);
+  if (!node)
+    return [];
+  const targetKey = normalizeGraphPath(node.filePath);
+  const refs = [];
+  const seen = new Set;
+  for (const edge of graph.edges) {
+    if (normalizeGraphPath(edge.target) !== targetKey)
+      continue;
+    const file3 = moduleNameForEdgePath(graph, edge.source);
+    if (seen.has(file3))
+      continue;
+    if (edge.usedSymbols !== undefined) {
+      if (edge.usedSymbols.includes(symbolName)) {
+        seen.add(file3);
+        refs.push({ file: file3, resolution: "used" });
+      }
+      continue;
+    }
+    const imported = edge.importedSymbols ?? [];
+    if (edge.importType === "namespace" || imported.includes(symbolName)) {
+      seen.add(file3);
+      refs.push({ file: file3, resolution: "imported" });
+    }
+  }
+  refs.sort((a, b) => a.file.localeCompare(b.file));
+  return refs;
+}
+var DEAD_EXPORT_EXCLUDED_ROLES = new Set([
+  "api_route",
+  "cli_command",
+  "test_file",
+  "agent",
+  "hook",
+  "middleware"
+]);
+function getDeadExports(graph, options) {
+  if (!isSchemaVersionAtLeast(graph.schema_version, "1.1.0")) {
+    return {
+      schemaSupported: false,
+      analyzedFiles: 0,
+      skippedUnresolvable: 0,
+      candidates: [],
+      note: 'Graph predates schema 1.1.0 (no usedSymbols data). Run repo_map action="build" to enable dead_exports.'
+    };
+  }
+  const usage = new Map;
+  for (const edge of graph.edges) {
+    const target = normalizeGraphPath(edge.target);
+    let entry = usage.get(target);
+    if (!entry) {
+      entry = { used: new Set, unresolvable: false };
+      usage.set(target, entry);
+    }
+    if (edge.importType === "namespace" || edge.importType === "sideeffect" || edge.importType === "require") {
+      entry.unresolvable = true;
+    } else if (edge.usedSymbols) {
+      for (const symbol3 of edge.usedSymbols)
+        entry.used.add(symbol3);
+    }
+  }
+  const reverse = getReverseIndex(graph);
+  const candidates = [];
+  let analyzedFiles = 0;
+  let skippedUnresolvable = 0;
+  for (const node of Object.values(graph.nodes)) {
+    if (node.exports.length === 0)
+      continue;
+    const key = normalizeGraphPath(node.filePath);
+    const importerCount = reverse.get(key)?.length ?? 0;
+    if (importerCount === 0)
+      continue;
+    const roles = node.ontology?.roles ?? [];
+    if (roles.some((r) => DEAD_EXPORT_EXCLUDED_ROLES.has(r)))
+      continue;
+    const entry = usage.get(key);
+    if (entry?.unresolvable) {
+      skippedUnresolvable++;
+      continue;
+    }
+    analyzedFiles++;
+    const used = entry?.used ?? new Set;
+    for (const symbol3 of node.exports) {
+      if (symbol3 === "default")
+        continue;
+      if (used.has(symbol3))
+        continue;
+      candidates.push({
+        file: node.moduleName,
+        symbol: symbol3,
+        line: node.exportLines?.[symbol3],
+        importerCount
+      });
+    }
+  }
+  candidates.sort((a, b) => a.file.localeCompare(b.file) || a.symbol.localeCompare(b.symbol));
+  const limit = options?.maxCandidates ?? 100;
+  const truncated = candidates.length > limit;
+  return {
+    schemaSupported: true,
+    analyzedFiles,
+    skippedUnresolvable,
+    candidates: candidates.slice(0, limit),
+    note: "Advisory: exported symbols with no detected in-repo reference, limited to files imported by >=1 other file. " + "Regex analysis cannot see dynamic dispatch, string-keyed access, or namespace/barrel re-export usage; verify before removing." + (truncated ? ` Showing ${limit} of ${candidates.length}.` : "")
+  };
+}
 function getBlastRadius(graph, filePaths, maxDepth = 3) {
   const targetNodes = filePaths.map((filePath) => getGraphNode(graph, filePath)).filter((node) => node !== undefined);
   const targets = targetNodes.map((node) => normalizeLookupPath(node.moduleName));
@@ -142569,7 +142803,9 @@ var VALID_ACTIONS = [
   "key_files",
   "ontology",
   "package_boundaries",
-  "preflight_packet"
+  "preflight_packet",
+  "callers",
+  "dead_exports"
 ];
 var MAX_FILE_PATH_LENGTH3 = 500;
 var MAX_SYMBOL_LENGTH2 = 256;
@@ -142633,7 +142869,7 @@ async function loadOrError(directory, action) {
   }
 }
 var repo_map = createSwarmTool({
-  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers.",
+  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning), ' + '"callers" (files that reference an exported symbol, call-site granularity; needs file+symbol), ' + '"dead_exports" (advisory: exported symbols with no detected in-repo reference). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers. " + 'Note: "callers"/"dead_exports" use conservative regex analysis (TS/JS/Python) and cannot see ' + 'dynamic dispatch or namespace/barrel re-export usage; "dead_exports" results are review candidates, not delete directives.',
   args: {
     action: exports_external.enum([
       "build",
@@ -142644,12 +142880,14 @@ var repo_map = createSwarmTool({
       "key_files",
       "ontology",
       "package_boundaries",
-      "preflight_packet"
-    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet"'),
+      "preflight_packet",
+      "callers",
+      "dead_exports"
+    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet" | "callers" | "dead_exports"'),
     file: exports_external.string().optional().describe("Target file (workspace-relative or absolute). Required for importers/dependencies/localization/ontology. Optional for preflight_packet."),
     files: exports_external.array(exports_external.string()).optional().describe("Multiple target files for blast_radius/preflight_packet. If omitted, falls back to `file`."),
-    symbol: exports_external.string().optional().describe('When provided alongside `file` on action="importers", restrict to consumers of this exported symbol.'),
-    top_n: exports_external.number().int().min(1).max(100).optional().describe('For action="key_files" or "package_boundaries": number of entries to return (default 10).'),
+    symbol: exports_external.string().optional().describe('Exported symbol name. Restricts consumers on action="importers"; required for action="callers".'),
+    top_n: exports_external.number().int().min(1).max(100).optional().describe('For action="key_files"/"package_boundaries": entries to return (default 10). For action="dead_exports": max candidates (default 100).'),
     max_depth: exports_external.number().int().min(1).max(10).optional().describe('For action="blast_radius": max BFS depth (default 3).')
   },
   async execute(args2, directory, _ctx) {
@@ -142711,6 +142949,10 @@ var repo_map = createSwarmTool({
         stale
       });
     }
+    if (action === "dead_exports") {
+      const result = getDeadExports(graph, { maxCandidates: a.top_n ?? 100 });
+      return ok(action, { ...result, stale });
+    }
     if (action === "preflight_packet") {
       const inputs = a.files && a.files.length > 0 ? a.files : a.file ? [a.file] : [];
       for (const f of inputs) {
@@ -142770,6 +143012,22 @@ var repo_map = createSwarmTool({
         stale
       });
     }
+    if (action === "callers") {
+      if (a.symbol === undefined) {
+        return err2(action, "callers requires `symbol` (the exported name)");
+      }
+      const sErr = validateSymbol(a.symbol);
+      if (sErr)
+        return err2(action, `invalid symbol: ${sErr}`);
+      const callers = getCallers(graph, target, a.symbol);
+      return ok(action, {
+        target,
+        symbol: a.symbol,
+        count: callers.length,
+        callers,
+        stale
+      });
+    }
     if (action === "dependencies") {
       const deps = getDependencies(graph, target);
       return ok(action, {

package/dist/tools/repo-graph/builder.d.ts

@@ -26,6 +26,8 @@ export declare const _internals: {
     extractPythonSymbols: typeof extractPythonSymbols;
     parseFileImports: typeof parseFileImports;
     extractFileOntology: typeof extractFileOntology;
+    stripComments: typeof stripComments;
+    computeUsedSymbols: typeof computeUsedSymbols;
 };
 /**
  * Add or update a node in the graph.
@@ -66,6 +68,16 @@ export declare function resolveModuleSpecifier(workspaceRoot: string, sourceFile
 /**
  * A parsed import with its specifier and type.
  */
+/**
+ * A single imported binding: the symbol's *exported* name in the target file
+ * and the *local* name it is bound to in the importing file (differs when an
+ * `as` alias or default import is used). Used to attribute call-site usage back
+ * to the correct exported symbol.
+ */
+interface ImportBinding {
+    imported: string;
+    local: string;
+}
 interface ParsedImport {
     /** The module specifier (e.g., './foo', 'lodash') */
     specifier: string;
@@ -73,8 +85,42 @@ interface ParsedImport {
     importType: 'default' | 'named' | 'namespace' | 'require' | 'sideeffect';
     /** Named imported symbols when statically detectable */
     importedSymbols: string[];
+    /** Alias-aware imported→local bindings for usage attribution */
+    bindings: ImportBinding[];
+    /** True for `export { x } from '...'` re-exports (symbols are re-exposed). */
+    reExport: boolean;
 }
+/**
+ * Strip line (`//…`) and block (`/* … *\/`) comments from JS/TS source while
+ * preserving string, template-literal, and regex-literal contents (DD-C010).
+ * Import specifiers live inside string literals, so strings must be kept
+ * intact; only comment spans are removed. This is a bounded single-pass scanner
+ * — not a full parser (AST parsing in the repo-graph init path would violate
+ * AGENTS.md invariant 1) — and it eliminates the most common source of false
+ * import edges: import-like text inside comments (`// import x from "y"`).
+ *
+ * It is string-aware (a `//` inside `"http://…"` is not a comment) and
+ * regex-aware (a regex literal such as `/[/*]/` must not be mistaken for the
+ * start of a block comment, which would otherwise run to EOF and delete real
+ * imports). Regex-vs-division is disambiguated by the previous significant
+ * character (REGEX_ALLOWED_AFTER).
+ */
+declare function stripComments(content: string): string;
 declare function parseFileImports(rawContent: string): ParsedImport[];
+/**
+ * Conservatively determine which imported bindings are actually referenced in
+ * the importing file's body.
+ *
+ * Heuristic: in a well-formed import statement, each local binding name appears
+ * exactly once. Counting occurrences of the local name across the
+ * comment-stripped file content, a count > 1 means at least one body reference.
+ * Strings are intentionally *not* stripped, so the bias is toward "used" — a
+ * conservative direction that avoids false dead-export positives. Bindings whose
+ * local name cannot be safely word-boundary matched are assumed used.
+ *
+ * @returns the *exported* names (binding.imported) judged to be used.
+ */
+declare function computeUsedSymbols(strippedContent: string, bindings: readonly ImportBinding[]): string[];
 /**
  * Result of scanning a single file for graph updates.
  */

package/dist/tools/repo-graph/query.d.ts

@@ -1,10 +1,35 @@
-import type { BlastRadiusResult, FileOntology, FileReference, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
+import type { BlastRadiusResult, CallerReference, DeadExportsResult, FileOntology, FileReference, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
 export declare function getGraphNode(graph: RepoGraph, input: string): GraphNode | undefined;
 export declare function resetQueryCache(): void;
 export declare function isGraphFresh(graph: RepoGraph | null, maxAgeMs?: number): boolean;
 export declare function getImporters(graph: RepoGraph, filePath: string): FileReference[];
 export declare function getDependencies(graph: RepoGraph, filePath: string): FileReference[];
 export declare function getSymbolConsumers(graph: RepoGraph, filePath: string, symbolName: string): SymbolReference[];
+/**
+ * Files that actually *reference* an exported symbol of `filePath` — call-site
+ * granularity, not just "imports the file". On schema >= 1.1.0 graphs this uses
+ * per-edge `usedSymbols`; on older graphs (or namespace imports) it falls back
+ * to import-level matching, flagged via `resolution: 'imported'`.
+ */
+export declare function getCallers(graph: RepoGraph, filePath: string, symbolName: string): CallerReference[];
+export interface DeadExportsOptions {
+    /** Max candidates returned (default 100). */
+    maxCandidates?: number;
+}
+/**
+ * Conservatively detect exported symbols with no detected in-repo reference.
+ *
+ * Scoping for precision (advisory "candidate" output, never a delete directive):
+ *   - Requires schema >= 1.1.0 (per-edge usedSymbols); otherwise returns
+ *     schemaSupported=false so the caller can prompt a rebuild.
+ *   - Only considers files imported by >= 1 other file — a file with no
+ *     importers is a likely public-API entry / CLI / test, not dead code.
+ *   - Skips files imported anywhere via namespace/side-effect/require/dynamic
+ *     imports, where per-symbol usage is unresolvable.
+ *   - Excludes framework-invoked roles (routes, CLIs, tests, agents, hooks,
+ *     middleware) and the synthetic 'default' export.
+ */
+export declare function getDeadExports(graph: RepoGraph, options?: DeadExportsOptions): DeadExportsResult;
 export declare function getBlastRadius(graph: RepoGraph, filePaths: string[], maxDepth?: number): BlastRadiusResult;
 export declare function getKeyFiles(graph: RepoGraph, topN?: number): GraphNode[];
 export declare function getFileOntology(graph: RepoGraph, filePath: string): FileOntology | null;

package/dist/tools/repo-graph/types.d.ts

@@ -7,7 +7,23 @@
  * Every other submodule imports from here.
  */
 export declare const REPO_GRAPH_FILENAME = "repo-graph.json";
-export declare const GRAPH_SCHEMA_VERSION = "1.0.0";
+/**
+ * Graph schema version.
+ *
+ * 1.1.0 added per-edge `usedSymbols` (imported symbols actually referenced in
+ * the importing file) and per-node `exportLines`, enabling the `callers` and
+ * `dead_exports` queries. Both fields are optional, so graphs written by older
+ * versions (1.0.0) still load — but `dead_exports` requires >= 1.1.0 data and
+ * self-gates via {@link isSchemaVersionAtLeast} rather than relying on the
+ * loader (which only checks that a version string is present, not its value).
+ */
+export declare const GRAPH_SCHEMA_VERSION = "1.1.0";
+/**
+ * Compare dotted numeric version strings (e.g. '1.1.0' >= '1.1.0').
+ * Missing/non-numeric segments are treated as 0. Returns true when `version`
+ * is greater than or equal to `minimum`.
+ */
+export declare function isSchemaVersionAtLeast(version: string | undefined, minimum: string): boolean;
 export declare const FILE_ROLE_VALUES: readonly ["api_route", "middleware", "service_module", "data_module", "swarm_tool", "agent", "hook", "config", "schema", "test_file", "cli_command", "documentation", "source_module"];
 export type FileRole = (typeof FILE_ROLE_VALUES)[number];
 export declare const ROUTE_METHOD_VALUES: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD", "ALL"];
@@ -73,6 +89,13 @@ export interface GraphNode {
     moduleName: string;
     /** Exported symbols from this file */
     exports: string[];
+    /**
+     * Definition line for each exported symbol, keyed by symbol name (1-based).
+     * Optional and best-effort: present on graphs built at schema >= 1.1.0,
+     * absent for symbols whose line could not be determined. Used to point
+     * `dead_exports` candidates at a location.
+     */
+    exportLines?: Record<string, number>;
     /** Imported module specifiers */
     imports: string[];
     /** Language/extension of the file */
@@ -98,6 +121,14 @@ export interface GraphEdge {
     importType: ImportType;
     /** Named symbols imported from the target, when statically detectable */
     importedSymbols?: string[];
+    /**
+     * The subset of the target's exported symbols (by their *exported* name)
+     * that are actually referenced in the source file's body — not merely
+     * imported. Computed at build time via a conservative, alias-aware textual
+     * scan (schema >= 1.1.0). Absent on namespace/side-effect/require/dynamic
+     * imports, where individual symbol usage is not statically resolvable.
+     */
+    usedSymbols?: string[];
 }
 export interface FileReference {
     file: string;
@@ -109,6 +140,47 @@ export interface SymbolReference {
     line?: number;
     importedAs: string;
 }
+/**
+ * A file that references a specific exported symbol of a target file.
+ * `resolution` records how confidently the usage was attributed:
+ *   - 'used'     → the symbol was found referenced in the source body
+ *   - 'imported' → fallback for graphs predating usedSymbols (schema < 1.1.0);
+ *                  the symbol is imported but body usage was not analyzed
+ */
+export interface CallerReference {
+    file: string;
+    resolution: 'used' | 'imported';
+}
+/**
+ * An exported symbol with no detected in-repo reference. Advisory only —
+ * regex-based analysis cannot see dynamic dispatch, string-keyed access, or
+ * usage through namespace/barrel re-exports, so this is a *candidate* for
+ * review, never a directive to delete.
+ */
+export interface DeadExportCandidate {
+    /** Module name (workspace-relative) of the file that owns the export */
+    file: string;
+    /** The exported symbol name */
+    symbol: string;
+    /** Definition line, when known (from exportLines) */
+    line?: number;
+    /** How many other in-repo files import this file at all */
+    importerCount: number;
+}
+export interface DeadExportsResult {
+    /** False when the graph predates schema 1.1.0 (rebuild required). */
+    schemaSupported: boolean;
+    /** Files whose exports were analyzed (imported by >= 1 other file). */
+    analyzedFiles: number;
+    /**
+     * Files skipped because at least one importer used a namespace/side-effect/
+     * require/dynamic import, making per-symbol usage unresolvable.
+     */
+    skippedUnresolvable: number;
+    candidates: DeadExportCandidate[];
+    /** Human-readable note describing scope and limitations of the result. */
+    note: string;
+}
 export interface BlastRadiusResult {
     target: string[];
     directDependents: string[];

package/dist/tools/repo-graph.d.ts

@@ -20,8 +20,9 @@ export { clearCache, getCachedGraph, getCachedMtime, isDirty, markDirty, setCach
 export { updateGraphForFiles } from './repo-graph/incremental';
 export type { ExtractFileOntologyInput } from './repo-graph/ontology';
 export { extractFileOntology } from './repo-graph/ontology';
-export { buildOntologyPreflightPacket, getBlastRadius, getDependencies, getFileOntology, getGraphNode, getImporters, getKeyFiles, getLocalizationContext, getPackageBoundaries, getSymbolConsumers, isGraphFresh, resetQueryCache, } from './repo-graph/query';
+export type { DeadExportsOptions } from './repo-graph/query';
+export { buildOntologyPreflightPacket, getBlastRadius, getCallers, getDeadExports, getDependencies, getFileOntology, getGraphNode, getImporters, getKeyFiles, getLocalizationContext, getPackageBoundaries, getSymbolConsumers, isGraphFresh, resetQueryCache, } from './repo-graph/query';
 export { getGraphPath, loadGraph, loadGraphSync, loadOrCreateGraph, saveGraph, saveIfDirty, } from './repo-graph/storage';
-export type { BlastRadiusResult, BuildWorkspaceGraphOptions, ConventionFact, DataOperationFact, FileOntology, FileReference, FileRole, GraphEdge, GraphNode, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RouteFact, RouteMethod, SecurityFact, SymbolReference, } from './repo-graph/types';
-export { createEmptyGraph, GRAPH_SCHEMA_VERSION, normalizeGraphPath, REPO_GRAPH_FILENAME, updateGraphMetadata, } from './repo-graph/types';
+export type { BlastRadiusResult, BuildWorkspaceGraphOptions, CallerReference, ConventionFact, DataOperationFact, DeadExportCandidate, DeadExportsResult, FileOntology, FileReference, FileRole, GraphEdge, GraphNode, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RouteFact, RouteMethod, SecurityFact, SymbolReference, } from './repo-graph/types';
+export { createEmptyGraph, GRAPH_SCHEMA_VERSION, isSchemaVersionAtLeast, normalizeGraphPath, REPO_GRAPH_FILENAME, updateGraphMetadata, } from './repo-graph/types';
 export { validateGraphEdge, validateGraphNode, validateWorkspace, } from './repo-graph/validation';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.85.0",
+	"version": "7.86.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",