@wrongstack/tools 0.296.2 → 0.296.3

package/dist/tool-tier.js

@@ -5131,11 +5131,18 @@ async function parseSymbols(opts) {
     } else if (ts.isHeritageClause(node)) {
       for (const t of node.types) {
         const name = getTypeName(t.expression);
-        if (name) refs.push({ fromId: 0, toName: name, callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement", line: lineNum });
+        if (name)
+          refs.push({
+            fromId: 0,
+            toName: name,
+            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
+            line: lineNum
+          });
       }
     } else if (ts.isImportDeclaration(node)) {
-      const moduleName = getModuleName(node);
-      if (moduleName) refs.push({ fromId: 0, toName: moduleName, callType: "import", line: lineNum });
+      emitImportSpecifierRefs(node, refs, lineNum);
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+      emitExportSpecifierRefs(node, refs, lineNum);
     }
     const scopeIdx = scopeParts.length;
     pushScopeName(node, scopeParts);
@@ -5151,11 +5158,6 @@ function getTypeName(name) {
   if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
   return "";
 }
-function getModuleName(node) {
-  const moduleSpecifier = node.moduleSpecifier;
-  if (ts.isStringLiteral(moduleSpecifier)) return moduleSpecifier.text;
-  return "";
-}
 function deduplicateRefs(refs) {
   const seen = /* @__PURE__ */ new Set();
   return refs.filter((r) => {
@@ -5165,6 +5167,44 @@ function deduplicateRefs(refs) {
     return true;
   });
 }
+function getImportSpecifierName(spec) {
+  return spec.propertyName?.text ?? spec.name.text;
+}
+function emitImportSpecifierRefs(node, refs, lineNum) {
+  const clause = node.importClause;
+  if (!clause) return;
+  if (clause.name) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+  }
+  const bindings = clause.namedBindings;
+  if (!bindings) return;
+  if (ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      refs.push({
+        fromId: 0,
+        toName: getImportSpecifierName(element),
+        callType: "import",
+        line: lineNum
+      });
+    }
+  } else if (ts.isNamespaceImport(bindings)) {
+    refs.push({ fromId: 0, toName: bindings.name.text, callType: "import", line: lineNum });
+  }
+}
+function emitExportSpecifierRefs(node, refs, lineNum) {
+  const clause = node.exportClause;
+  if (clause && ts.isNamespaceExport(clause)) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum });
+    return;
+  }
+  if (clause && ts.isNamedExports(clause)) {
+    for (const element of clause.elements) {
+      const originalName = element.propertyName?.text ?? element.name.text;
+      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum });
+    }
+    return;
+  }
+}
 var ts, tsLoad, kindMapCache;
 var init_ts_parser = __esm({
   "src/codebase-index/ts-parser.ts"() {
@@ -8454,9 +8494,50 @@ import { createReadStream } from "node:fs";
 import * as fs7 from "node:fs/promises";
 import * as path10 from "node:path";
 import { atomicWrite, ulid } from "@wrongstack/core/utils";
+var ARTIFACT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var sweptRoots = /* @__PURE__ */ new Set();
+function sweepOldArtifacts(root) {
+  if (sweptRoots.has(root)) return;
+  sweptRoots.add(root);
+  void (async () => {
+    const cutoff = Date.now() - ARTIFACT_RETENTION_MS;
+    let sessionDirs;
+    try {
+      const entries = await fs7.readdir(root, { withFileTypes: true });
+      sessionDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return;
+    }
+    for (const sessionDir of sessionDirs) {
+      const dir = path10.join(root, sessionDir);
+      let names;
+      try {
+        names = await fs7.readdir(dir);
+      } catch {
+        continue;
+      }
+      let removed = 0;
+      for (const name of names) {
+        const target = path10.join(dir, name);
+        try {
+          const stat17 = await fs7.stat(target);
+          if (stat17.isFile() && stat17.mtimeMs < cutoff) {
+            await fs7.rm(target, { force: true });
+            removed++;
+          }
+        } catch {
+        }
+      }
+      if (removed === names.length && names.length > 0) {
+        await fs7.rmdir(dir).catch(() => void 0);
+      }
+    }
+  })();
+}
 var BrowserArtifactStore = class {
   constructor(root) {
     this.root = root;
+    sweepOldArtifacts(root);
   }
   root;
   async write(sessionId, kind, extension, mimeType, content) {
@@ -9886,42 +9967,6 @@ import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
 import * as fs14 from "node:fs";
 import * as path21 from "node:path";
 
-// src/codebase-index/schema.ts
-var SCHEMA_VERSION = 3;
-
-// src/codebase-index/lsp-kind.ts
-function lspKindToInternalKind(k) {
-  switch (k) {
-    case 5 /* Class */:
-      return "class";
-    case 6 /* Method */:
-      return "method";
-    case 7 /* Property */:
-    case 8 /* Field */:
-      return "property";
-    case 9 /* Constructor */:
-      return "class";
-    case 10 /* Enum */:
-      return "enum";
-    case 11 /* Interface */:
-      return "interface";
-    case 12 /* Function */:
-      return "function";
-    case 13 /* Variable */:
-      return "var";
-    case 14 /* Constant */:
-      return "const";
-    case 22 /* EnumMember */:
-      return "enum";
-    case 26 /* TypeParameter */:
-      return "type";
-    case 3 /* Namespace */:
-      return "namespace";
-    default:
-      return null;
-  }
-}
-
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
 var B = 0.75;
@@ -10011,6 +10056,42 @@ var Bm25Index = class {
   }
 };
 
+// src/codebase-index/lsp-kind.ts
+function lspKindToInternalKind(k) {
+  switch (k) {
+    case 5 /* Class */:
+      return "class";
+    case 6 /* Method */:
+      return "method";
+    case 7 /* Property */:
+    case 8 /* Field */:
+      return "property";
+    case 9 /* Constructor */:
+      return "class";
+    case 10 /* Enum */:
+      return "enum";
+    case 11 /* Interface */:
+      return "interface";
+    case 12 /* Function */:
+      return "function";
+    case 13 /* Variable */:
+      return "var";
+    case 14 /* Constant */:
+      return "const";
+    case 22 /* EnumMember */:
+      return "enum";
+    case 26 /* TypeParameter */:
+      return "type";
+    case 3 /* Namespace */:
+      return "namespace";
+    default:
+      return null;
+  }
+}
+
+// src/codebase-index/schema.ts
+var SCHEMA_VERSION = 3;
+
 // src/codebase-index/sqlite-runtime.ts
 import { createRequire } from "node:module";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
@@ -10078,96 +10159,6 @@ function runSqliteWithRetry(fn) {
   throw lastError;
 }
 
-// src/codebase-index/writer-helpers.ts
-import { resolveWstackPaths as resolveWstackPaths2 } from "@wrongstack/core/utils";
-function escapeLike(value) {
-  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
-}
-function assignRefsToSymbols(refs, symbols) {
-  if (refs.length === 0 || symbols.length === 0) return [];
-  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
-  const seen = /* @__PURE__ */ new Set();
-  const assigned = [];
-  for (const ref of refs) {
-    let owner2;
-    for (const symbol of ordered) {
-      if (symbol.line > ref.line) break;
-      owner2 = symbol;
-    }
-    if (!owner2 && ref.callType === "import") owner2 = ordered[0];
-    if (!owner2 || owner2.id <= 0) continue;
-    const key = `${owner2.id}:${ref.toName}:${ref.callType}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    assigned.push({ ...ref, fromId: owner2.id });
-  }
-  return assigned;
-}
-function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths2({ projectRoot }).projectCodebaseIndex;
-}
-function codebaseIndexDirOverride(ctx) {
-  const v = ctx.meta?.["codebaseIndexDir"];
-  return typeof v === "string" ? v : void 0;
-}
-
-// src/codebase-index/writer-schema.ts
-var METADATA_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS metadata (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-`;
-var CORE_TABLES_SQL = `
-  CREATE TABLE IF NOT EXISTS files (
-    file TEXT PRIMARY KEY,
-    lang TEXT NOT NULL,
-    mtime_ms INTEGER NOT NULL,
-    symbol_count INTEGER NOT NULL DEFAULT 0,
-    last_indexed INTEGER NOT NULL
-  );
-  CREATE TABLE IF NOT EXISTS symbols (
-    id INTEGER PRIMARY KEY,
-    lang TEXT NOT NULL,
-    kind TEXT NOT NULL,
-    name TEXT NOT NULL,
-    file TEXT NOT NULL,
-    line INTEGER NOT NULL,
-    col INTEGER NOT NULL,
-    signature TEXT NOT NULL DEFAULT '',
-    doc_comment TEXT NOT NULL DEFAULT '',
-    scope TEXT NOT NULL DEFAULT '',
-    text TEXT NOT NULL DEFAULT '',
-    file_fk TEXT NOT NULL
-  );
-`;
-var SYMBOL_INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)",
-  "CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)",
-  "CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)",
-  "CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)",
-  "CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)",
-  "CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)",
-  "CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)"
-];
-var REFS_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS refs (
-    id INTEGER PRIMARY KEY,
-    from_id INTEGER NOT NULL,
-    to_name TEXT NOT NULL,
-    to_id INTEGER,
-    call_type TEXT NOT NULL,
-    line INTEGER NOT NULL
-  );
-`;
-var REFS_INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)",
-  "CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)",
-  "CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)",
-  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)"
-];
-var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
-
 // src/codebase-index/writer-admin.ts
 import * as fs13 from "node:fs";
 import * as path19 from "node:path";
@@ -10640,6 +10631,39 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   return { nodes, edges };
 }
 
+// src/codebase-index/writer-helpers.ts
+import { resolveWstackPaths as resolveWstackPaths2 } from "@wrongstack/core/utils";
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function assignRefsToSymbols(refs, symbols) {
+  if (refs.length === 0 || symbols.length === 0) return [];
+  const ordered = [...symbols].sort((a, b) => a.line - b.line || a.col - b.col || a.id - b.id);
+  const seen = /* @__PURE__ */ new Set();
+  const assigned = [];
+  for (const ref of refs) {
+    let owner2;
+    for (const symbol of ordered) {
+      if (symbol.line > ref.line) break;
+      owner2 = symbol;
+    }
+    if (!owner2 && ref.callType === "import") owner2 = ordered[0];
+    if (!owner2 || owner2.id <= 0) continue;
+    const key = `${owner2.id}:${ref.toName}:${ref.callType}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    assigned.push({ ...ref, fromId: owner2.id });
+  }
+  return assigned;
+}
+function resolveIndexDir(projectRoot, override) {
+  return override ?? resolveWstackPaths2({ projectRoot }).projectCodebaseIndex;
+}
+function codebaseIndexDirOverride(ctx) {
+  const v = ctx.meta?.["codebaseIndexDir"];
+  return typeof v === "string" ? v : void 0;
+}
+
 // src/codebase-index/writer-pragmas.ts
 import { sqliteCachePragmas } from "@wrongstack/core/utils";
 function applyIndexStorePragmas(db) {
@@ -10658,6 +10682,63 @@ function applyIndexStorePragmas(db) {
   }
 }
 
+// src/codebase-index/writer-schema.ts
+var METADATA_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+var CORE_TABLES_SQL = `
+  CREATE TABLE IF NOT EXISTS files (
+    file TEXT PRIMARY KEY,
+    lang TEXT NOT NULL,
+    mtime_ms INTEGER NOT NULL,
+    symbol_count INTEGER NOT NULL DEFAULT 0,
+    last_indexed INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS symbols (
+    id INTEGER PRIMARY KEY,
+    lang TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT NOT NULL,
+    file TEXT NOT NULL,
+    line INTEGER NOT NULL,
+    col INTEGER NOT NULL,
+    signature TEXT NOT NULL DEFAULT '',
+    doc_comment TEXT NOT NULL DEFAULT '',
+    scope TEXT NOT NULL DEFAULT '',
+    text TEXT NOT NULL DEFAULT '',
+    file_fk TEXT NOT NULL
+  );
+`;
+var SYMBOL_INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)",
+  "CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)",
+  "CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)",
+  "CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)",
+  "CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)",
+  "CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)",
+  "CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)"
+];
+var REFS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS refs (
+    id INTEGER PRIMARY KEY,
+    from_id INTEGER NOT NULL,
+    to_name TEXT NOT NULL,
+    to_id INTEGER,
+    call_type TEXT NOT NULL,
+    line INTEGER NOT NULL
+  );
+`;
+var REFS_INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)",
+  "CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)",
+  "CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)",
+  "CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)"
+];
+var SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
+
 // src/codebase-index/writer-search-helpers.ts
 function normalizeSearchLimit(limit) {
   return typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : void 0;
@@ -10866,9 +10947,15 @@ var IndexStore = class _IndexStore {
         DROP TABLE IF EXISTS refs;
       `);
       this.db.exec("DROP TABLE IF EXISTS symbols_fts");
