@askexenow/exe-os 0.9.69 → 0.9.70

package/dist/mcp/server.js

@@ -4772,6 +4772,12 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "exe-build-adv is MANDATORY for ALL work touching 3+ files. Run /exe-build-adv --auto BEFORE implementation. Pipeline: Spec \u2192 AC \u2192 Tests \u2192 Evaluate \u2192 Fix. No multi-file feature ships without pipeline artifacts. No exceptions \u2014 managers reject work without them."
       },
+      {
+        title: "Code context first for repository orientation",
+        domain: "workflow",
+        priority: "p1",
+        content: "Before broad repo exploration, symbol tracing, blast-radius review, or codebase Q&A, agents should use the consolidated code_context MCP tool instead of manual grep/read loops. Use action=index or stats to refresh/check the index; action=search with query, limit, offset, languages, paths, refresh_index for fresh multi-language code/doc search; action=trace for symbol imports/dependents; action=blast_radius for impact analysis before edits. CLI parity exists via exe-os code-context init|index|status|stats|search|doctor. Keep code_context separate from durable employee memory: promote only validated decisions, procedures, or lessons into store_memory/commit_memory."
+      },
       {
         title: "Commit discipline \u2014 never leave verified work floating",
         domain: "workflow",
@@ -18331,13 +18337,75 @@ import crypto13 from "crypto";
 
 // src/lib/code-chunker.ts
 import ts from "typescript";
+var LANGUAGE_BY_EXTENSION = {
+  c: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  cxx: "cpp",
+  h: "c",
+  hh: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  css: "css",
+  scss: "scss",
+  f: "fortran",
+  f90: "fortran",
+  f95: "fortran",
+  go: "go",
+  html: "html",
+  htm: "html",
+  java: "java",
+  js: "javascript",
+  jsx: "javascript",
+  json: "json",
+  kt: "kotlin",
+  kts: "kotlin",
+  lua: "lua",
+  md: "markdown",
+  mdx: "mdx",
+  pas: "pascal",
+  php: "php",
+  py: "python",
+  r: "r",
+  rb: "ruby",
+  rs: "rust",
+  scala: "scala",
+  sc: "scala",
+  sol: "solidity",
+  sql: "sql",
+  svelte: "svelte",
+  swift: "swift",
+  toml: "toml",
+  ts: "typescript",
+  tsx: "typescript",
+  vue: "vue",
+  xml: "xml",
+  yaml: "yaml",
+  yml: "yaml",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell"
+};
+var TEXT_LIKE_LANGUAGES = /* @__PURE__ */ new Set(["json", "markdown", "mdx", "toml", "yaml", "xml", "html", "css", "scss", "sql"]);
+function languageForFile(filePath) {
+  const base = filePath.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+  if (["dockerfile", "makefile", "rakefile", "gemfile"].includes(base)) return base;
+  const ext = base.includes(".") ? base.split(".").pop() : void 0;
+  return ext ? LANGUAGE_BY_EXTENSION[ext] : void 0;
+}
 function chunkSourceFile(source, fileName = "file.ts") {
+  const language = languageForFile(fileName);
+  if (language === "typescript" || language === "javascript") {
+    return chunkTypeScriptLike(source, fileName);
+  }
+  return chunkGenericSource(source, fileName, language);
+}
+function chunkTypeScriptLike(source, fileName) {
   const sourceFile = ts.createSourceFile(
     fileName,
     source,
     ts.ScriptTarget.Latest,
     true,
-    // setParentNodes
     fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
   );
   const chunks = [];
@@ -18359,144 +18427,117 @@ function chunkSourceFile(source, fileName = "file.ts") {
     if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
       return node.name?.getText(sourceFile) ?? "(anonymous)";
     }
-    if (ts.isClassDeclaration(node)) {
-      return node.name?.getText(sourceFile) ?? "(anonymous class)";
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isEnumDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isVariableStatement(node)) {
-      const decls = node.declarationList.declarations;
-      return decls.map((d) => d.name.getText(sourceFile)).join(", ");
-    }
-    if (ts.isExportAssignment(node)) {
-      return "default export";
-    }
+    if (ts.isClassDeclaration(node)) return node.name?.getText(sourceFile) ?? "(anonymous class)";
+    if (ts.isInterfaceDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isTypeAliasDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isEnumDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isVariableStatement(node)) return node.declarationList.declarations.map((d) => d.name.getText(sourceFile)).join(", ");
+    if (ts.isExportAssignment(node)) return "default export";
     return "(unknown)";
   }
   function visitTopLevel(node) {
     if (ts.isImportDeclaration(node)) {
-      importLines.push({
-        start: getLineNumber(node.getStart(sourceFile)),
-        end: getLineNumber(node.getEnd())
-      });
+      importLines.push({ start: getLineNumber(node.getStart(sourceFile)), end: getLineNumber(node.getEnd()) });
       return;
     }
     if (ts.isFunctionDeclaration(node)) {
-      chunks.push({
-        kind: "function",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "function", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isClassDeclaration(node)) {
-      chunks.push({
-        kind: "class",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
-      return;
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
-      return;
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "class", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
-    if (ts.isEnumDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+      chunks.push({ kind: "type", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isVariableStatement(node)) {
-      const decls = node.declarationList.declarations;
-      const isFnLike = decls.some(
-        (d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
-      );
-      chunks.push({
-        kind: isFnLike ? "function" : "variable",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      const isFnLike = node.declarationList.declarations.some((d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)));
+      chunks.push({ kind: isFnLike ? "function" : "variable", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isExportAssignment(node)) {
-      chunks.push({
-        kind: "export",
-        name: "default export",
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "export", name: "default export", text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isExpressionStatement(node)) {
       const text3 = getNodeText(node);
-      if (text3.length > 10) {
-        chunks.push({
-          kind: "other",
-          name: text3.slice(0, 40).replace(/\n/g, " "),
-          text: text3,
-          startLine: getLineNumber(node.getStart(sourceFile)),
-          endLine: getLineNumber(node.getEnd())
-        });
-      }
-      return;
+      if (text3.length > 10) chunks.push({ kind: "other", name: text3.slice(0, 40).replace(/\n/g, " "), text: text3, startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()) });
     }
   }
   sourceFile.statements.forEach(visitTopLevel);
   if (importLines.length > 0) {
     const startLine = importLines[0].start;
     const endLine = importLines[importLines.length - 1].end;
-    const importText = lines.slice(startLine - 1, endLine).join("\n");
-    chunks.unshift({
-      kind: "import",
-      name: `${importLines.length} imports`,
-      text: importText,
-      startLine,
+    chunks.unshift({ kind: "import", name: `${importLines.length} imports`, text: lines.slice(startLine - 1, endLine).join("\n"), startLine, endLine });
+  }
+  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks.length > 0 ? chunks : chunkByWindows(source, 80);
+}
+function chunkGenericSource(source, _fileName, language) {
+  const lines = source.split("\n");
+  if (source.trim().length === 0) return [];
+  if (language && TEXT_LIKE_LANGUAGES.has(language)) return chunkTextLike(lines, language);
+  const chunks = [];
+  const patterns = [
+    { kind: "function", regex: /^\s*(?:async\s+)?def\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*class\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:pub\s+)?fn\s+([A-Za-z_][\w]*)\s*[<(]/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:public|private|protected|static|final|suspend|fun|override|open|internal|export|async|func|function|subroutine)\s+.*?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*function\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "type", regex: /^\s*(?:interface|type|enum|record|data\s+class|case\s+class|contract|library)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "section", regex: /^\s{0,3}#{1,6}\s+(.+)$/, name: (m) => m[1].trim() }
+  ];
+  const starts = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern.regex);
+      if (match) {
+        starts.push({ line: i + 1, kind: pattern.kind, name: pattern.name(match) });
+        break;
+      }
+    }
+  }
+  if (starts.length === 0) return chunkByWindows(source, 80);
+  for (let i = 0; i < starts.length; i++) {
+    const start = starts[i];
+    const next = starts[i + 1]?.line ?? lines.length + 1;
+    const endLine = Math.max(start.line, next - 1);
+    chunks.push({
+      kind: start.kind,
+      name: start.name,
+      text: lines.slice(start.line - 1, endLine).join("\n"),
+      startLine: start.line,
       endLine
     });
   }
-  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks;
+}
+function chunkTextLike(lines, language) {
+  if (language === "markdown" || language === "mdx") {
+    const starts = lines.map((line, i) => ({ line, i })).filter(({ line }) => /^\s{0,3}#{1,6}\s+/.test(line));
+    if (starts.length > 0) {
+      return starts.map((start, idx) => {
+        const end = starts[idx + 1]?.i ?? lines.length;
+        const title = start.line.replace(/^\s{0,3}#{1,6}\s+/, "").trim();
+        return { kind: "section", name: title, text: lines.slice(start.i, end).join("\n"), startLine: start.i + 1, endLine: end };
+      });
+    }
+  }
+  return chunkByWindows(lines.join("\n"), 80);
+}
+function chunkByWindows(source, windowLines) {
+  const lines = source.split("\n");
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += windowLines) {
+    const end = Math.min(lines.length, i + windowLines);
+    const text3 = lines.slice(i, end).join("\n");
+    if (text3.trim()) chunks.push({ kind: "other", name: `lines ${i + 1}-${end}`, text: text3, startLine: i + 1, endLine: end });
+  }
   return chunks;
 }
 function summarizeChunk(chunk, filePath) {
@@ -18515,13 +18556,14 @@ function summarizeChunk(chunk, filePath) {
       return `Variable ${chunk.name} in ${location}`;
     case "export":
       return `Default export in ${location}`;
+    case "section":
+      return `Section ${chunk.name} in ${location}`;
     default:
       return `${chunk.kind} in ${location}`;
   }
 }
 function isChunkable(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  return ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx";
+  return Boolean(languageForFile(filePath));
 }
 
 // src/lib/graph-rag.ts
@@ -26962,12 +27004,11 @@ import { z as z88 } from "zod";
 init_config();
 import crypto19 from "crypto";
 import path50 from "path";
-import { existsSync as existsSync39, mkdirSync as mkdirSync21, readFileSync as readFileSync32, statSync as statSync9, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync21, readFileSync as readFileSync32, readdirSync as readdirSync14, statSync as statSync9, writeFileSync as writeFileSync23 } from "fs";
 import { spawnSync } from "child_process";
-var INDEX_VERSION = 1;
-var DEFAULT_MAX_FILES = 2e3;
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-var IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build"]);
+var INDEX_VERSION = 2;
+var DEFAULT_MAX_FILES = 5e3;
+var IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build", "target", "vendor"]);
 function normalizeProjectRoot(projectRoot) {
   return path50.resolve(projectRoot || process.cwd());
 }
@@ -26985,78 +27026,53 @@ function getCodeContextIndexPath(projectRoot) {
   return path50.join(indexDir(), `${rootHash}.json`);
 }
 function currentBranch(projectRoot) {
-  const result2 = spawnSync("git", ["branch", "--show-current"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 2e3
-  });
+  const result2 = spawnSync("git", ["branch", "--show-current"], { cwd: projectRoot, encoding: "utf8", timeout: 2e3 });
   const branch = result2.status === 0 ? result2.stdout.trim() : "";
   return branch || "detached-or-unknown";
 }
 function shouldIgnore(relPath) {
-  const parts = relPath.split(path50.sep);
+  const parts = relPath.split(/[\\/]/);
   return parts.some((part) => IGNORE_SEGMENTS.has(part));
 }
-function isCodeFile(relPath) {
-  return CODE_EXTENSIONS.has(path50.extname(relPath).toLowerCase());
+function listRecursive(projectRoot, dir = projectRoot, out = []) {
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
+    const abs = path50.join(dir, entry.name);
+    const rel = path50.relative(projectRoot, abs).replaceAll(path50.sep, "/");
+    if (shouldIgnore(rel)) continue;
+    if (entry.isDirectory()) listRecursive(projectRoot, abs, out);
+    else if (entry.isFile()) out.push(rel);
+  }
+  return out;
 }
 function listCodeFiles(projectRoot, maxFiles) {
-  const git = spawnSync("git", ["ls-files", "*.ts", "*.tsx", "*.js", "*.jsx"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 5e3,
-    maxBuffer: 1024 * 1024 * 8
-  });
+  const git = spawnSync("git", ["ls-files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
   let files = [];
   if (git.status === 0 && git.stdout.trim()) {
     files = git.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
   } else {
-    const rg = spawnSync("rg", ["--files", "-g", "*.ts", "-g", "*.tsx", "-g", "*.js", "-g", "*.jsx"], {
-      cwd: projectRoot,
-      encoding: "utf8",
-      timeout: 5e3,
-      maxBuffer: 1024 * 1024 * 8
-    });
-    if (rg.status === 0 && rg.stdout.trim()) {
-      files = rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-    }
+    const rg = spawnSync("rg", ["--files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
+    files = rg.status === 0 && rg.stdout.trim() ? rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : listRecursive(projectRoot);
   }
-  return files.filter((file) => isCodeFile(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
+  return files.map((file) => file.replaceAll(path50.sep, "/")).filter((file) => isChunkable(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
 }
 function parseImportPaths(importText) {
   const paths = [];
-  const fromRegex = /from\s+["']([^"']+)["']/g;
-  let match;
-  while ((match = fromRegex.exec(importText)) !== null) paths.push(match[1]);
-  const bareRegex = /^import\s+["']([^"']+)["']/gm;
-  while ((match = bareRegex.exec(importText)) !== null) {
-    if (!paths.includes(match[1])) paths.push(match[1]);
-  }
-  const requireRegex = /require\(["']([^"']+)["']\)/g;
-  while ((match = requireRegex.exec(importText)) !== null) {
-    if (!paths.includes(match[1])) paths.push(match[1]);
+  const patterns = [/from\s+["']([^"']+)["']/g, /^import\s+["']([^"']+)["']/gm, /require\(["']([^"']+)["']\)/g, /use\s+([A-Za-z0-9_:]+)::/g, /#include\s+[<"]([^>"]+)[>"]/g];
+  for (const regex of patterns) {
+    let match;
+    while ((match = regex.exec(importText)) !== null) if (!paths.includes(match[1])) paths.push(match[1]);
   }
   return paths;
 }
 function resolveImport(fromFile, importPath, allFiles) {
   if (!importPath.startsWith(".")) return null;
   const base = path50.posix.normalize(path50.posix.join(path50.posix.dirname(fromFile.replaceAll(path50.sep, "/")), importPath));
-  const withoutKnownExt = base.replace(/\.(?:js|jsx|ts|tsx)$/, "");
-  const candidates = [
-    base,
-    `${withoutKnownExt}.ts`,
-    `${withoutKnownExt}.tsx`,
-    `${withoutKnownExt}.js`,
-    `${withoutKnownExt}.jsx`,
-    `${base}.ts`,
-    `${base}.tsx`,
-    `${base}.js`,
-    `${base}.jsx`,
-    path50.posix.join(base, "index.ts"),
-    path50.posix.join(base, "index.tsx"),
-    path50.posix.join(base, "index.js"),
-    path50.posix.join(base, "index.jsx")
-  ];
+  const withoutKnownExt = base.replace(/\.(?:[a-z0-9]+)$/i, "");
+  const candidates = [base];
+  for (const ext of ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"]) {
+    candidates.push(`${withoutKnownExt}.${ext}`, `${base}.${ext}`);
+  }
+  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path50.posix.join(base, indexName));
   return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
 }
 function symbolId(filePath, chunk) {
@@ -27082,39 +27098,32 @@ function buildFileRecord(projectRoot, relPath, allFiles, previous) {
   try {
     stat = statSync9(absPath);
   } catch {
-    return null;
+    return { record: null, reused: false };
   }
-  if (!stat.isFile()) return null;
+  if (!stat.isFile()) return { record: null, reused: false };
+  const language = languageForFile(relPath);
+  if (!language || !isChunkable(relPath)) return { record: null, reused: false };
   const source = readFileSync32(absPath, "utf8");
   const hash = hashText(source);
-  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
-    return previous;
+  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size && previous.language === language) {
+    return { record: previous, reused: true };
   }
-  if (!isChunkable(relPath)) return null;
   const chunks = chunkSourceFile(source, relPath);
   const imports = chunks.filter((chunk) => chunk.kind === "import").flatMap((chunk) => parseImportPaths(chunk.text));
   const resolvedImports = imports.map((importPath) => resolveImport(relPath, importPath, allFiles)).filter((file) => Boolean(file));
-  const symbols = chunks.filter((chunk) => chunk.kind !== "import" && chunk.name !== "(unknown)").map((chunk) => ({
+  const symbols = chunks.filter((chunk) => chunk.name !== "(unknown)").map((chunk) => ({
     id: symbolId(relPath, chunk),
     name: chunk.name,
     kind: chunk.kind,
     filePath: relPath,
+    language,
     startLine: chunk.startLine,
     endLine: chunk.endLine,
     summary: summarizeChunk(chunk, relPath),
-    text: chunk.text.slice(0, 6e3),
+    text: chunk.text.slice(0, 8e3),
     comment: chunk.comment
   }));
-  return {
-    path: relPath,
-    absPath,
-    hash,
-    mtimeMs: stat.mtimeMs,
-    size: stat.size,
-    imports,
-    resolvedImports,
-    symbols
-  };
+  return { record: { path: relPath, absPath, language, hash, mtimeMs: stat.mtimeMs, size: stat.size, imports, resolvedImports, symbols }, reused: false };
 }
 function buildCodeContextIndex(options = {}) {
   const projectRoot = normalizeProjectRoot(options.projectRoot);
@@ -27124,17 +27133,27 @@ function buildCodeContextIndex(options = {}) {
   const files = listCodeFiles(projectRoot, maxFiles);
   const allFiles = new Set(files.map((file) => file.replaceAll(path50.sep, "/")));
   const fileRecords = {};
+  let rebuiltFiles = 0;
+  let reusedFiles = 0;
+  let skippedFiles = 0;
   for (const rel of files) {
     const normalized = rel.replaceAll(path50.sep, "/");
-    const record = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
-    if (record) fileRecords[normalized] = record;
-  }
+    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    if (record) {
+      fileRecords[normalized] = record;
+      if (reused) reusedFiles++;
+      else rebuiltFiles++;
+    } else skippedFiles++;
+  }
+  const languageBreakdown = {};
+  for (const file of Object.values(fileRecords)) languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
   const index = {
     version: INDEX_VERSION,
     projectRoot,
     rootHash: hashText(projectRoot).slice(0, 16),
     branch,
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: { filesSeen: files.length, filesIndexed: Object.keys(fileRecords).length, rebuiltFiles, reusedFiles, skippedFiles, languageBreakdown },
     files: fileRecords
   };
   saveIndex(index);
@@ -27162,13 +27181,60 @@ function loadOrBuildCodeContextIndex(options = {}) {
   }
   return buildCodeContextIndex(options);
 }
+function normalizeLanguage(language) {
+  return language.toLowerCase().replace(/^c\+\+$/, "cpp").replace(/^c#$/, "csharp").replace(/^js$/, "javascript").replace(/^ts$/, "typescript");
+}
 function tokenize(query) {
-  return query.toLowerCase().split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+  const raw = query.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+  const expanded = /* @__PURE__ */ new Set();
+  for (const term of raw) {
+    expanded.add(term);
+    for (const part of term.split(/[_.$/-]+/)) if (part.length >= 2) expanded.add(part);
+    const dashed = term.replace(/[_.$/]+/g, "-");
+    if (dashed.length >= 2) expanded.add(dashed);
+    if (!term.includes("-")) expanded.add(`${term}s`);
+    if (term.endsWith("s") && term.length > 3) expanded.add(term.slice(0, -1));
+  }
+  return [...expanded];
+}
+function ngrams(terms) {
+  const grams = [...terms];
+  for (let i = 0; i < terms.length - 1; i++) grams.push(`${terms[i]} ${terms[i + 1]}`);
+  return grams;
+}
+function globToRegex(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    const next = pattern[i + 1];
+    if (ch === "*" && next === "*") {
+      out += ".*";
+      i++;
+      continue;
+    }
+    if (ch === "*") {
+      out += "[^/]*";
+      continue;
+    }
+    if (".+^${}()|[]\\".includes(ch)) out += `\\${ch}`;
+    else out += ch;
+  }
+  return new RegExp(`^${out}$`);
+}
+function matchesPath(filePath, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  const normalized = filePath.replaceAll(path50.sep, "/");
+  return patterns.some((pattern) => {
+    const p = pattern.replaceAll(path50.sep, "/").replace(/^\.\//, "");
+    return normalized === p || normalized.startsWith(`${p}/`) || normalized.endsWith(p) || globToRegex(p).test(normalized);
+  });
 }
 function scoreSymbol(symbol, terms) {
+  const grams = ngrams(terms);
   const haystacks = {
     name: symbol.name.toLowerCase(),
     path: symbol.filePath.toLowerCase(),
+    language: symbol.language.toLowerCase(),
     summary: symbol.summary.toLowerCase(),
     text: symbol.text.toLowerCase()
   };
@@ -27176,41 +27242,73 @@ function scoreSymbol(symbol, terms) {
   const matches = [];
   for (const term of terms) {
     if (haystacks.name === term) {
-      score += 80;
+      score += 100;
       matches.push(`name=${term}`);
       continue;
     }
     if (haystacks.name.includes(term)) {
-      score += 40;
+      score += 45;
       matches.push(`name~${term}`);
     }
     if (haystacks.path.includes(term)) {
-      score += 15;
+      score += 18;
       matches.push(`path~${term}`);
     }
+    if (haystacks.language === term) {
+      score += 18;
+      matches.push(`language=${term}`);
+    }
     if (haystacks.summary.includes(term)) {
-      score += 12;
+      score += 16;
       matches.push(`summary~${term}`);
     }
     if (haystacks.text.includes(term)) {
-      score += 4;
+      score += 5;
       matches.push(`text~${term}`);
     }
   }
+  for (const gram of grams.filter((g) => g.includes(" "))) {
+    if (haystacks.text.includes(gram) || haystacks.summary.includes(gram)) {
+      score += 20;
+      matches.push(`phrase~${gram}`);
+    }
+  }
+  const uniqueMatches = new Set(matches.map((m) => m.replace(/^[^=~]+[=~]/, ""))).size;
+  score += uniqueMatches * 3;
   return { score, matches };
 }
+function filteredFiles(index, options = {}) {
+  const languages = options.languages?.map(normalizeLanguage).filter(Boolean);
+  return Object.values(index.files).filter((file) => {
+    if (languages && languages.length > 0 && !languages.includes(normalizeLanguage(file.language))) return false;
+    return matchesPath(file.path, options.paths);
+  });
+}
 function searchCodeContext(query, options = {}) {
   const terms = tokenize(query);
   if (terms.length === 0) return [];
-  const index = loadOrBuildCodeContextIndex(options);
+  const index = loadOrBuildCodeContextIndex({ projectRoot: options.projectRoot, force: options.force || options.refreshIndex, maxFiles: options.maxFiles });
   const results = [];
-  for (const file of Object.values(index.files)) {
+  for (const file of filteredFiles(index, options)) {
     for (const symbol of file.symbols) {
       const scored = scoreSymbol(symbol, terms);
-      if (scored.score > 0) results.push({ symbol, score: scored.score, matches: scored.matches });
+      if (scored.score > 0) {
+        results.push({
+          symbol,
+          score: scored.score,
+          matches: scored.matches,
+          filePath: symbol.filePath,
+          language: symbol.language,
+          content: symbol.text,
+          startLine: symbol.startLine,
+          endLine: symbol.endLine
+        });
+      }
     }
   }
-  return results.sort((a, b) => b.score - a.score || a.symbol.filePath.localeCompare(b.symbol.filePath)).slice(0, options.limit ?? 20);
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = options.limit ?? 20;
+  return results.sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath)).slice(offset, offset + limit);
 }
 function dependentsMap(index) {
   const map = /* @__PURE__ */ new Map();
@@ -27238,19 +27336,10 @@ function traceCodeSymbol(symbolName, options = {}) {
   const index = loadOrBuildCodeContextIndex(options);
   const matches = findSymbols(index, symbolName, options.limit ?? 20);
   const dependents = dependentsMap(index);
-  return {
-    query: symbolName,
-    matches,
-    definitions: matches.map((symbol) => {
-      const file = index.files[symbol.filePath];
-      return {
-        symbol,
-        imports: file.resolvedImports,
-        dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(),
-        relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20)
-      };
-    })
-  };
+  return { query: symbolName, matches, definitions: matches.map((symbol) => {
+    const file = index.files[symbol.filePath];
+    return { symbol, imports: file.resolvedImports, dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(), relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20) };
+  }) };
 }
 function resolveTargetFile(index, input) {
   if (input.filePath) {
@@ -27290,20 +27379,10 @@ function analyzeBlastRadius(input) {
     const lower = file.toLowerCase();
     return (lower.includes("test") || lower.includes("spec")) && (lower.includes(targetBase) || (symbolLower ? index.files[file].symbols.some((s) => s.text.toLowerCase().includes(symbolLower)) : false));
   });
-  for (const test of tests) {
-    if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
-  }
+  for (const test of tests) if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
   const impactedFiles = [...impacted.entries()].map(([filePath, value]) => ({ filePath, distance: value.distance, reason: value.reason })).sort((a, b) => a.distance - b.distance || a.filePath.localeCompare(b.filePath));
   const nonTestImpacted = impactedFiles.filter((f) => !f.filePath.match(/(test|spec)\./i)).length;
-  const riskLevel = nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low";
-  return {
-    target: target.target,
-    targetFile: target.filePath,
-    impactedFiles,
-    tests,
-    symbolsInTarget: index.files[target.filePath]?.symbols ?? [],
-    riskLevel
-  };
+  return { target: target.target, targetFile: target.filePath, impactedFiles, tests, symbolsInTarget: index.files[target.filePath]?.symbols ?? [], riskLevel: nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low" };
 }
 function getCodeContextStats(options = {}) {
   const index = loadOrBuildCodeContextIndex(options);
@@ -27311,9 +27390,14 @@ function getCodeContextStats(options = {}) {
     projectRoot: index.projectRoot,
     branch: index.branch,
     indexedAt: index.indexedAt,
+    indexAgeMs: Math.max(0, Date.now() - Date.parse(index.indexedAt)),
     files: Object.keys(index.files).length,
     symbols: Object.values(index.files).reduce((sum, file) => sum + file.symbols.length, 0),
     imports: Object.values(index.files).reduce((sum, file) => sum + file.resolvedImports.length, 0),
+    languageBreakdown: index.stats.languageBreakdown,
+    rebuiltFiles: index.stats.rebuiltFiles,
+    reusedFiles: index.stats.reusedFiles,
+    skippedFiles: index.stats.skippedFiles,
     indexPath: getCodeContextIndexPath(index.projectRoot)
   };
 }
@@ -27337,10 +27421,14 @@ function registerCodeContext(server2) {
       file_path: z88.string().optional().describe("File path for blast_radius"),
       force: z88.boolean().optional().describe("Force rebuild before answering"),
       limit: z88.coerce.number().int().min(1).max(100).optional().describe("Max results"),
+      offset: z88.coerce.number().int().min(0).optional().describe("Search pagination offset"),
+      refresh_index: z88.boolean().optional().describe("Refresh/rebuild index before searching"),
+      languages: z88.array(z88.string()).optional().describe('Language filters, e.g. ["python", "typescript"]'),
+      paths: z88.array(z88.string()).optional().describe("Path/glob filters"),
       depth: z88.coerce.number().int().min(1).max(5).optional().describe("Dependent traversal depth for blast_radius"),
       max_files: z88.coerce.number().int().min(1).max(1e4).optional().describe("Max code files to index")
     }
-  }, async ({ action, project_root, query, symbol, file_path, force, limit, depth, max_files }) => {
+  }, async ({ action, project_root, query, symbol, file_path, force, limit, offset, refresh_index, languages, paths, depth, max_files }) => {
     const opts = { projectRoot: project_root, force, maxFiles: max_files };
     if (action === "index") {
       const index = buildCodeContextIndex(opts);
@@ -27358,7 +27446,15 @@ function registerCodeContext(server2) {
     }
     if (action === "search") {
       if (!query) return errorResult10('code_context action "search" requires query');
-      return jsonResult({ query, results: searchCodeContext(query, { ...opts, limit }) });
+      return jsonResult({
+        query,
+        limit: limit ?? 20,
+        offset: offset ?? 0,
+        refresh_index: refresh_index ?? false,
+        languages: languages ?? [],
+        paths: paths ?? [],
+        results: searchCodeContext(query, { ...opts, limit, offset, refreshIndex: refresh_index, languages, paths })
+      });
     }
     if (action === "trace") {
       if (!symbol) return errorResult10('code_context action "trace" requires symbol');