cto-ai-cli 7.1.0 → 8.0.1

package/dist/mcp/index.js

@@ -9,6 +9,116 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/engine/synonyms.ts
+function buildBidirectionalIndex() {
+  for (const [canonical, synonyms] of Object.entries(SYNONYM_MAP)) {
+    if (!BIDIRECTIONAL_INDEX.has(canonical)) {
+      BIDIRECTIONAL_INDEX.set(canonical, /* @__PURE__ */ new Set());
+    }
+    const canonicalSet = BIDIRECTIONAL_INDEX.get(canonical);
+    for (const syn of synonyms) {
+      canonicalSet.add(syn);
+    }
+    canonicalSet.add(canonical);
+    for (const syn of synonyms) {
+      if (!BIDIRECTIONAL_INDEX.has(syn)) {
+        BIDIRECTIONAL_INDEX.set(syn, /* @__PURE__ */ new Set());
+      }
+      const synSet = BIDIRECTIONAL_INDEX.get(syn);
+      synSet.add(canonical);
+      for (const otherSyn of synonyms) {
+        if (otherSyn !== syn) synSet.add(otherSyn);
+      }
+    }
+  }
+}
+function expandTerm(term) {
+  const normalized = term.toLowerCase().trim();
+  const related = BIDIRECTIONAL_INDEX.get(normalized);
+  if (!related) return [normalized];
+  return [normalized, ...Array.from(related)];
+}
+var SYNONYM_MAP, BIDIRECTIONAL_INDEX;
+var init_synonyms = __esm({
+  "src/engine/synonyms.ts"() {
+    "use strict";
+    SYNONYM_MAP = {
+      // Authentication & Authorization
+      "auth": ["authentication", "authorize", "login", "signin", "session", "jwt", "token", "oauth", "sso", "identity", "credential"],
+      "permission": ["authorization", "access", "role", "acl", "rbac", "policy", "grant"],
+      // Database & Storage
+      "database": ["db", "repository", "store", "storage", "persistence", "orm", "sql", "query", "prisma", "sequelize", "typeorm", "mongo", "postgres", "mysql"],
+      "cache": ["redis", "memcached", "ttl", "invalidation", "memoize", "store"],
+      "migration": ["schema", "upgrade", "version", "evolution"],
+      // API & Networking
+      "api": ["endpoint", "route", "handler", "controller", "rest", "graphql", "rpc", "service"],
+      "request": ["req", "http", "call", "fetch", "axios"],
+      "response": ["res", "reply", "result", "output"],
+      "middleware": ["interceptor", "filter", "plugin", "hook"],
+      "gateway": ["proxy", "router", "load-balancer", "reverse-proxy"],
+      // Frontend & UI
+      "component": ["widget", "element", "view", "template"],
+      "state": ["store", "redux", "zustand", "context", "model"],
+      "render": ["paint", "draw", "display", "show"],
+      "style": ["css", "theme", "design", "layout", "tailwind"],
+      // Testing & Quality
+      "test": ["spec", "suite", "case", "assertion", "mock", "stub", "fixture", "vitest", "jest", "mocha"],
+      "validate": ["verify", "check", "assert", "ensure", "sanitize"],
+      "error": ["exception", "failure", "bug", "issue", "crash"],
+      // Performance & Optimization
+      "optimize": ["performance", "speed", "fast", "efficient", "improve", "enhance"],
+      "latency": ["delay", "lag", "slowness", "response-time"],
+      "throughput": ["capacity", "volume", "rate", "bandwidth"],
+      // Data & Collections
+      "dataset": ["data", "record", "row", "entry", "item", "collection"],
+      "empty": ["null", "blank", "missing", "absent", "none", "zero"],
+      // Data Processing
+      "parse": ["decode", "deserialize", "extract", "read"],
+      "serialize": ["encode", "stringify", "format", "marshal"],
+      "transform": ["map", "convert", "translate", "process"],
+      "filter": ["select", "where", "match", "find"],
+      // Configuration & Setup
+      "config": ["configuration", "setting", "option", "preference", "env", "environment"],
+      "init": ["initialize", "setup", "bootstrap", "start", "create"],
+      "deploy": ["deployment", "release", "publish", "ship", "launch"],
+      // Logging & Monitoring
+      "log": ["logger", "logging", "trace", "debug", "info", "warn", "error"],
+      "metric": ["measurement", "stat", "telemetry", "analytics", "tracking"],
+      "monitor": ["observe", "watch", "track", "alert"],
+      // Security
+      "secret": ["credential", "key", "password", "token", "apikey", "sensitive"],
+      "encrypt": ["cipher", "encode", "hash", "crypto"],
+      "sanitize": ["escape", "clean", "validate", "filter"],
+      // File System & I/O
+      "file": ["document", "asset", "resource", "path"],
+      "read": ["load", "fetch", "get", "retrieve"],
+      "write": ["save", "persist", "store", "put"],
+      "delete": ["remove", "unlink", "destroy", "drop"],
+      // Async & Concurrency
+      "async": ["asynchronous", "promise", "await", "concurrent", "parallel"],
+      "queue": ["buffer", "backlog", "pending", "deferred"],
+      "lock": ["mutex", "semaphore", "synchronize", "atomic"],
+      // Architecture & Patterns
+      "service": ["microservice", "api", "backend", "server", "daemon"],
+      "client": ["consumer", "frontend", "user", "caller"],
+      "event": ["message", "signal", "notification", "trigger"],
+      "stream": ["flow", "pipe", "channel", "observable"],
+      // Business Logic
+      "user": ["account", "profile", "member", "customer"],
+      "order": ["purchase", "transaction", "checkout", "cart"],
+      "payment": ["billing", "invoice", "charge", "stripe", "paypal"],
+      "notification": ["alert", "message", "email", "push", "sms"],
+      // DevOps & Infrastructure
+      "docker": ["container", "image", "dockerfile", "compose"],
+      "kubernetes": ["k8s", "cluster", "pod", "deployment", "helm"],
+      "ci": ["continuous-integration", "pipeline", "build", "github-actions", "jenkins"],
+      "cd": ["continuous-deployment", "release", "deploy", "rollout"]
+    };
+    BIDIRECTIONAL_INDEX = /* @__PURE__ */ new Map();
+    buildBidirectionalIndex();
+  }
+});
+
 // src/engine/tfidf.ts
 function buildIndex(files) {
   const documents = /* @__PURE__ */ new Map();
@@ -32,15 +142,29 @@ function buildIndex(files) {
   let totalLength = 0;
   for (const doc of documents.values()) totalLength += doc.length;
   const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
-  return { documents, idf, avgDocLength, totalDocs };
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
 }
-function query(index, taskDescription, maxResults = 50) {
+function query(index, taskDescription, maxResults = 50, expandSynonyms = true) {
   const queryTerms = tokenize(taskDescription);
   if (queryTerms.length === 0) return [];
   const querySet = /* @__PURE__ */ new Map();
   for (const term of queryTerms) {
     querySet.set(term, (querySet.get(term) ?? 0) + 1);
   }
+  if (expandSynonyms) {
+    const expandedSet = /* @__PURE__ */ new Map();
+    for (const [term, count] of querySet) {
+      const synonyms = expandTerm(term);
+      for (const syn of synonyms) {
+        const weight = syn === term ? count : count * 0.7;
+        expandedSet.set(syn, (expandedSet.get(syn) ?? 0) + weight);
+      }
+    }
+    querySet.clear();
+    for (const [term, weight] of expandedSet) {
+      querySet.set(term, weight);
+    }
+  }
   const results = [];
   const k1 = 1.5;
   const b = 0.75;
@@ -52,8 +176,11 @@ function query(index, taskDescription, maxResults = 50) {
       if (tf === 0) continue;
       const termIdf = index.idf.get(qTerm) ?? 0;
       if (termIdf <= 0) continue;
+      const df = index.docFreq.get(qTerm) ?? 0;
+      const dfRatio = index.totalDocs > 0 ? df / index.totalDocs : 0;
+      const domainDamp = dfRatio > 0.5 ? (1 - dfRatio) * (1 - dfRatio) : 1;
       const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / index.avgDocLength));
-      score += termIdf * tfNorm * qCount;
+      score += termIdf * tfNorm * qCount * domainDamp;
       matchedTerms.push(qTerm);
     }
     if (score > 0) {
@@ -116,32 +243,147 @@ function boostByPath(matches, allFiles, taskDescription) {
   for (const m of matches) {
     boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
   }
+  const pathTermDocFreq = /* @__PURE__ */ new Map();
+  const allPathTokenSets = /* @__PURE__ */ new Map();
   for (const filePath of allFiles) {
-    const pathTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
-    const pathMatches = pathTerms.filter((t) => queryTerms.has(t));
-    if (pathMatches.length > 0) {
+    const tokens = new Set(tokenize(filePath.replace(/[/\\.]/g, " ")));
+    allPathTokenSets.set(filePath, tokens);
+    for (const t of tokens) {
+      pathTermDocFreq.set(t, (pathTermDocFreq.get(t) ?? 0) + 1);
+    }
+  }
+  const N = allFiles.length;
+  function pathIdf(term) {
+    const df = pathTermDocFreq.get(term) ?? 0;
+    if (df === 0) return 0;
+    return Math.log((N + 1) / (df + 1));
+  }
+  for (const filePath of allFiles) {
+    const parts = filePath.replace(/\\/g, "/").split("/");
+    const fileName = parts.pop() ?? "";
+    const dirSegments = parts;
+    const dirTerms = tokenize(dirSegments.join(" ").replace(/[/\\.]/g, " "));
+    const fileTerms = tokenize(fileName.replace(/[.\-_]/g, " "));
+    const dirMatches = dirTerms.filter((t) => queryTerms.has(t));
+    const fileMatches = fileTerms.filter((t) => queryTerms.has(t));
+    const allPathMatches = [.../* @__PURE__ */ new Set([...dirMatches, ...fileMatches])];
+    if (allPathMatches.length > 0) {
+      const uniqueDirMatches = [...new Set(dirMatches)];
+      const uniqueFileMatches = [...new Set(fileMatches)].filter((t) => !uniqueDirMatches.includes(t));
+      const maxIdf = Math.log(N + 1);
+      let pathBoost = 0;
+      for (const t of uniqueDirMatches) {
+        pathBoost += 0.4 * (pathIdf(t) / maxIdf);
+      }
+      for (const t of uniqueFileMatches) {
+        pathBoost += 0.25 * (pathIdf(t) / maxIdf);
+      }
       const existing = boosted.get(filePath);
-      const pathBoost = pathMatches.length * 0.3;
       if (existing) {
-        existing.score = Math.min(1, existing.score + pathBoost);
-        for (const t of pathMatches) {
+        existing.score = existing.score + pathBoost;
+        for (const t of allPathMatches) {
           if (!existing.matchedTerms.includes(t)) existing.matchedTerms.push(t);
         }
       } else {
         boosted.set(filePath, {
           filePath,
-          score: Math.min(1, pathBoost),
-          matchedTerms: pathMatches
+          score: pathBoost,
+          matchedTerms: allPathMatches
         });
       }
     }
   }
   return [...boosted.values()].sort((a, b) => b.score - a.score);
 }
-var STOP_WORDS, TERM_FAMILIES;
+function boostByLayer(matches, allFiles, taskDescription) {
+  const queryTerms = tokenize(taskDescription);
+  const targetDirTerms = /* @__PURE__ */ new Set();
+  for (const term of queryTerms) {
+    const layers = LAYER_MAP[term];
+    if (layers) {
+      for (const l of layers) targetDirTerms.add(l);
+    }
+  }
+  if (targetDirTerms.size === 0) return matches;
+  const boosted = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+  }
+  for (const filePath of allFiles) {
+    const dirTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
+    const layerHits = dirTerms.filter((t) => targetDirTerms.has(t));
+    if (layerHits.length > 0) {
+      const layerBoost = Math.min(0.5, layerHits.length * 0.2);
+      const existing = boosted.get(filePath);
+      if (existing) {
+        existing.score = existing.score + layerBoost;
+      } else {
+        boosted.set(filePath, {
+          filePath,
+          score: layerBoost,
+          matchedTerms: [`[layer:${layerHits[0]}]`]
+        });
+      }
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+function boostByImports(matches, dependencies, topK = 10, boostFactor = 0.4) {
+  if (matches.length === 0 || dependencies.size === 0) return matches;
+  const boosted = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+  }
+  const reverseDeps = /* @__PURE__ */ new Map();
+  for (const [from, tos] of dependencies) {
+    for (const to of tos) {
+      const existing = reverseDeps.get(to) ?? [];
+      existing.push(from);
+      reverseDeps.set(to, existing);
+    }
+  }
+  const topMatches = matches.slice(0, topK);
+  const maxDepsPerParent = 5;
+  for (const parent of topMatches) {
+    const boost = parent.score * boostFactor;
+    const imports = dependencies.get(parent.filePath) ?? [];
+    const sortedImports = [...imports].sort((a, b) => {
+      const sa = boosted.get(a)?.score ?? 0;
+      const sb = boosted.get(b)?.score ?? 0;
+      return sb - sa;
+    });
+    for (const dep of sortedImports.slice(0, maxDepsPerParent)) {
+      applyImportBoost(boosted, dep, boost, parent.filePath, "imported-by");
+    }
+    const importers = reverseDeps.get(parent.filePath) ?? [];
+    const sortedImporters = [...importers].sort((a, b) => {
+      const sa = boosted.get(a)?.score ?? 0;
+      const sb = boosted.get(b)?.score ?? 0;
+      return sb - sa;
+    });
+    for (const imp of sortedImporters.slice(0, maxDepsPerParent)) {
+      applyImportBoost(boosted, imp, boost * 0.7, parent.filePath, "imports");
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+function applyImportBoost(boosted, filePath, boost, parentPath, relation) {
+  const existing = boosted.get(filePath);
+  if (existing) {
+    existing.score = existing.score + boost;
+  } else {
+    boosted.set(filePath, {
+      filePath,
+      score: boost,
+      matchedTerms: [`[${relation}:${parentPath.split("/").pop()}]`]
+    });
+  }
+}
+var STOP_WORDS, TERM_FAMILIES, LAYER_MAP;
 var init_tfidf = __esm({
   "src/engine/tfidf.ts"() {
     "use strict";
+    init_synonyms();
     STOP_WORDS = /* @__PURE__ */ new Set([
       // Language keywords
       "import",
@@ -285,6 +527,29 @@ var init_tfidf = __esm({
       ["encryp", "encrypt"],
       ["decryp", "encrypt"]
     ];
+    LAYER_MAP = {
+      // Query terms → directory segments that should be boosted
+      "endpoint": ["endpoint", "controller", "handler", "route", "router", "api", "rest"],
+      "api": ["endpoint", "controller", "handler", "route", "router", "api", "rest"],
+      "controller": ["endpoint", "controller", "handler", "route", "router"],
+      "repositori": ["repositori", "dao", "store", "persist"],
+      "databas": ["repositori", "dao", "store", "persist", "migrat"],
+      "storag": ["repositori", "dao", "store", "persist"],
+      "cach": ["cach", "redis", "memcach", "store"],
+      "servic": ["servic", "usecas", "core"],
+      "usecas": ["usecas", "servic", "core"],
+      "config": ["config", "inject", "setup", "bootstrap"],
+      "inject": ["config", "inject", "setup"],
+      "depend": ["config", "inject", "setup"],
+      "event": ["event", "listen", "handler", "subscrib"],
+      "error": ["error", "except", "handler", "fault"],
+      "except": ["except", "error", "handler", "fault"],
+      "model": ["model", "entiti", "dto", "domain", "schema"],
+      "entiti": ["entiti", "model", "dto", "domain"],
+      "metric": ["metric", "monitor", "observ", "telemetri"],
+      "test": ["test", "spec", "mock", "fixtur"],
+      "migrat": ["migrat", "schema", "databas"]
+    };
   }
 });
 
@@ -536,7 +801,19 @@ var DEFAULT_CONFIG = {
     },
     ignore: {
       dirs: ["node_modules", "dist", "build", ".git", "coverage", "__pycache__", ".next", "vendor", ".cto"],
-      patterns: ["*.min.js", "*.map", "*.lock", "*.generated.*"]
+      patterns: [
+        "*.min.js",
+        "*.map",
+        "*.lock",
+        "*.generated.*",
+        "CHANGELOG*",
+        "LICENSE*",
+        "CONTRIBUTING*",
+        "CODE_OF_CONDUCT*",
+        "AUTHORS*",
+        "CODEOWNERS",
+        "SECURITY*"
+      ]
     },
     maxDepth: 20
   },
@@ -1724,11 +2001,15 @@ function computeTypeProviderUsage(files, graph) {
 
 // src/engine/analyzer.ts
 function matchesPattern(filename, patterns) {
+  const lower = filename.toLowerCase();
   for (const pattern of patterns) {
     if (pattern.startsWith("*.")) {
       const ext = pattern.slice(1);
       if (filename.endsWith(ext)) return true;
-    } else if (filename === pattern) {
+    } else if (pattern.endsWith("*")) {
+      const prefix = pattern.slice(0, -1).toLowerCase();
+      if (lower.startsWith(prefix)) return true;
+    } else if (lower === pattern.toLowerCase()) {
       return true;
     }
   }
@@ -2874,17 +3155,19 @@ async function selectContext(input) {
   const selectedFiles = [];
   let usedTokens = 0;
   const hasSemanticSignal = semanticMap.size > 0;
+  const maxSemanticScore = hasSemanticSignal ? Math.max(...Array.from(semanticMap.values())) : 0;
+  const semanticFloor = maxSemanticScore * 0.1;
   for (const file of candidates) {
     const isTarget = targetSet.has(file.relativePath);
     const isMustInclude = mustInclude.has(file.relativePath);
     if (hasSemanticSignal && !isTarget && !isMustInclude) {
       const semScore = semanticMap.get(file.relativePath) ?? 0;
       const lrnBoost = learnerMap.get(file.relativePath) ?? 0;
-      if (semScore === 0 && lrnBoost === 0) {
+      if (semScore < semanticFloor && lrnBoost <= 0) {
         decisions.push({
           file: file.relativePath,
           action: "exclude",
-          reason: "Skipped: no semantic relevance to task"
+          reason: `Skipped: semantic score ${semScore.toFixed(3)} below floor ${semanticFloor.toFixed(3)}`
         });
         continue;
       }
@@ -3015,6 +3298,212 @@ function buildReason(file, level, isTarget, isMustInclude) {
 // src/engine/context-pipeline.ts
 init_tfidf();
 
+// src/engine/ast-tokenizer.ts
+init_tfidf();
+var ANNOTATION_LAYER_MAP = {
+  "repository": ["repositori", "dao", "store", "persist", "databas"],
+  "service": ["servic", "usecas", "busi", "logic"],
+  "controller": ["control", "endpoint", "api", "rest", "handler"],
+  "restcontroller": ["control", "endpoint", "api", "rest", "handler"],
+  "component": ["compon", "bean", "inject"],
+  "entity": ["entiti", "model", "domain", "persist"],
+  "configuration": ["config", "setup", "inject", "wire"],
+  "bean": ["config", "inject", "wire", "bean"],
+  "autowired": ["inject", "wire", "depend"],
+  "inject": ["inject", "wire", "depend"],
+  "provides": ["inject", "wire", "depend", "config"],
+  "singleton": ["singleton", "scope", "lifecycl"],
+  "test": ["test", "spec", "assert", "mock"],
+  "override": ["overrid", "inherit", "polymorph"],
+  "transactional": ["transact", "databas", "commit", "rollback"],
+  "cacheable": ["cach", "ttl", "evict", "invalidat"],
+  "async": ["async", "concurr", "thread", "parallel"],
+  "eventlistener": ["event", "listen", "handler", "subscrib"],
+  "scheduled": ["schedul", "cron", "timer", "job"],
+  "slf4j": ["log", "metric", "observ"],
+  "data": ["model", "entiti", "dto", "data"],
+  "getter": ["model", "entiti", "dto", "accessor"],
+  "setter": ["model", "entiti", "dto", "mutator"],
+  "builder": ["build", "pattern", "fluent"],
+  "value": ["model", "entiti", "dto", "immut"]
+};
+function extractStructuralTokens(content, filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  const language = detectLanguage2(ext);
+  switch (language) {
+    case "java":
+      return extractJava(content);
+    case "python":
+      return extractPython(content);
+    case "go":
+      return extractGo(content);
+    case "typescript":
+      return extractTypeScript(content);
+    default:
+      return { classNames: [], methodNames: [], annotations: [], parents: [], packageName: null, language: "unknown" };
+  }
+}
+function detectLanguage2(ext) {
+  switch (ext) {
+    case "java":
+      return "java";
+    case "py":
+      return "python";
+    case "go":
+      return "go";
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx":
+      return "typescript";
+    default:
+      return "unknown";
+  }
+}
+function extractJava(content) {
+  const classNames = [];
+  const methodNames = [];
+  const annotations = [];
+  const parents = [];
+  let packageName = null;
+  const pkgMatch = content.match(/^package\s+([\w.]+)\s*;/m);
+  if (pkgMatch) packageName = pkgMatch[1];
+  const annRegex = /@(\w+)/g;
+  let annMatch;
+  while ((annMatch = annRegex.exec(content)) !== null) {
+    const ann = annMatch[1].toLowerCase();
+    if (ann !== "override" && ann.length > 2) {
+      annotations.push(ann);
+    }
+  }
+  const classRegex = /(?:public|private|protected|abstract|final|static)?\s*(?:class|interface|enum)\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w\s,]+))?/g;
+  let classMatch;
+  while ((classMatch = classRegex.exec(content)) !== null) {
+    classNames.push(classMatch[1]);
+    if (classMatch[2]) parents.push(classMatch[2]);
+    if (classMatch[3]) {
+      for (const impl of classMatch[3].split(",")) {
+        const trimmed = impl.trim();
+        if (trimmed) parents.push(trimmed);
+      }
+    }
+  }
+  const methodRegex = /(?:public|private|protected|static|abstract|final|synchronized|default)\s+(?:<[\w\s,?]+>\s+)?(?:[\w<>\[\]?,\s]+)\s+(\w+)\s*\(/g;
+  let methodMatch;
+  while ((methodMatch = methodRegex.exec(content)) !== null) {
+    const name = methodMatch[1];
+    if (!["equals", "hashCode", "toString", "main", "get", "set"].includes(name)) {
+      methodNames.push(name);
+    }
+  }
+  return { classNames, methodNames, annotations, parents, packageName, language: "java" };
+}
+function extractPython(content) {
+  const classNames = [];
+  const methodNames = [];
+  const annotations = [];
+  const parents = [];
+  const classRegex = /^\s*class\s+(\w+)(?:\(([^)]+)\))?/gm;
+  let classMatch;
+  while ((classMatch = classRegex.exec(content)) !== null) {
+    classNames.push(classMatch[1]);
+    if (classMatch[2]) {
+      for (const parent of classMatch[2].split(",")) {
+        const trimmed = parent.trim().split("[")[0];
+        if (trimmed && trimmed !== "object") parents.push(trimmed);
+      }
+    }
+  }
+  const decRegex = /^\s*@(\w+)/gm;
+  let decMatch;
+  while ((decMatch = decRegex.exec(content)) !== null) {
+    annotations.push(decMatch[1].toLowerCase());
+  }
+  const funcRegex = /^\s*(?:async\s+)?def\s+(\w+)/gm;
+  let funcMatch;
+  while ((funcMatch = funcRegex.exec(content)) !== null) {
+    const name = funcMatch[1];
+    if (!name.startsWith("__") || name === "__init__") {
+      methodNames.push(name.replace(/^_+|_+$/g, ""));
+    }
+  }
+  return { classNames, methodNames, annotations, parents, packageName: null, language: "python" };
+}
+function extractGo(content) {
+  const classNames = [];
+  const methodNames = [];
+  const parents = [];
+  const pkgMatch = content.match(/^package\s+(\w+)/m);
+  const packageName = pkgMatch ? pkgMatch[1] : null;
+  const typeRegex = /type\s+(\w+)\s+(?:struct|interface)/g;
+  let typeMatch;
+  while ((typeMatch = typeRegex.exec(content)) !== null) {
+    classNames.push(typeMatch[1]);
+  }
+  const funcRegex = /func\s+(?:\(\w+\s+\*?(\w+)\)\s+)?(\w+)\s*\(/g;
+  let funcMatch;
+  while ((funcMatch = funcRegex.exec(content)) !== null) {
+    methodNames.push(funcMatch[2]);
+    if (funcMatch[1]) {
+      parents.push(funcMatch[1]);
+    }
+  }
+  return { classNames, methodNames, annotations: [], parents, packageName, language: "go" };
+}
+function extractTypeScript(content) {
+  const classNames = [];
+  const methodNames = [];
+  const annotations = [];
+  const parents = [];
+  const classRegex = /(?:export\s+)?(?:abstract\s+)?(?:class|interface)\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w\s,]+))?/g;
+  let classMatch;
+  while ((classMatch = classRegex.exec(content)) !== null) {
+    classNames.push(classMatch[1]);
+    if (classMatch[2]) parents.push(classMatch[2]);
+    if (classMatch[3]) {
+      for (const impl of classMatch[3].split(",")) {
+        const trimmed = impl.trim();
+        if (trimmed) parents.push(trimmed);
+      }
+    }
+  }
+  const decRegex = /@(\w+)/g;
+  let decMatch;
+  while ((decMatch = decRegex.exec(content)) !== null) {
+    annotations.push(decMatch[1].toLowerCase());
+  }
+  const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)/g;
+  let funcMatch;
+  while ((funcMatch = funcRegex.exec(content)) !== null) {
+    methodNames.push(funcMatch[1]);
+  }
+  return { classNames, methodNames, annotations, parents, packageName: null, language: "typescript" };
+}
+function augmentContentWithStructure(content, filePath) {
+  const struct = extractStructuralTokens(content, filePath);
+  const augmentParts = [];
+  for (const name of struct.classNames) {
+    const words = name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    augmentParts.push(words, words, words);
+  }
+  for (const name of struct.methodNames) {
+    const words = name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    augmentParts.push(words, words);
+  }
+  for (const parent of struct.parents) {
+    const words = parent.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    augmentParts.push(words);
+  }
+  for (const ann of struct.annotations) {
+    const layerTerms = ANNOTATION_LAYER_MAP[ann];
+    if (layerTerms) {
+      augmentParts.push(...layerTerms);
+    }
+  }
+  if (augmentParts.length === 0) return content;
+  return augmentParts.join(" ") + "\n" + content;
+}
+
 // src/engine/index-cache.ts
 init_tfidf();
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, statSync } from "fs";
@@ -3134,7 +3623,7 @@ function rebuildIndex(cachedFiles) {
   for (const [term, df] of docFreq) {
     idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
   }
-  return { documents, idf, avgDocLength, totalDocs };
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
 }
 
 // src/engine/reranker.ts
@@ -3371,10 +3860,1426 @@ function applyQualityGate(scored) {
   return { passed, filtered, threshold };
 }
 
+// src/engine/call-graph.ts
+function getLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (ext === "java") return "java";
+  if (["ts", "tsx", "js", "jsx", "mts", "mjs"].includes(ext)) return "ts";
+  if (ext === "py") return "python";
+  if (ext === "go") return "go";
+  return null;
+}
+function extractJavaDefinitions(content, filePath) {
+  const defs = [];
+  const classMatch = content.match(/(?:public|abstract)\s+(?:class|interface)\s+(\w+)/);
+  const className = classMatch?.[1];
+  const methodRegex = /(?:public|protected|private|static|\s)+\s+[\w<>\[\],\s?]+\s+(\w+)\s*\(/gm;
+  let match;
+  while ((match = methodRegex.exec(content)) !== null) {
+    const name = match[1];
+    if (name === className || name === "if" || name === "for" || name === "while" || name === "switch" || name === "catch" || name === "return") continue;
+    const linePrefix = content.substring(Math.max(0, match.index - 200), match.index);
+    const isPublic = /public\s/.test(match[0]);
+    defs.push({
+      name,
+      className,
+      filePath,
+      isExported: isPublic
+    });
+  }
+  return defs;
+}
+function extractTsDefinitions(content, filePath) {
+  const defs = [];
+  const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/gm;
+  let match;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const isExported = match[0].startsWith("export");
+    defs.push({ name: match[1], filePath, isExported });
+  }
+  const classRegex = /(?:export\s+)?class\s+(\w+)/gm;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const isExportedClass = match[0].startsWith("export");
+    const classStart = match.index + match[0].length;
+    const methodInClassRegex = /(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w[\w<>\[\]|,\s]*\s*)?{/gm;
+    methodInClassRegex.lastIndex = classStart;
+    let methodMatch;
+    while ((methodMatch = methodInClassRegex.exec(content)) !== null) {
+      const name = methodMatch[1];
+      if (name === "constructor" || name === "if" || name === "for" || name === "while" || name === "catch" || name === "return" || name === "function" || name === "class") continue;
+      defs.push({ name, className, filePath, isExported: isExportedClass });
+      if (methodMatch.index - classStart > 1e4) break;
+    }
+  }
+  const arrowRegex = /export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(/gm;
+  while ((match = arrowRegex.exec(content)) !== null) {
+    defs.push({ name: match[1], filePath, isExported: true });
+  }
+  return defs;
+}
+function extractPythonDefinitions(content, filePath) {
+  const defs = [];
+  const classRegex = /^class\s+(\w+)/gm;
+  let currentClass;
+  let match;
+  const funcRegex = /^(\s*)def\s+(\w+)\s*\(/gm;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const indent = match[1];
+    const name = match[2];
+    if (name.startsWith("_") && name !== "__init__") continue;
+    const before = content.substring(0, match.index);
+    const lastClass = before.match(/^class\s+(\w+)/gm);
+    const isMethod = indent.length > 0 && lastClass;
+    const className = isMethod ? lastClass[lastClass.length - 1].replace(/^class\s+/, "") : void 0;
+    defs.push({
+      name: name === "__init__" ? className ?? name : name,
+      className,
+      filePath,
+      isExported: !name.startsWith("_")
+    });
+  }
+  return defs;
+}
+function extractGoDefinitions(content, filePath) {
+  const defs = [];
+  const funcRegex = /^func\s+(\w+)\s*\(/gm;
+  let match;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const name = match[1];
+    defs.push({
+      name,
+      filePath,
+      isExported: name[0] === name[0].toUpperCase()
+    });
+  }
+  const methodRegex = /^func\s+\(\s*\w+\s+\*?(\w+)\s*\)\s+(\w+)\s*\(/gm;
+  while ((match = methodRegex.exec(content)) !== null) {
+    defs.push({
+      name: match[2],
+      className: match[1],
+      filePath,
+      isExported: match[2][0] === match[2][0].toUpperCase()
+    });
+  }
+  return defs;
+}
+function extractJavaCalls(content, filePath) {
+  const calls = [];
+  const callRegex = /(?<!\w)([a-z]\w+)\.([a-z]\w+)\s*\(/gm;
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const receiver = match[1];
+    const method = match[2];
+    if ([
+      "System",
+      "LOG",
+      "LOGGER",
+      "logger",
+      "log",
+      "this",
+      "super",
+      "String",
+      "Integer",
+      "Long",
+      "Boolean",
+      "Double",
+      "Float",
+      "Math",
+      "Arrays",
+      "Collections",
+      "Objects",
+      "Optional",
+      "List",
+      "Map",
+      "Set",
+      "Stream"
+    ].includes(receiver)) continue;
+    if ([
+      "toString",
+      "hashCode",
+      "equals",
+      "getClass",
+      "wait",
+      "notify",
+      "length",
+      "size",
+      "isEmpty",
+      "get",
+      "set",
+      "add",
+      "remove",
+      "contains",
+      "put",
+      "stream",
+      "map",
+      "filter",
+      "collect",
+      "orElse",
+      "orElseGet",
+      "orElseThrow",
+      "isPresent",
+      "ifPresent",
+      "of",
+      "valueOf",
+      "format",
+      "println",
+      "append",
+      "build",
+      "builder",
+      "thenReturn",
+      "when",
+      "verify",
+      "mock",
+      "given"
+    ].includes(method)) continue;
+    calls.push({ callerFile: filePath, receiverName: receiver, methodName: method });
+  }
+  const staticRegex = /(?<!\w)([A-Z]\w+)\.([a-z]\w+)\s*\(/gm;
+  while ((match = staticRegex.exec(content)) !== null) {
+    const receiver = match[1];
+    const method = match[2];
+    if ([
+      "System",
+      "Math",
+      "Arrays",
+      "Collections",
+      "Objects",
+      "Optional",
+      "String",
+      "Integer",
+      "Long",
+      "Boolean",
+      "Double",
+      "Float",
+      "LoggerFactory",
+      "Logger",
+      "Assert",
+      "Mockito",
+      "Assertions",
+      "ResponseEntity",
+      "HttpStatus"
+    ].includes(receiver)) continue;
+    if ([
+      "of",
+      "valueOf",
+      "format",
+      "parse",
+      "toString",
+      "getLogger",
+      "builder",
+      "newBuilder",
+      "create",
+      "getInstance"
+    ].includes(method)) continue;
+    calls.push({ callerFile: filePath, receiverName: receiver, methodName: method });
+  }
+  return calls;
+}
+function extractTsCalls(content, filePath) {
+  const calls = [];
+  const callRegex = /(?<!\w)([a-z]\w+)\.([a-z]\w+)\s*\(/gm;
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const receiver = match[1];
+    const method = match[2];
+    if ([
+      "console",
+      "process",
+      "Math",
+      "JSON",
+      "Promise",
+      "Object",
+      "Array",
+      "String",
+      "Number",
+      "Date",
+      "Error",
+      "RegExp",
+      "Buffer",
+      "this",
+      "super",
+      "window",
+      "document",
+      "expect",
+      "describe",
+      "it",
+      "test",
+      "vi",
+      "jest"
+    ].includes(receiver)) continue;
+    if ([
+      "toString",
+      "valueOf",
+      "hasOwnProperty",
+      "length",
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "slice",
+      "splice",
+      "map",
+      "filter",
+      "reduce",
+      "forEach",
+      "find",
+      "findIndex",
+      "some",
+      "every",
+      "includes",
+      "indexOf",
+      "join",
+      "split",
+      "replace",
+      "match",
+      "trim",
+      "toLowerCase",
+      "toUpperCase",
+      "startsWith",
+      "endsWith",
+      "keys",
+      "values",
+      "entries",
+      "has",
+      "get",
+      "set",
+      "delete",
+      "add",
+      "size",
+      "then",
+      "catch",
+      "finally",
+      "resolve",
+      "reject",
+      "stringify",
+      "parse",
+      "log",
+      "warn",
+      "error",
+      "info",
+      "debug"
+    ].includes(method)) continue;
+    calls.push({ callerFile: filePath, receiverName: receiver, methodName: method });
+  }
+  return calls;
+}
+function extractPythonCalls(content, filePath) {
+  const calls = [];
+  const callRegex = /(?<!\w)(?:self\.)?([a-z_]\w+)\.([a-z_]\w+)\s*\(/gm;
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const receiver = match[1];
+    const method = match[2];
+    if ([
+      "self",
+      "cls",
+      "os",
+      "sys",
+      "json",
+      "logging",
+      "print",
+      "str",
+      "int",
+      "float",
+      "list",
+      "dict",
+      "set",
+      "tuple",
+      "super",
+      "type",
+      "isinstance",
+      "len",
+      "range",
+      "enumerate"
+    ].includes(receiver)) continue;
+    if ([
+      "append",
+      "extend",
+      "insert",
+      "remove",
+      "pop",
+      "clear",
+      "get",
+      "keys",
+      "values",
+      "items",
+      "update",
+      "format",
+      "join",
+      "split",
+      "strip",
+      "replace",
+      "lower",
+      "upper",
+      "startswith",
+      "endswith",
+      "encode",
+      "decode"
+    ].includes(method)) continue;
+    calls.push({ callerFile: filePath, receiverName: receiver, methodName: method });
+  }
+  return calls;
+}
+function extractGoCalls(content, filePath) {
+  const calls = [];
+  const callRegex = /(?<!\w)([a-z]\w+)\.([A-Z]\w+)\s*\(/gm;
+  let match;
+  while ((match = callRegex.exec(content)) !== null) {
+    const receiver = match[1];
+    const method = match[2];
+    if ([
+      "fmt",
+      "log",
+      "os",
+      "io",
+      "strings",
+      "strconv",
+      "bytes",
+      "context",
+      "errors",
+      "sync",
+      "time",
+      "math",
+      "sort",
+      "http",
+      "json",
+      "testing",
+      "reflect"
+    ].includes(receiver)) continue;
+    calls.push({ callerFile: filePath, receiverName: receiver, methodName: method });
+  }
+  return calls;
+}
+function buildJavaImportMap(content, allFiles) {
+  const importMap = /* @__PURE__ */ new Map();
+  const importRegex = /^import\s+(?:static\s+)?[\w.]+\.(\w+)\s*;/gm;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const className = match[1];
+    const targetFile = allFiles.find((f) => {
+      const basename4 = f.split("/").pop()?.replace(".java", "") ?? "";
+      return basename4 === className;
+    });
+    if (targetFile) {
+      importMap.set(className, targetFile);
+      const varName = className.charAt(0).toLowerCase() + className.slice(1);
+      importMap.set(varName, targetFile);
+    }
+  }
+  const fieldRegex = /(?:private|protected)\s+(?:final\s+)?(\w+)\s+(\w+)\s*[;=]/gm;
+  while ((match = fieldRegex.exec(content)) !== null) {
+    const typeName = match[1];
+    const fieldName = match[2];
+    const existing = importMap.get(typeName);
+    if (existing) {
+      importMap.set(fieldName, existing);
+    }
+  }
+  return importMap;
+}
+function buildTsImportMap(content, allFiles) {
+  const importMap = /* @__PURE__ */ new Map();
+  const importRegex = /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/gm;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const namedImports = match[1];
+    const defaultImport = match[2];
+    const modulePath = match[3];
+    const targetFile = allFiles.find((f) => {
+      const stripped = f.replace(/\.(ts|tsx|js|jsx|mts|mjs)$/, "");
+      return stripped.endsWith(modulePath.replace(/^\.\//, "").replace(/^\.\.\//, "")) || f.endsWith(modulePath.replace(/^\.\//, "") + "/index.ts");
+    });
+    if (targetFile) {
+      if (namedImports) {
+        for (const name of namedImports.split(",").map((s) => s.trim())) {
+          const cleanName = name.split(" as ").pop()?.trim() ?? name.trim();
+          if (cleanName) importMap.set(cleanName, targetFile);
+        }
+      }
+      if (defaultImport) {
+        importMap.set(defaultImport, targetFile);
+      }
+    }
+  }
+  return importMap;
+}
+function buildPythonImportMap(content, allFiles) {
+  const importMap = /* @__PURE__ */ new Map();
+  const fromRegex = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+  let match;
+  while ((match = fromRegex.exec(content)) !== null) {
+    const modulePath = match[1].replace(/\./g, "/");
+    const names = match[2].split(",").map((s) => s.trim().split(" as ").pop()?.trim() ?? "");
+    const targetFile = allFiles.find((f) => f.includes(modulePath + ".py") || f.includes(modulePath + "/__init__.py"));
+    if (targetFile) {
+      for (const name of names) {
+        if (name) importMap.set(name, targetFile);
+        const snakeName = name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+        if (snakeName !== name) importMap.set(snakeName, targetFile);
+      }
+    }
+  }
+  return importMap;
+}
+function buildCallGraph(files) {
+  const allPaths = files.map((f) => f.relativePath);
+  const allDefinitions = [];
+  const allCalls = [];
+  for (const file of files) {
+    const lang = getLanguage(file.relativePath);
+    if (!lang) continue;
+    let defs;
+    let calls;
+    switch (lang) {
+      case "java":
+        defs = extractJavaDefinitions(file.content, file.relativePath);
+        calls = extractJavaCalls(file.content, file.relativePath);
+        break;
+      case "ts":
+        defs = extractTsDefinitions(file.content, file.relativePath);
+        calls = extractTsCalls(file.content, file.relativePath);
+        break;
+      case "python":
+        defs = extractPythonDefinitions(file.content, file.relativePath);
+        calls = extractPythonCalls(file.content, file.relativePath);
+        break;
+      case "go":
+        defs = extractGoDefinitions(file.content, file.relativePath);
+        calls = extractGoCalls(file.content, file.relativePath);
+        break;
+    }
+    allDefinitions.push(...defs);
+    allCalls.push(...calls);
+  }
+  const defByMethod = /* @__PURE__ */ new Map();
+  for (const def of allDefinitions) {
+    const existing = defByMethod.get(def.name) ?? [];
+    existing.push(def);
+    defByMethod.set(def.name, existing);
+  }
+  const defByQualified = /* @__PURE__ */ new Map();
+  for (const def of allDefinitions) {
+    if (def.className) {
+      defByQualified.set(`${def.className}.${def.name}`, def);
+    }
+  }
+  const edges = [];
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const lang = getLanguage(file.relativePath);
+    if (!lang) continue;
+    let importMap;
+    switch (lang) {
+      case "java":
+        importMap = buildJavaImportMap(file.content, allPaths);
+        break;
+      case "ts":
+        importMap = buildTsImportMap(file.content, allPaths);
+        break;
+      case "python":
+        importMap = buildPythonImportMap(file.content, allPaths);
+        break;
+      default:
+        importMap = /* @__PURE__ */ new Map();
+    }
+    const fileCalls = allCalls.filter((c) => c.callerFile === file.relativePath);
+    for (const call of fileCalls) {
+      let targetFile;
+      targetFile = importMap.get(call.receiverName);
+      if (!targetFile) {
+        const qualDef = defByQualified.get(`${call.receiverName}.${call.methodName}`);
+        if (qualDef) targetFile = qualDef.filePath;
+      }
+      if (!targetFile) {
+        const capitalized = call.receiverName.charAt(0).toUpperCase() + call.receiverName.slice(1);
+        targetFile = importMap.get(capitalized);
+      }
+      if (!targetFile) {
+        const candidates = defByMethod.get(call.methodName);
+        if (candidates && candidates.length === 1 && candidates[0].filePath !== file.relativePath) {
+          targetFile = candidates[0].filePath;
+        }
+      }
+      if (targetFile && targetFile !== file.relativePath) {
+        const key = `${file.relativePath}\u2192${targetFile}`;
+        if (!edgeSet.has(key)) {
+          edgeSet.add(key);
+          edges.push({ from: file.relativePath, to: targetFile, type: "call" });
+        }
+      }
+    }
+  }
+  return { definitions: allDefinitions, calls: allCalls, edges };
+}
+function boostByCallGraph(matches, callEdges, topK = 10, boostFactor = 0.3) {
+  if (matches.length === 0 || callEdges.length === 0) return matches;
+  const boosted = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+  }
+  const callsTo = /* @__PURE__ */ new Map();
+  const calledBy = /* @__PURE__ */ new Map();
+  for (const edge of callEdges) {
+    if (edge.type !== "call") continue;
+    const fwd = callsTo.get(edge.from) ?? [];
+    fwd.push(edge.to);
+    callsTo.set(edge.from, fwd);
+    const rev = calledBy.get(edge.to) ?? [];
+    rev.push(edge.from);
+    calledBy.set(edge.to, rev);
+  }
+  const topMatches = matches.slice(0, topK);
+  const maxBoostPerParent = 5;
+  for (const parent of topMatches) {
+    const boost = parent.score * boostFactor;
+    const called = callsTo.get(parent.filePath) ?? [];
+    for (const target of called.slice(0, maxBoostPerParent)) {
+      const existing = boosted.get(target);
+      if (existing) {
+        existing.score += boost;
+        if (!existing.matchedTerms.includes("[call-graph:called-by-match]")) {
+          existing.matchedTerms.push("[call-graph:called-by-match]");
+        }
+      } else {
+        boosted.set(target, {
+          filePath: target,
+          score: boost,
+          matchedTerms: ["[call-graph:called-by-match]"]
+        });
+      }
+    }
+    const callers = calledBy.get(parent.filePath) ?? [];
+    for (const caller of callers.slice(0, maxBoostPerParent)) {
+      const callerBoost = boost * 0.7;
+      const existing = boosted.get(caller);
+      if (existing) {
+        existing.score += callerBoost;
+        if (!existing.matchedTerms.includes("[call-graph:calls-match]")) {
+          existing.matchedTerms.push("[call-graph:calls-match]");
+        }
+      } else {
+        boosted.set(caller, {
+          filePath: caller,
+          score: callerBoost,
+          matchedTerms: ["[call-graph:calls-match]"]
+        });
+      }
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+
+// src/engine/git-relevance.ts
+import { execSync } from "child_process";
+function buildCoChangeMatrix(projectPath, maxCommits = 500, minCoChanges = 2) {
+  const emptyMatrix = {
+    entries: /* @__PURE__ */ new Map(),
+    fileCommitCounts: /* @__PURE__ */ new Map(),
+    totalCommits: 0
+  };
+  let gitOutput;
+  try {
+    gitOutput = execSync(
+      `git log --no-merges --diff-filter=ACMR --name-only --format="---COMMIT---" -n ${maxCommits}`,
+      { cwd: projectPath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, timeout: 15e3 }
+    );
+  } catch {
+    return emptyMatrix;
+  }
+  const commits = [];
+  let currentFiles = [];
+  for (const line of gitOutput.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "---COMMIT---") {
+      if (currentFiles.length > 0) {
+        commits.push(currentFiles);
+      }
+      currentFiles = [];
+    } else if (trimmed.length > 0) {
+      currentFiles.push(trimmed);
+    }
+  }
+  if (currentFiles.length > 0) {
+    commits.push(currentFiles);
+  }
+  if (commits.length === 0) return emptyMatrix;
+  const fileCommitCounts = /* @__PURE__ */ new Map();
+  const coChangeCounts = /* @__PURE__ */ new Map();
+  for (const files of commits) {
+    const unique = [...new Set(files)];
+    for (const file of unique) {
+      fileCommitCounts.set(file, (fileCommitCounts.get(file) ?? 0) + 1);
+    }
+    const capped = unique.slice(0, 20);
+    for (let i = 0; i < capped.length; i++) {
+      for (let j = i + 1; j < capped.length; j++) {
+        const [a, b] = capped[i] < capped[j] ? [capped[i], capped[j]] : [capped[j], capped[i]];
+        const key = `${a}\0${b}`;
+        coChangeCounts.set(key, (coChangeCounts.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const [key, coCommits] of coChangeCounts) {
+    if (coCommits < minCoChanges) continue;
+    const [fileA, fileB] = key.split("\0");
+    const commitsA = fileCommitCounts.get(fileA) ?? 0;
+    const commitsB = fileCommitCounts.get(fileB) ?? 0;
+    const union = commitsA + commitsB - coCommits;
+    const similarity = union > 0 ? coCommits / union : 0;
+    const entry = { fileA, fileB, coCommits, similarity };
+    const listA = entries.get(fileA) ?? [];
+    listA.push(entry);
+    entries.set(fileA, listA);
+    const listB = entries.get(fileB) ?? [];
+    listB.push({ ...entry, fileA: fileB, fileB: fileA });
+    entries.set(fileB, listB);
+  }
+  for (const [, list] of entries) {
+    list.sort((a, b) => b.similarity - a.similarity);
+  }
+  return { entries, fileCommitCounts, totalCommits: commits.length };
+}
+function boostByGitCoChange(matches, coChangeMatrix, topK = 10, boostFactor = 0.25, minSimilarity = 0.15) {
+  if (matches.length === 0 || coChangeMatrix.entries.size === 0) return matches;
+  const boosted = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+  }
+  const topMatches = matches.slice(0, topK);
+  const maxBoostTargets = 5;
+  for (const parent of topMatches) {
+    const partners = coChangeMatrix.entries.get(parent.filePath) ?? [];
+    let boostedCount = 0;
+    for (const partner of partners) {
+      if (boostedCount >= maxBoostTargets) break;
+      if (partner.similarity < minSimilarity) break;
+      const boost = parent.score * boostFactor * partner.similarity;
+      const existing = boosted.get(partner.fileB);
+      if (existing) {
+        existing.score += boost;
+        if (!existing.matchedTerms.includes("[git-cochange]")) {
+          existing.matchedTerms.push("[git-cochange]");
+        }
+      } else {
+        boosted.set(partner.fileB, {
+          filePath: partner.fileB,
+          score: boost,
+          matchedTerms: ["[git-cochange]"]
+        });
+      }
+      boostedCount++;
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+
+// src/engine/multi-hop.ts
+init_tfidf();
+var DEFAULT_CONFIG2 = {
+  maxHops: 2,
+  topKPerHop: 5,
+  decayFactor: 0.5,
+  minScoreThreshold: 0.2
+};
+function multiHopQuery(index, task, deps, callEdges, fileContents, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const hops = [];
+  const callsTo = /* @__PURE__ */ new Map();
+  const calledBy = /* @__PURE__ */ new Map();
+  for (const edge of callEdges) {
+    const fwd = callsTo.get(edge.from) ?? /* @__PURE__ */ new Set();
+    fwd.add(edge.to);
+    callsTo.set(edge.from, fwd);
+    const rev = calledBy.get(edge.to) ?? /* @__PURE__ */ new Set();
+    rev.add(edge.from);
+    calledBy.set(edge.to, rev);
+  }
+  const aggregateScores = /* @__PURE__ */ new Map();
+  const aggregateTerms = /* @__PURE__ */ new Map();
+  const explored = /* @__PURE__ */ new Set();
+  const initialResults = query(index, task, 50);
+  for (const m of initialResults) {
+    aggregateScores.set(m.filePath, m.score);
+    aggregateTerms.set(m.filePath, new Set(m.matchedTerms));
+    explored.add(m.filePath);
+  }
+  hops.push({
+    hop: 0,
+    seedFiles: [],
+    newFiles: initialResults.slice(0, cfg.topKPerHop).map((m) => m.filePath),
+    expandedTerms: tokenize(task)
+  });
+  let currentSeeds = initialResults.slice(0, cfg.topKPerHop);
+  for (let hop = 1; hop <= cfg.maxHops; hop++) {
+    if (currentSeeds.length === 0) break;
+    const seedFiles = currentSeeds.map((m) => m.filePath);
+    const newFiles = [];
+    const expandedTerms = [];
+    const connectedFiles = /* @__PURE__ */ new Set();
+    for (const seed of seedFiles) {
+      const importDeps = deps.get(seed) ?? [];
+      for (const dep of importDeps) {
+        if (!explored.has(dep)) connectedFiles.add(dep);
+      }
+      const calls = callsTo.get(seed) ?? /* @__PURE__ */ new Set();
+      for (const called of calls) {
+        if (!explored.has(called)) connectedFiles.add(called);
+      }
+      const callers = calledBy.get(seed) ?? /* @__PURE__ */ new Set();
+      for (const caller of callers) {
+        if (!explored.has(caller)) connectedFiles.add(caller);
+      }
+    }
+    for (const seed of seedFiles) {
+      const content = fileContents.get(seed);
+      if (!content) continue;
+      const identifiers = extractKeyIdentifiers(content, seed);
+      expandedTerms.push(...identifiers);
+    }
+    const decayMultiplier = Math.pow(cfg.decayFactor, hop);
+    const uniqueExpandedTerms = [...new Set(expandedTerms)];
+    const expandedQuery = task + " " + uniqueExpandedTerms.slice(0, 10).join(" ");
+    const expandedResults = query(index, expandedQuery, 30);
+    for (const connected of connectedFiles) {
+      const expandedMatch = expandedResults.find((r) => r.filePath === connected);
+      const graphScore = 0.3;
+      const bm25Score = expandedMatch?.score ?? 0;
+      const hopScore = (graphScore + bm25Score) * decayMultiplier;
+      if (hopScore >= cfg.minScoreThreshold * decayMultiplier) {
+        const existing = aggregateScores.get(connected) ?? 0;
+        aggregateScores.set(connected, existing + hopScore);
+        const terms = aggregateTerms.get(connected) ?? /* @__PURE__ */ new Set();
+        terms.add(`[hop-${hop}]`);
+        if (expandedMatch) {
+          for (const t of expandedMatch.matchedTerms) terms.add(t);
+        }
+        aggregateTerms.set(connected, terms);
+        if (!explored.has(connected)) {
+          newFiles.push(connected);
+          explored.add(connected);
+        }
+      }
+    }
+    for (const r of expandedResults) {
+      if (!explored.has(r.filePath)) {
+        const hopScore = r.score * decayMultiplier * 0.5;
+        if (hopScore >= cfg.minScoreThreshold * decayMultiplier) {
+          const existing = aggregateScores.get(r.filePath) ?? 0;
+          aggregateScores.set(r.filePath, existing + hopScore);
+          const terms = aggregateTerms.get(r.filePath) ?? /* @__PURE__ */ new Set();
+          terms.add(`[hop-${hop}-bm25]`);
+          for (const t of r.matchedTerms) terms.add(t);
+          aggregateTerms.set(r.filePath, terms);
+          newFiles.push(r.filePath);
+          explored.add(r.filePath);
+        }
+      }
+    }
+    hops.push({ hop, seedFiles, newFiles, expandedTerms: uniqueExpandedTerms.slice(0, 20) });
+    const newScored = newFiles.map((f) => ({ filePath: f, score: aggregateScores.get(f) ?? 0 })).sort((a, b) => b.score - a.score).slice(0, cfg.topKPerHop);
+    currentSeeds = newScored.map((s) => ({
+      filePath: s.filePath,
+      score: s.score,
+      matchedTerms: [...aggregateTerms.get(s.filePath) ?? []]
+    }));
+  }
+  const matches = [];
+  for (const [filePath, score] of aggregateScores) {
+    const terms = aggregateTerms.get(filePath) ?? /* @__PURE__ */ new Set();
+    matches.push({ filePath, score, matchedTerms: [...terms] });
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return {
+    matches,
+    hops,
+    totalFilesExplored: explored.size
+  };
+}
+function extractKeyIdentifiers(content, filePath) {
+  const identifiers = [];
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (ext === "java") {
+    const classMatches = content.match(/(?:class|interface)\s+(\w+)/g) ?? [];
+    for (const m of classMatches) {
+      const name = m.replace(/(?:class|interface)\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+    const methodRegex = /(?:public|protected)\s+[\w<>\[\],\s?]+\s+(\w+)\s*\(/gm;
+    let match;
+    while ((match = methodRegex.exec(content)) !== null) {
+      identifiers.push(...splitCamelCase(match[1]));
+    }
+  } else if (["ts", "tsx", "js", "jsx"].includes(ext)) {
+    const exportMatches = content.match(/export\s+(?:class|function|const|interface|type)\s+(\w+)/g) ?? [];
+    for (const m of exportMatches) {
+      const name = m.replace(/export\s+(?:class|function|const|interface|type)\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+  } else if (ext === "py") {
+    const defMatches = content.match(/^(?:class|def)\s+(\w+)/gm) ?? [];
+    for (const m of defMatches) {
+      const name = m.replace(/^(?:class|def)\s+/, "");
+      identifiers.push(...splitSnakeCase(name));
+    }
+  } else if (ext === "go") {
+    const funcMatches = content.match(/^func\s+(?:\([^)]+\)\s+)?([A-Z]\w+)/gm) ?? [];
+    for (const m of funcMatches) {
+      const name = m.replace(/^func\s+(?:\([^)]+\)\s+)?/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+    const typeMatches = content.match(/^type\s+([A-Z]\w+)/gm) ?? [];
+    for (const m of typeMatches) {
+      const name = m.replace(/^type\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+  }
+  return [...new Set(identifiers)].filter((id) => id.length >= 3 && !NOISE_IDENTIFIERS.has(id.toLowerCase())).slice(0, 30);
+}
+function splitCamelCase(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((s) => s.length >= 3);
+}
+function splitSnakeCase(name) {
+  return name.split("_").filter((s) => s.length >= 3);
+}
+var NOISE_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "has",
+  "add",
+  "put",
+  "new",
+  "run",
+  "map",
+  "for",
+  "the",
+  "and",
+  "not",
+  "with",
+  "from",
+  "this",
+  "that",
+  "test",
+  "spec",
+  "mock",
+  "void",
+  "null",
+  "true",
+  "false",
+  "string",
+  "number",
+  "boolean",
+  "int",
+  "impl",
+  "default",
+  "abstract",
+  "base",
+  "main",
+  "init",
+  "setup",
+  "util",
+  "utils",
+  "helper",
+  "helpers",
+  "common",
+  "config",
+  "model",
+  "entity",
+  "service",
+  "repository",
+  "controller",
+  "handler",
+  "interface",
+  "type",
+  "class",
+  "function",
+  "const",
+  "return",
+  "import",
+  "export",
+  "private",
+  "public",
+  "protected",
+  "static",
+  "final",
+  "override",
+  "async",
+  "await"
+]);
+
+// src/engine/query-intent.ts
+var ACTION_PATTERNS = [
+  [/\b(fix|bug|debug|repair|resolve|broken|crash|error|issue|wrong)\b/i, "fix"],
+  [/\b(add|implement|create|build|new|feature|introduce|wire)\b/i, "add"],
+  [/\b(refactor|restructure|clean|extract|split|move|rename|simplify)\b/i, "refactor"],
+  [/\b(trace|follow|understand|find|where|how|flow|path|chain)\b/i, "trace"],
+  [/\b(test|spec|coverage|assert|mock|verify)\b/i, "test"],
+  [/\b(doc|document|describe|explain|readme|comment)\b/i, "docs"],
+  [/\b(remove|delete|deprecate|drop|kill|eliminate)\b/i, "remove"],
+  [/\b(optimize|performance|speed|fast|slow|latency|efficient)\b/i, "optimize"]
+];
+function detectAction(task) {
+  for (const [pattern, action] of ACTION_PATTERNS) {
+    if (pattern.test(task)) return action;
+  }
+  return "unknown";
+}
+var LAYER_KEYWORDS = [
+  [["controller", "endpoint", "handler", "router", "route", "api", "rest", "entrypoint"], "endpoint"],
+  [["usecase", "use case", "use-case", "interactor", "application service"], "usecase"],
+  [["service", "domain service", "business logic"], "service"],
+  [["repository", "repo", "dao", "data access", "persistence", "database", "db", "store"], "repository"],
+  [["cache", "redis", "memcached", "caching", "ttl", "invalidat"], "cache"],
+  [["client", "http client", "api client", "rest client", "feign", "retrofit"], "client"],
+  [["model", "entity", "dto", "domain object", "value object", "pojo"], "model"],
+  [["config", "configuration", "injector", "module", "bean", "provider", "dependency injection"], "config"],
+  [["queue", "kafka", "rabbit", "sqs", "event", "listener", "consumer", "producer", "message"], "queue"],
+  [["middleware", "interceptor", "filter", "guard", "pipe"], "middleware"]
+];
+function detectLayers(task) {
+  const lower = task.toLowerCase();
+  const layers = [];
+  for (const [keywords, layer] of LAYER_KEYWORDS) {
+    if (keywords.some((kw) => lower.includes(kw))) {
+      layers.push(layer);
+    }
+  }
+  return [...new Set(layers)];
+}
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "need",
+  "not",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "for",
+  "yet",
+  "so",
+  "in",
+  "on",
+  "at",
+  "to",
+  "from",
+  "by",
+  "with",
+  "about",
+  "between",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "up",
+  "down",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "of",
+  "if"
+]);
+var ACTION_WORDS = /* @__PURE__ */ new Set([
+  "fix",
+  "add",
+  "create",
+  "build",
+  "implement",
+  "refactor",
+  "trace",
+  "follow",
+  "find",
+  "update",
+  "modify",
+  "change",
+  "remove",
+  "delete",
+  "debug",
+  "test",
+  "check",
+  "verify",
+  "validate",
+  "handle",
+  "process",
+  "resolve",
+  "repair",
+  "optimize",
+  "improve",
+  "speed",
+  "clean",
+  "bug",
+  "error",
+  "issue",
+  "problem",
+  "flow",
+  "path",
+  "chain"
+]);
+var OPERATION_WORDS = /* @__PURE__ */ new Set([
+  "create",
+  "read",
+  "update",
+  "delete",
+  "save",
+  "load",
+  "fetch",
+  "retrieve",
+  "store",
+  "persist",
+  "insert",
+  "remove",
+  "invalidate",
+  "validate",
+  "parse",
+  "transform",
+  "convert",
+  "render",
+  "display",
+  "send",
+  "receive",
+  "publish",
+  "subscribe",
+  "emit",
+  "listen",
+  "authenticate",
+  "authorize",
+  "encrypt",
+  "decrypt",
+  "hash",
+  "serialize",
+  "deserialize",
+  "encode",
+  "decode",
+  "compress",
+  "replicate",
+  "sync",
+  "migrate",
+  "export",
+  "import",
+  "upload",
+  "download",
+  "search",
+  "index",
+  "query",
+  "filter",
+  "sort"
+]);
+function extractEntities(task) {
+  const words = task.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/);
+  const entities = [];
+  for (const word of words) {
+    if (word.length < 3) continue;
+    if (STOP_WORDS2.has(word)) continue;
+    if (ACTION_WORDS.has(word)) continue;
+    if (OPERATION_WORDS.has(word)) continue;
+    const isLayer = LAYER_KEYWORDS.some(([kws]) => kws.includes(word));
+    if (isLayer) continue;
+    entities.push(word);
+  }
+  return [...new Set(entities)];
+}
+function extractOperations(task) {
+  const words = task.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/);
+  const operations = [];
+  for (const word of words) {
+    if (OPERATION_WORDS.has(word)) {
+      operations.push(word);
+    }
+  }
+  const opPatterns = task.toLowerCase().match(/\b(on|after|before|during)\s+(\w+)/g);
+  if (opPatterns) {
+    for (const pattern of opPatterns) {
+      const parts = pattern.split(/\s+/);
+      if (parts.length >= 2 && OPERATION_WORDS.has(parts[1])) {
+        operations.push(parts[1]);
+      }
+    }
+  }
+  return [...new Set(operations)];
+}
+function extractQualifiers(task) {
+  const qualifiers = [];
+  const patterns = task.match(/\b(on|for|in|via|from|through)\s+(\w+(?:\s+\w+)?)/gi);
+  if (patterns) {
+    for (const p of patterns) {
+      const parts = p.split(/\s+/);
+      if (parts.length >= 2) {
+        const qualifier = parts.slice(1).join(" ").toLowerCase();
+        if (!STOP_WORDS2.has(qualifier) && qualifier.length >= 2) {
+          qualifiers.push(qualifier);
+        }
+      }
+    }
+  }
+  return [...new Set(qualifiers)];
+}
+function parseQueryIntent(task) {
+  const action = detectAction(task);
+  const entities = extractEntities(task);
+  const operations = extractOperations(task);
+  const layers = detectLayers(task);
+  const qualifiers = extractQualifiers(task);
+  const signals = [
+    action !== "unknown" ? 1 : 0,
+    entities.length > 0 ? 1 : 0,
+    operations.length > 0 ? 1 : 0,
+    layers.length > 0 ? 1 : 0
+  ];
+  const confidence = signals.reduce((a, b) => a + b, 0) / signals.length;
+  return { original: task, action, entities, operations, layers, qualifiers, confidence };
+}
+function buildWeightedQuery(intent) {
+  const parts = [];
+  for (const entity of intent.entities) {
+    parts.push(entity, entity, entity);
+  }
+  for (const op of intent.operations) {
+    parts.push(op, op);
+  }
+  for (const layer of intent.layers) {
+    parts.push(layer);
+  }
+  for (const q of intent.qualifiers) {
+    parts.push(q);
+  }
+  if (parts.length === 0) return intent.original;
+  return parts.join(" ");
+}
+
+// src/engine/embeddings.ts
+function buildTfIdfEmbeddingIndex(index) {
+  const allTerms = [...index.idf.keys()];
+  const termToIdx = new Map(allTerms.map((t, i) => [t, i]));
+  const dimensions = allTerms.length;
+  const docVectors = /* @__PURE__ */ new Map();
+  const docNorms = /* @__PURE__ */ new Map();
+  for (const [filePath, doc] of index.documents) {
+    const vec = new Float32Array(dimensions);
+    let norm = 0;
+    for (const [term, tf] of doc.terms) {
+      const idx = termToIdx.get(term);
+      if (idx === void 0) continue;
+      const idf = index.idf.get(term) ?? 0;
+      const weight = tf * idf;
+      vec[idx] = weight;
+      norm += weight * weight;
+    }
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+      for (let i = 0; i < dimensions; i++) {
+        vec[i] /= norm;
+      }
+    }
+    docVectors.set(filePath, vec);
+    docNorms.set(filePath, norm);
+  }
+  function queryFn(text, topK) {
+    const queryTerms = tokenizeForEmbedding(text);
+    const termCounts = /* @__PURE__ */ new Map();
+    for (const t of queryTerms) {
+      termCounts.set(t, (termCounts.get(t) ?? 0) + 1);
+    }
+    const queryVec = new Float32Array(dimensions);
+    let queryNorm = 0;
+    for (const [term, count] of termCounts) {
+      const idx = termToIdx.get(term);
+      if (idx === void 0) continue;
+      const idf = index.idf.get(term) ?? 0;
+      const weight = count * idf;
+      queryVec[idx] = weight;
+      queryNorm += weight * weight;
+    }
+    queryNorm = Math.sqrt(queryNorm);
+    if (queryNorm > 0) {
+      for (let i = 0; i < dimensions; i++) {
+        queryVec[i] /= queryNorm;
+      }
+    }
+    const results = [];
+    for (const [filePath, docVec] of docVectors) {
+      let dot = 0;
+      for (const [term] of termCounts) {
+        const idx = termToIdx.get(term);
+        if (idx !== void 0) {
+          dot += queryVec[idx] * docVec[idx];
+        }
+      }
+      if (dot > 0) {
+        results.push({ filePath, score: dot });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  return {
+    backend: "tfidf-cosine",
+    dimensions,
+    documentCount: docVectors.size,
+    query: queryFn
+  };
+}
+function reciprocalRankFusion(bm25Results, embeddingResults, k = 60, bm25Weight = 0.6, embeddingWeight = 0.4) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let i = 0; i < bm25Results.length; i++) {
+    const rrf = bm25Weight / (k + i + 1);
+    const existing = scores.get(bm25Results[i].filePath) ?? 0;
+    scores.set(bm25Results[i].filePath, existing + rrf);
+  }
+  for (let i = 0; i < embeddingResults.length; i++) {
+    const rrf = embeddingWeight / (k + i + 1);
+    const existing = scores.get(embeddingResults[i].filePath) ?? 0;
+    scores.set(embeddingResults[i].filePath, existing + rrf);
+  }
+  return [...scores.entries()].map(([filePath, score]) => ({ filePath, score })).sort((a, b) => b.score - a.score);
+}
+function tokenizeForEmbedding(text) {
+  return text.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-z0-9]/g, " ").split(/\s+/).filter((t) => t.length >= 2);
+}
+
 // src/engine/context-pipeline.ts
+var RANKING_NOISE_PATTERNS = [
+  /^changelog/i,
+  /^license/i,
+  /^contributing/i,
+  /^code_of_conduct/i,
+  /^authors/i,
+  /^codeowners$/i,
+  /^security/i,
+  /\.lock$/,
+  /^package-lock\.json$/,
+  /^yarn\.lock$/,
+  /^pnpm-lock\.yaml$/,
+  /^Gemfile\.lock$/
+];
+function isRankingNoise(filePath) {
+  const basename4 = filePath.split("/").pop() ?? filePath;
+  return RANKING_NOISE_PATTERNS.some((re) => re.test(basename4));
+}
+function fileTypePenalty(filePath, taskType) {
+  const lower = filePath.toLowerCase();
+  const isTest = /[/\\]test[s]?[/\\]|\.test\.|\.spec\.|_test\./i.test(lower);
+  const isDoc = /\.md$|\.txt$|\.rst$|^docs[/\\]/i.test(lower);
+  const isConfig = /\.xml$|\.yml$|\.yaml$|\.properties$|\.gradle$/i.test(lower);
+  if (taskType === "debug") {
+    if (isTest) return 0.4;
+    if (isDoc) return 0.2;
+    if (isConfig) return 0.6;
+  } else if (taskType === "test") {
+    if (isTest) return 1.2;
+    if (isDoc) return 0.3;
+  } else if (taskType === "docs") {
+    if (isDoc) return 1.2;
+    if (isTest) return 0.3;
+  } else if (taskType === "feature" || taskType === "refactor") {
+    if (isTest) return 0.5;
+    if (isDoc) return 0.4;
+  }
+  return 1;
+}
+function detectComplexQuery(task) {
+  const lower = task.toLowerCase();
+  const words = lower.split(/\s+/).filter((w) => w.length > 2);
+  const chainIndicators = /\b(when|after|then|through|from .+ to|via|chain|flow|trace|path|propagat|cascade|invalidat\w+ on|calls?|invokes?)\b/;
+  if (chainIndicators.test(lower)) return true;
+  const layers = [
+    "controller",
+    "endpoint",
+    "router",
+    "handler",
+    "service",
+    "usecase",
+    "use case",
+    "repository",
+    "repo",
+    "cache",
+    "database",
+    "queue",
+    "client",
+    "adapter",
+    "gateway",
+    "interceptor",
+    "middleware",
+    "listener",
+    "consumer",
+    "producer",
+    "publisher",
+    "subscriber"
+  ];
+  const layerCount = layers.filter((l) => lower.includes(l)).length;
+  if (layerCount >= 2) return true;
+  if (words.length >= 10) return true;
+  const entityConnectors = lower.match(/\b(on|for|in|from|to|with|after|before|during)\b/g);
+  if (entityConnectors && entityConnectors.length >= 3) return true;
+  return false;
+}
 async function runContextPipeline(input) {
   const { projectPath, task, analysis, budget = 5e4 } = input;
   const taskType = classifyTask(task);
+  const queryIntent = parseQueryIntent(task);
+  const weightedQuery = buildWeightedQuery(queryIntent);
   const fileContentMap = /* @__PURE__ */ new Map();
   const fileContents = [];
   for (const file of analysis.files) {
@@ -3386,22 +5291,58 @@ async function runContextPipeline(input) {
       fileContents.push({ relativePath: file.relativePath, content: "" });
     }
   }
-  const indexFiles = analysis.files.map((f) => ({
-    relativePath: f.relativePath,
-    absolutePath: f.path,
-    content: fileContentMap.get(f.relativePath)
-  }));
+  const indexFiles = analysis.files.map((f) => {
+    const raw = fileContentMap.get(f.relativePath);
+    const augmented = raw ? augmentContentWithStructure(raw, f.relativePath) : void 0;
+    return {
+      relativePath: f.relativePath,
+      absolutePath: f.path,
+      content: augmented
+    };
+  });
   const { index, stats: indexCacheStats } = buildIndexCached(projectPath, indexFiles);
-  const semanticMatches = query(index, task, 50);
-  const boostedMatches = boostByPath(
-    semanticMatches,
-    analysis.files.map((f) => f.relativePath),
-    task
-  );
+  const fileCount = analysis.files.length;
+  const adaptiveTopK = Math.min(Math.max(20, Math.round(fileCount * 0.15)), 100);
+  const allFilePaths = analysis.files.map((f) => f.relativePath);
   const depMap = /* @__PURE__ */ new Map();
   for (const file of analysis.files) {
     depMap.set(file.relativePath, file.imports);
   }
+  const callGraph = buildCallGraph(
+    fileContents.filter((f) => f.content.length > 0)
+  );
+  const callEdges = [...analysis.graph.edges.filter((e) => e.type === "call"), ...callGraph.edges];
+  const isComplexQuery = detectComplexQuery(task);
+  const embeddingIndex = buildTfIdfEmbeddingIndex(index);
+  const embeddingResults = embeddingIndex.query(weightedQuery, adaptiveTopK);
+  let bm25Matches;
+  if (isComplexQuery) {
+    const hopResult = multiHopQuery(index, weightedQuery, depMap, callEdges, fileContentMap, {
+      maxHops: 2,
+      topKPerHop: 5,
+      decayFactor: 0.5,
+      minScoreThreshold: 0.15
+    });
+    bm25Matches = hopResult.matches.slice(0, adaptiveTopK);
+  } else {
+    bm25Matches = query(index, weightedQuery, adaptiveTopK);
+  }
+  const fusedResults = reciprocalRankFusion(bm25Matches, embeddingResults, 60, 0.6, 0.4);
+  const rawMatches = fusedResults.slice(0, adaptiveTopK).map((r) => {
+    const bm25Match = bm25Matches.find((m) => m.filePath === r.filePath);
+    return {
+      filePath: r.filePath,
+      score: r.score,
+      matchedTerms: bm25Match?.matchedTerms ?? ["[embedding-only]"]
+    };
+  });
+  const semanticMatches = rawMatches.filter((m) => !isRankingNoise(m.filePath));
+  const pathBoosted = boostByPath(semanticMatches, allFilePaths, task);
+  const layerBoosted = boostByLayer(pathBoosted, allFilePaths, task);
+  const importBoosted = boostByImports(layerBoosted, depMap, 10, 0.4);
+  const callBoosted = boostByCallGraph(importBoosted, callEdges, 10, 0.3);
+  const coChangeMatrix = buildCoChangeMatrix(projectPath, 500, 2);
+  const boostedMatches = boostByGitCoChange(callBoosted, coChangeMatrix, 10, 0.25, 0.15);
   const rerankResult = rerank({
     task,
     candidates: boostedMatches,
@@ -3410,12 +5351,15 @@ async function runContextPipeline(input) {
     dependencies: depMap,
     allFilePaths: analysis.files.map((f) => f.relativePath)
   });
-  const rerankedMatches = rerankResult.files.map((rf) => ({
-    filePath: rf.filePath,
-    score: rf.bm25Score,
-    // Keep original BM25 score for composite
-    matchedTerms: boostedMatches.find((m) => m.filePath === rf.filePath)?.matchedTerms ?? []
+  const rerankerApproved = new Set(rerankResult.files.map((rf) => rf.filePath));
+  const rerankedMatches = boostedMatches.map((m) => ({
+    filePath: m.filePath,
+    score: rerankerApproved.has(m.filePath) ? m.score * 1.5 : m.score,
+    matchedTerms: [...m.matchedTerms]
   }));
+  for (const m of rerankedMatches) {
+    m.score *= fileTypePenalty(m.filePath, taskType);
+  }
   const learner = await loadLearner(projectPath);
   const learnerBoosts = getLearnerBoosts(
     learner,
@@ -3438,7 +5382,7 @@ async function runContextPipeline(input) {
     const { querySiblingRepos: querySiblingRepos2 } = await Promise.resolve().then(() => (init_multi_repo(), multi_repo_exports));
     multiRepo = querySiblingRepos2(input.siblingRepos, task, 5, 0.3);
   }
-  return { selection, taskType, fileContentMap, semanticMap, learnerMap, multiRepo, indexCacheStats };
+  return { selection, taskType, fileContentMap, semanticMap, learnerMap, queryIntent, multiRepo, indexCacheStats };
 }
 
 // src/mcp/index.ts