-      this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(String(SCHEMA_VERSION), "version");
+      this.stmt("UPDATE metadata SET value = ? WHERE key = ?").run(
+        String(SCHEMA_VERSION),
+        "version"
+      );
     } else if (storedVersion === null) {
-      this.stmt("INSERT INTO metadata(key, value) VALUES (?, ?)").run("version", String(SCHEMA_VERSION));
+      this.stmt("INSERT INTO metadata(key, value) VALUES (?, ?)").run(
+        "version",
+        String(SCHEMA_VERSION)
+      );
     }
     this.db.exec(CORE_TABLES_SQL);
     for (const sql of SYMBOL_INDEX_SQL) this.db.exec(sql);
@@ -10885,7 +10972,9 @@ var IndexStore = class _IndexStore {
       );
       if (symbolCount !== ftsCount) {
         this.db.exec("DELETE FROM symbols_fts");
-        const rows = this.stmt("SELECT id, name, signature, doc_comment FROM symbols ORDER BY id").all();
+        const rows = this.stmt(
+          "SELECT id, name, signature, doc_comment FROM symbols ORDER BY id"
+        ).all();
         bulkInsertFtsWithStatement(
           (sql) => this.stmt(sql),
           _IndexStore.MAX_SQL_VARS,
@@ -11107,7 +11196,9 @@ var IndexStore = class _IndexStore {
     const limitSql = limit !== void 0 ? " LIMIT ?" : "";
     const sql = `SELECT id, lang, kind, name, file, line, col, signature, doc_comment, text FROM symbols ${where}${limitSql}`;
     const binds = limit !== void 0 ? [...values, limit] : values;
-    const rows = this.stmt(sql).all(...binds);
+    const rows = this.stmt(sql).all(
+      ...binds
+    );
     return rows.map((row) => mapWriterSearchRow(row, filter?.lspKind));
   }
   /** Shared WHERE builder for {@link search} / empty-query ranked totals. */
@@ -11283,7 +11374,9 @@ var IndexStore = class _IndexStore {
   }
   setLastIndexed(ts2) {
     this.runWithRetry(() => {
-      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(String(ts2));
+      this.stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES('last_indexed', ?)").run(
+        String(ts2)
+      );
     });
   }
   getMetadata(key) {
@@ -11394,7 +11487,9 @@ var IndexStore = class _IndexStore {
           this.stmt(
             `DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file IN (${placeholders}))`
           ).run(...options.deleteForFiles);
-          this.stmt(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
+          this.stmt(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(
+            ...options.deleteForFiles
+          );
         }
         const totalSymbols = entries.reduce((n, e) => n + e.symbols.length, 0);
         let nextId = this.allocateSymbolIds(totalSymbols);
@@ -11438,11 +11533,7 @@ var IndexStore = class _IndexStore {
           this.ftsAvailable,
           ftsRows
         );
-        bulkInsertRefsWithStatement(
-          (sql) => this.stmt(sql),
-          _IndexStore.MAX_SQL_VARS,
-          refsToInsert
-        );
+        bulkInsertRefsWithStatement((sql) => this.stmt(sql), _IndexStore.MAX_SQL_VARS, refsToInsert);
         const upsertStmt = this.stmt(
           `INSERT INTO files(file, lang, mtime_ms, symbol_count, last_indexed)
            VALUES (?, ?, ?, ?, ?)
@@ -11471,7 +11562,9 @@ var IndexStore = class _IndexStore {
    */
   deleteRefsForFile(file) {
     this.runWithRetry(() => {
-      this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(file);
+      this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
+        file
+      );
     });
   }
   /**
@@ -11626,9 +11719,7 @@ var IndexStore = class _IndexStore {
    * build the full symbol universe for the reachability scan.
    */
   getAllSymbols() {
-    return this.stmt(
-      "SELECT id, name, file, kind, line FROM symbols ORDER BY id"
-    ).all().map((r) => ({ ...r, kind: r.kind }));
+    return this.stmt("SELECT id, name, file, kind, line FROM symbols ORDER BY id").all().map((r) => ({ ...r, kind: r.kind }));
   }
   /**
    * Returns every resolved reference (to_id IS NOT NULL). Used by
@@ -11640,6 +11731,25 @@ var IndexStore = class _IndexStore {
       "SELECT from_id AS fromId, to_id AS toId, call_type AS callType FROM refs WHERE to_id IS NOT NULL"
     ).all();
   }
+  /**
+   * Returns ALL import refs (including unresolved) with their source-file
+   * path and resolved target id.  Used by the dead-code scan's file-level
+   * graph traversal to handle barrel-only entry points where no symbol
+   * carries the ref.
+   *
+   * Refs whose `from_id` doesn't match a known symbol (e.g. pure-barrel
+   * files with no declarations) will have `sourceFile === null`.
+   */
+  getAllImportRefs() {
+    return this.stmt(
+      `SELECT s.file AS sourceFile, r.to_name AS toName, r.to_id AS toId,
+              r.call_type AS callType, r.line
+       FROM refs r
+       LEFT JOIN symbols s ON r.from_id = s.id
+       WHERE r.call_type = 'import'
+       ORDER BY r.line`
+    ).all();
+  }
   close() {
     this.stmtCache.clear();
     this.bm25Dirty = true;
@@ -13349,6 +13459,7 @@ var codebaseStatsTool = {
 };
 
 // src/codebase-index/dead-code-scan.ts
+init_languages2();
 import * as fs19 from "node:fs";
 import * as path24 from "node:path";
 var deadCodeScanTool = {
@@ -13417,7 +13528,15 @@ function discoverEntryPoints(projectRoot, userEntryPoints) {
   if (rootPkg) {
     addPkgJsonEntryPoints(projectRoot, rootPkg, entries);
   }
-  const workspaces = rootPkg ? extractWorkspaceGlobs(rootPkg, projectRoot) : [];
+  let workspaces;
+  if (rootPkg) {
+    workspaces = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (workspaces.length === 0) {
+      workspaces = extractPnpmWorkspaceDirs(projectRoot);
+    }
+  } else {
+    workspaces = [];
+  }
   for (const wsDir of workspaces) {
     const pkgJsonPath = path24.join(wsDir, "package.json");
     const pkg = tryReadJson(pkgJsonPath);
@@ -13439,77 +13558,189 @@ function discoverEntryPoints(projectRoot, userEntryPoints) {
   }
   return [...entries];
 }
+var BUILD_OUTPUT_DIRS = ["dist", "out", "build", "release"];
+var BUILD_OUTPUT_DIR_NAMES = BUILD_OUTPUT_DIRS.map((d) => `${path24.sep}${d}${path24.sep}`);
+function trySourceEquivalent(resolved) {
+  resolved = resolved.replace(/[/\\]/g, path24.sep);
+  for (const marker of BUILD_OUTPUT_DIR_NAMES) {
+    const idx = resolved.indexOf(marker);
+    if (idx === -1) continue;
+    const base = resolved.replace(marker, `${path24.sep}src${path24.sep}`);
+    const candidate = base.replace(/\.(js|mjs|cjs)$/, ".ts");
+    if (candidate !== base && fs19.existsSync(candidate)) {
+      return candidate;
+    }
+    const dtsStripped = base.replace(/\.d\.ts$/, "");
+    const candidateDts = dtsStripped + ".ts";
+    if (candidateDts !== base && candidateDts !== candidate && fs19.existsSync(candidateDts)) {
+      return candidateDts;
+    }
+    const candidateNoExt = base + ".ts";
+    if (candidate !== candidateNoExt && candidateNoExt !== candidateDts && fs19.existsSync(candidateNoExt)) {
+      return candidateNoExt;
+    }
+  }
+  return null;
+}
+function tryAddEntryPath(pkgDir, rawPath, entries) {
+  const resolved = resolveAgainst(pkgDir, rawPath);
+  if (fs19.existsSync(resolved)) entries.add(resolved);
+  const tsResolved = resolved.replace(/\.(js|mjs|cjs)$/, ".ts");
+  if (tsResolved !== resolved && fs19.existsSync(tsResolved)) {
+    entries.add(tsResolved);
+  }
+  const srcAlt = trySourceEquivalent(resolved);
+  if (srcAlt) entries.add(srcAlt);
+}
 function addPkgJsonEntryPoints(pkgDir, pkg, entries) {
   if (typeof pkg.main === "string") {
-    const resolved = resolveAgainst(pkgDir, pkg.main);
-    if (fs19.existsSync(resolved)) entries.add(resolved);
-    const tsResolved = resolved.replace(/\.(js|mjs|cjs)$/, ".ts");
-    if (tsResolved !== resolved && fs19.existsSync(tsResolved)) {
-      entries.add(tsResolved);
-    }
+    tryAddEntryPath(pkgDir, pkg.main, entries);
   }
   const bin = pkg.bin;
   if (typeof bin === "string") {
-    const resolved = resolveAgainst(pkgDir, bin);
-    if (fs19.existsSync(resolved)) entries.add(resolved);
+    tryAddEntryPath(pkgDir, bin, entries);
   } else if (bin && typeof bin === "object") {
     for (const value of Object.values(bin)) {
       if (typeof value === "string") {
-        const resolved = resolveAgainst(pkgDir, value);
-        if (fs19.existsSync(resolved)) entries.add(resolved);
+        tryAddEntryPath(pkgDir, value, entries);
       }
     }
   }
   for (const key of ["types", "typings"]) {
     if (typeof pkg[key] === "string") {
-      const resolved = resolveAgainst(pkgDir, pkg[key]);
-      if (fs19.existsSync(resolved)) entries.add(resolved);
+      tryAddEntryPath(pkgDir, pkg[key], entries);
     }
   }
   const exports_ = pkg.exports;
   if (exports_ && typeof exports_ === "object") {
     for (const value of Object.values(exports_)) {
       if (typeof value === "string") {
-        const resolved = resolveAgainst(pkgDir, value);
-        if (fs19.existsSync(resolved)) entries.add(resolved);
+        tryAddEntryPath(pkgDir, value, entries);
       } else if (value && typeof value === "object") {
-        for (const nested of Object.values(
-          value
-        )) {
+        for (const nested of Object.values(value)) {
           if (typeof nested === "string") {
-            const resolved = resolveAgainst(pkgDir, nested);
-            if (fs19.existsSync(resolved)) entries.add(resolved);
+            tryAddEntryPath(pkgDir, nested, entries);
           }
         }
       }
     }
   }
 }
+function expandGlobPattern(entry, projectRoot) {
+  const dirs = [];
+  if (entry.includes("*")) {
+    const base = entry.replace(/\/\*+$/, "");
+    const baseDir = path24.resolve(projectRoot, base);
+    try {
+      const children = fs19.readdirSync(baseDir, { withFileTypes: true });
+      for (const child of children) {
+        if (child.isDirectory()) {
+          dirs.push(path24.join(baseDir, child.name));
+        }
+      }
+    } catch {
+    }
+  } else {
+    dirs.push(path24.resolve(projectRoot, entry));
+  }
+  return dirs;
+}
 function extractWorkspaceGlobs(pkg, projectRoot) {
   const dirs = [];
   const workspaces = pkg.workspaces;
   if (Array.isArray(workspaces)) {
     for (const entry of workspaces) {
       if (typeof entry === "string") {
-        if (entry.includes("*")) {
-          const base = entry.replace(/\/\*+$/, "");
-          const baseDir = path24.resolve(projectRoot, base);
-          try {
-            const children = fs19.readdirSync(baseDir, { withFileTypes: true });
-            for (const child of children) {
-              if (child.isDirectory()) {
-                dirs.push(path24.join(baseDir, child.name));
-              }
-            }
-          } catch {
+        dirs.push(...expandGlobPattern(entry, projectRoot));
+      }
+    }
+  }
+  return dirs;
+}
+function extractPnpmWorkspaceDirs(projectRoot) {
+  const yamlPath = path24.join(projectRoot, "pnpm-workspace.yaml");
+  if (!fs19.existsSync(yamlPath)) return [];
+  try {
+    const content = fs19.readFileSync(yamlPath, "utf8");
+    const dirs = [];
+    let inPackages = false;
+    const lines = content.split("\n");
+    const itemRe = /^\s+-\s+"([^"]+)"|^\s+-\s+'([^']+)'|^\s+-\s+(\S+)/;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (/^packages\s*:\s*$/.test(trimmed)) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages && trimmed.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) {
+        if (!trimmed.startsWith("-")) {
+          inPackages = false;
+          continue;
+        }
+      }
+      if (inPackages) {
+        const m = itemRe.exec(line);
+        if (m) {
+          const entry = m[1] ?? m[2] ?? m[3];
+          if (entry) {
+            dirs.push(...expandGlobPattern(entry, projectRoot));
           }
-        } else {
-          dirs.push(path24.resolve(projectRoot, entry));
         }
       }
     }
+    return dirs;
+  } catch {
+    return [];
+  }
+}
+function resolveModulePath(importerPath, moduleSpecifier, indexedFiles) {
+  if (!moduleSpecifier.startsWith(".")) return [];
+  const dir = path24.dirname(importerPath);
+  const base = path24.resolve(dir, moduleSpecifier);
+  const results = [];
+  const stripped = base.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+  const skipBase = stripped !== base && /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(base);
+  const candidates = skipBase ? [stripped] : [base];
+  for (const candidate of candidates) {
+    if (indexedFiles.has(candidate + ".ts")) results.push(candidate + ".ts");
+    if (indexedFiles.has(candidate + ".tsx")) results.push(candidate + ".tsx");
+    if (indexedFiles.has(candidate + ".js")) results.push(candidate + ".js");
+    if (indexedFiles.has(candidate + ".jsx")) results.push(candidate + ".jsx");
+    if (indexedFiles.has(candidate + ".mjs")) results.push(candidate + ".mjs");
+    if (indexedFiles.has(candidate + ".cjs")) results.push(candidate + ".cjs");
+    if (indexedFiles.has(path24.join(candidate, "index.ts")))
+      results.push(path24.join(candidate, "index.ts"));
+    if (indexedFiles.has(path24.join(candidate, "index.tsx")))
+      results.push(path24.join(candidate, "index.tsx"));
+    if (indexedFiles.has(path24.join(candidate, "index.js")))
+      results.push(path24.join(candidate, "index.js"));
+    if (indexedFiles.has(path24.join(candidate, "index.jsx")))
+      results.push(path24.join(candidate, "index.jsx"));
+    if (indexedFiles.has(path24.join(candidate, "index.mjs")))
+      results.push(path24.join(candidate, "index.mjs"));
+    if (indexedFiles.has(path24.join(candidate, "index.cjs")))
+      results.push(path24.join(candidate, "index.cjs"));
+  }
+  return [...new Set(results)];
+}
+function parseNamedExportSymbols(matchText) {
+  const braceStart = matchText.indexOf("{");
+  if (braceStart === -1) return null;
+  const braceEnd = matchText.indexOf("}", braceStart);
+  if (braceEnd === -1) return null;
+  const inner = matchText.slice(braceStart + 1, braceEnd);
+  const symbols = [];
+  for (const part of inner.split(",")) {
+    let s = part.trim();
+    if (!s) continue;
+    s = s.replace(/^type\s+/, "");
+    const asIdx = s.search(/\s+as\s+/);
+    if (asIdx !== -1) {
+      s = s.slice(0, asIdx).trim();
+    }
+    if (s) symbols.push(s);
   }
-  return dirs;
+  return symbols;
 }
 function runDeadCodeScan(projectRoot, opts = {}) {
   const store = opts.store ?? indexStorePool.acquire(projectRoot, { indexDir: opts.indexDir });
@@ -13531,12 +13762,71 @@ function runDeadCodeScan(projectRoot, opts = {}) {
     }
     const discoveredFiles = discoverEntryPoints(projectRoot, opts.userEntryPoints);
     const entryFileSet = new Set(discoveredFiles.map((f) => path24.resolve(f)));
+    const indexedFiles = /* @__PURE__ */ new Set();
+    for (const s of allSymbols) indexedFiles.add(s.file);
+    for (const fm of store.getAllFileMetas()) indexedFiles.add(fm.file);
     const seedIds = /* @__PURE__ */ new Set();
     for (const s of allSymbols) {
       if (entryFileSet.has(s.file)) {
         seedIds.add(s.id);
       }
     }
+    const fileToSymbolIds = /* @__PURE__ */ new Map();
+    for (const s of allSymbols) {
+      let byFile = fileToSymbolIds.get(s.file);
+      if (!byFile) {
+        byFile = [];
+        fileToSymbolIds.set(s.file, byFile);
+      }
+      byFile.push(s.id);
+    }
+    const scannedBarrels = /* @__PURE__ */ new Set();
+    const barrelWorkList = [...entryFileSet];
+    while (barrelWorkList.length > 0) {
+      const epFile = barrelWorkList.pop();
+      if (scannedBarrels.has(epFile)) continue;
+      scannedBarrels.add(epFile);
+      try {
+        const content = fs19.readFileSync(epFile, "utf8");
+        const strippedContent = content.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length)).replace(/\/\/[^\n]*/g, (m) => " ".repeat(m.length));
+        const reExportRe = /export\s+(?:(?:type\s+)?\{[\s\S]*?\}\s+from|\*\s+as\s+\w+\s+from|\*\s+from)\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = reExportRe.exec(strippedContent)) !== null) {
+          const moduleSpec = match[1];
+          const resolvedFiles = resolveModulePath(epFile, moduleSpec, indexedFiles);
+          for (const rf of resolvedFiles) {
+            const fileSyms = fileToSymbolIds.get(rf);
+            if (fileSyms) {
+              const namedSymbols = parseNamedExportSymbols(match[0]);
+              if (namedSymbols) {
+                const nameSet = new Set(namedSymbols);
+                for (const sid of fileSyms) {
+                  const sym = symbolById.get(sid);
+                  if (sym && nameSet.has(sym.name)) seedIds.add(sid);
+                }
+              } else {
+                for (const sid of fileSyms) seedIds.add(sid);
+              }
+            }
+            if (!scannedBarrels.has(rf)) {
+              barrelWorkList.push(rf);
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof Error && err.code !== "ENOENT") {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "dead_code_scan_barrel_read_failed",
+              message: err.message,
+              file: epFile,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      }
+    }
     const alive = new Set(seedIds);
     const frontier = [...seedIds];
     const visitedEdges = /* @__PURE__ */ new Set();
@@ -13570,8 +13860,7 @@ function runDeadCodeScan(projectRoot, opts = {}) {
       dead.push({
         name: s.name,
         kind: s.kind,
-        lang: "ts",
-        // populated from symbol file metadata
+        lang: detectLang(s.file) ?? "ts",
         file: s.file,
         line: s.line,
         reason
@@ -13596,16 +13885,14 @@ function runDeadCodeScan(projectRoot, opts = {}) {
         deadFiles.push({
           file,
           symbolCount: syms.length,
-          lang: syms[0]?.kind ?? "ts"
+          lang: detectLang(file) ?? "ts"
         });
       }
     }
     const deadPackages = [];
     const pkgEntries = findPackageEntries(projectRoot);
     for (const [pkgName, pkgDir] of pkgEntries) {
-      const pkgFiles = allSymbols.filter(
-        (s) => s.file.startsWith(pkgDir + path24.sep)
-      );
+      const pkgFiles = allSymbols.filter((s) => s.file.startsWith(pkgDir + path24.sep));
       if (pkgFiles.length === 0) continue;
       const pkgUsed = pkgFiles.filter((s) => alive.has(s.id));
       if (pkgUsed.length === 0) {
@@ -13646,7 +13933,10 @@ function findPackageEntries(projectRoot) {
     pkgMap.set(rootPkg.name, projectRoot);
   }
   if (rootPkg) {
-    const wsDirs = extractWorkspaceGlobs(rootPkg, projectRoot);
+    let wsDirs = extractWorkspaceGlobs(rootPkg, projectRoot);
+    if (wsDirs.length === 0) {
+      wsDirs = extractPnpmWorkspaceDirs(projectRoot);
+    }
     for (const wsDir of wsDirs) {
       const wsPkg = tryReadJson(path24.join(wsDir, "package.json"));
       if (wsPkg && typeof wsPkg.name === "string") {
@@ -14263,7 +14553,7 @@ function processFile(content, absPath, _style, _overwrite, target) {
 
 // src/e2e.ts
 init_util();
-import { open, readdir as readdir5 } from "node:fs/promises";
+import { open, readdir as readdir6 } from "node:fs/promises";
 import * as path27 from "node:path";
 async function readBoundedText(filePath, maxBytes) {
   let handle;
@@ -14381,7 +14671,7 @@ async function scanWorkspace(root, maxDepth, signal) {
     }
     let entries;
     try {
-      entries = await readdir5(current.directory, { withFileTypes: true });
+      entries = await readdir6(current.directory, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -14440,7 +14730,7 @@ async function detectPackageManager3(projectRoot, scanRoot, declared) {
   while (true) {
     const names = /* @__PURE__ */ new Set();
     try {
-      for (const entry of await readdir5(directory)) names.add(entry);
+      for (const entry of await readdir6(directory)) names.add(entry);
     } catch {
     }
     if (names.has("pnpm-lock.yaml")) return "pnpm";
@@ -14508,7 +14798,7 @@ async function collectSpecs(root, framework, testDirectory, signal) {
     if (scanned > MAX_SCAN_DIRECTORIES) return { count, samples, truncated: true };
     let entries;
     try {
-      entries = await readdir5(directory, { withFileTypes: true });
+      entries = await readdir6(directory, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -17217,7 +17507,7 @@ async function detectFixer(cwd) {
 init_util();
 import { spawn as spawn10 } from "node:child_process";
 import { statSync as statSync4 } from "node:fs";
-import { dirname as dirname13, resolve as resolve13, sep as sep6 } from "node:path";
+import { dirname as dirname14, resolve as resolve13, sep as sep6 } from "node:path";
 import { assessCommitSafety } from "@wrongstack/core/coordination";
 import { buildChildEnv as buildChildEnv4 } from "@wrongstack/core/utils";
 var TIMEOUT_MS2 = 3e4;
@@ -17379,7 +17669,7 @@ function findGitDir2(cwd, projectRoot) {
     } catch {
     }
     if (dir === root) break;
-    const parent = dirname13(dir);
+    const parent = dirname14(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -21477,12 +21767,13 @@ init_util();
 import * as fs28 from "node:fs/promises";
 import { FsError, ToolValidationError as ToolValidationError5 } from "@wrongstack/core/types";
 import { toErrorMessage as toErrorMessage4 } from "@wrongstack/core/utils";
+var ADVANCED_MODE_META_KEY = "tools.read.advancedMode";
 var MAX_BYTES2 = 5 * 1024 * 1024;
 var readTool = {
   name: "read",
   category: "Filesystem",
-  description: "Read the contents of a file with line numbers. This is the primary way to inspect source code, configuration, or any text file before making changes. Lines are returned 1-indexed with a `   N| ` prefix for easy reference in edits.",
-  usageHint: "FOUNDATIONAL TOOL \u2014 call this before almost any edit operation.\n\nBest practices:\n- Always read a file before using `edit`, `replace`, or `write` on it (the system often requires it for safety).\n- Use `offset` + `limit` for very large files instead of reading everything at once.\n- Default limit is generous (2000 lines) but can be increased.\n- The output format is designed to be directly usable as context for `edit` operations.",
+  description: "Read the contents of a file with line numbers. This is the primary way to inspect source code, configuration, or any text file before making changes. Lines are returned 1-indexed with a `   N| ` prefix for easy reference in edits. When advanced mode is on or `includeSymbols` is set, the result also includes a `symbols` field listing codebase-index symbol names, kinds, and line numbers for the file (not file content).",
+  usageHint: "FOUNDATIONAL TOOL \u2014 call this before almost any edit operation.\n\nBest practices:\n- Always read a file before using `edit`, `replace`, or `write` on it (the system often requires it for safety).\n- Use `offset` + `limit` for very large files instead of reading everything at once.\n- Default limit is generous (2000 lines) but can be increased.\n- The output format is designed to be directly usable as context for `edit` operations.\n- Set `includeSymbols: true` to also receive the codebase-index symbol listing for the file.\n- Enable advanced mode (`ctx.meta['tools.read.advancedMode'] = true`) to auto-inject symbols on every read.",
   selection: {
     doNotUseWhen: "you need to search many files for matching content.",
     useInstead: ["grep"]
@@ -21512,11 +21803,15 @@ var readTool = {
         type: "string",
         enum: ["content", "summary"],
         description: "Return full line-numbered content (default) or a compact file summary with imports/exports/symbols."
+      },
+      includeSymbols: {
+        type: "boolean",
+        description: "When true, include the codebase-index symbol list for this file as a structured `symbols` field in the result. Overrides the advanced-mode meta flag per-call."
       }
     },
     required: ["path"]
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, execOpts) {
     if (!input?.path) {
       throw new ToolValidationError5({
         message: "read: path is required",
@@ -21524,6 +21819,7 @@ var readTool = {
       });
     }
     const absPath = await safeResolveReal(input.path, ctx);
+    const shouldIncludeSymbols = input.includeSymbols === true || input.includeSymbols !== false && ctx.meta[ADVANCED_MODE_META_KEY] === true;
     let stat17;
     try {
       stat17 = await fs28.stat(absPath);
@@ -21567,13 +21863,15 @@ var readTool = {
     const requestedEnd = prior ? Math.min(offset + limit - 1, prior.totalLines) : offset + limit - 1;
     if (input.mode !== "summary" && limit > 0 && prior && coversRange(prior, stat17.mtimeMs, offset, requestedEnd)) {
       ctx.recordRead(absPath, stat17.mtimeMs);
+      const symResult2 = shouldIncludeSymbols ? await fetchSymbolsForFile(absPath, ctx, execOpts?.signal) : void 0;
       return {
         text: `[unchanged since previous read: "${input.path}" mtime=${Math.round(stat17.mtimeMs)}; requested lines ${offset}-${requestedEnd} were already shown. Use offset/limit for a new range if needed.]`,
         total_lines: prior.totalLines,
         encoding: "utf8",
         truncated: requestedEnd < prior.totalLines,
         cached: true,
-        note: "Repeated read suppressed to save tokens."
+        note: mergeSymbolNote("Repeated read suppressed to save tokens.", symResult2?.note),
+        ...symResult2?.symbols ? { symbols: symResult2.symbols } : {}
       };
     }
     const buf = await fs28.readFile(absPath);
@@ -21587,27 +21885,43 @@ var readTool = {
     if (input.mode === "summary") {
       ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
       rememberReadRange(ctx, absPath, stat17.mtimeMs, total, 1, Math.min(total, 200));
+      const symResult2 = shouldIncludeSymbols ? await fetchSymbolsForFile(absPath, ctx, execOpts?.signal) : void 0;
       return {
         text: summarizeFile(input.path, stat17.size, allLines),
         total_lines: total,
         encoding: "utf8",
         truncated: total > 200,
-        note: "Summary mode returned compact structure instead of full file content."
+        note: mergeSymbolNote(
+          "Summary mode returned compact structure instead of full file content.",
+          symResult2?.note
+        ),
+        ...symResult2?.symbols ? { symbols: symResult2.symbols } : {}
       };
     }
     if (limit === 0) {
       ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
       rememberReadRange(ctx, absPath, stat17.mtimeMs, total, 1, 0);
-      return { text: "", total_lines: total, encoding: "utf8", truncated: total > 0 };
+      const symResult2 = shouldIncludeSymbols ? await fetchSymbolsForFile(absPath, ctx, execOpts?.signal) : void 0;
+      return {
+        text: "",
+        total_lines: total,
+        encoding: "utf8",
+        truncated: total > 0,
+        ...symResult2?.symbols ? { symbols: symResult2.symbols } : {},
+        ...symResult2?.note ? { note: symResult2.note } : {}
+      };
     }
     if (offset > total) {
       ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
       rememberReadRange(ctx, absPath, stat17.mtimeMs, total, total + 1, total + 1);
+      const symResult2 = shouldIncludeSymbols ? await fetchSymbolsForFile(absPath, ctx, execOpts?.signal) : void 0;
       return {
         text: `[offset ${offset} is past end of file "${input.path}" \u2014 file has ${total} line(s). Do not retry this offset.]`,
         total_lines: total,
         encoding: "utf8",
-        truncated: false
+        truncated: false,
+        ...symResult2?.symbols ? { symbols: symResult2.symbols } : {},
+        ...symResult2?.note ? { note: symResult2.note } : {}
       };
     }
     const slice = allLines.slice(offset - 1, offset - 1 + limit);
@@ -21616,14 +21930,53 @@ var readTool = {
     const numbered = slice.map((line, i) => `${String(offset + i).padStart(width, " ")}\u2192${line}`).join("\n");
     ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
     rememberReadRange(ctx, absPath, stat17.mtimeMs, total, offset, offset + slice.length - 1);
+    const symResult = shouldIncludeSymbols ? await fetchSymbolsForFile(absPath, ctx, execOpts?.signal) : void 0;
     return {
       text: numbered,
       total_lines: total,
       encoding: "utf8",
-      truncated
+      truncated,
+      ...symResult?.symbols ? { symbols: symResult.symbols } : {},
+      ...symResult?.note ? { note: symResult.note } : {}
     };
   }
 };
+async function fetchSymbolsForFile(absPath, ctx, signal) {
+  try {
+    const state = getIndexState();
+    if (!state.ready) return {};
+    const { results, total } = await searchCodebaseIndex(
+      {
+        projectRoot: ctx.projectRoot,
+        indexDir: codebaseIndexDirOverride(ctx),
+        query: "",
+        file: absPath,
+        limit: 500
+      },
+      { signal }
+    );
+    if (results.length === 0) return {};
+    const sorted = results.map((r) => ({
+      name: r.name,
+      kind: r.kind,
+      line: r.line,
+      col: r.col,
+      signature: r.signature
+    })).sort((a, b) => a.line - b.line || a.col - b.col);
+    const result = { symbols: sorted };
+    if (total > results.length) {
+      result.note = `Symbol listing truncated to ${results.length} of ${total} entries.`;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function mergeSymbolNote(note, symNote) {
+  if (!symNote) return note;
+  if (!note) return symNote;
+  return `${note} ${symNote}`;
+}
 var READ_RANGES_META_KEY = "tools.read.ranges.v1";
 function getReadRanges(ctx) {
   const existing = ctx.meta[READ_RANGES_META_KEY];