cto-ai-cli 6.1.0 → 8.0.0

package/dist/mcp/index.js

@@ -1,15 +1,783 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in 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();
+  const docFreq = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const terms = tokenize(file.content);
+    const termCounts = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      termCounts.set(term, (termCounts.get(term) ?? 0) + 1);
+    }
+    documents.set(file.relativePath, { terms: termCounts, length: terms.length });
+    for (const term of termCounts.keys()) {
+      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const totalDocs = files.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const [term, df] of docFreq) {
+    idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
+  }
+  let totalLength = 0;
+  for (const doc of documents.values()) totalLength += doc.length;
+  const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
+}
+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;
+  for (const [filePath, doc] of index.documents) {
+    let score = 0;
+    const matchedTerms = [];
+    for (const [qTerm, qCount] of querySet) {
+      const tf = doc.terms.get(qTerm) ?? 0;
+      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 * domainDamp;
+      matchedTerms.push(qTerm);
+    }
+    if (score > 0) {
+      results.push({ filePath, score, matchedTerms });
+    }
+  }
+  const maxScore = results.reduce((max, r) => Math.max(max, r.score), 0);
+  if (maxScore > 0) {
+    for (const r of results) r.score = r.score / maxScore;
+  }
+  return results.sort((a, b2) => b2.score - a.score).slice(0, maxResults);
+}
+function tokenize(text) {
+  const tokens = [];
+  const rawTokens = text.match(/[a-zA-Z][a-zA-Z0-9]*|[0-9]+/g) ?? [];
+  for (const raw of rawTokens) {
+    const parts = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
+    for (const part of parts) {
+      if (part.length < 2) continue;
+      const stemmed = stem(part);
+      if (stemmed.length < 2) continue;
+      if (STOP_WORDS.has(stemmed)) continue;
+      tokens.push(stemmed);
+    }
+  }
+  return tokens;
+}
+function stem(word) {
+  let w = word.toLowerCase();
+  for (const [prefix, root] of TERM_FAMILIES) {
+    if (w.startsWith(prefix) || w === root) return root;
+  }
+  if (w.endsWith("ication") && w.length > 9) return w.slice(0, -7);
+  if (w.endsWith("ation") && w.length > 7) return w.slice(0, -5);
+  if (w.endsWith("tion") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("sion") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ment") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ness") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("able") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ible") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ator") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("izer") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ing") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ies") && w.length > 4) return w.slice(0, -3) + "y";
+  if (w.endsWith("ous") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ful") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ity") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ive") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ion") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ed") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("er") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("ly") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("al") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("s") && !w.endsWith("ss") && w.length > 3) return w.slice(0, -1);
+  return w;
+}
+function boostByPath(matches, allFiles, taskDescription) {
+  const queryTerms = new Set(tokenize(taskDescription));
+  const boosted = /* @__PURE__ */ new Map();
+  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 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);
+      if (existing) {
+        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: pathBoost,
+          matchedTerms: allPathMatches
+        });
+      }
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+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",
+      "export",
+      "from",
+      "const",
+      "let",
+      "var",
+      "function",
+      "class",
+      "interface",
+      "type",
+      "return",
+      "async",
+      "await",
+      "new",
+      "this",
+      "that",
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "void",
+      "string",
+      "number",
+      "boolean",
+      "any",
+      "unknown",
+      "never",
+      "object",
+      "array",
+      "promise",
+      "if",
+      "else",
+      "for",
+      "while",
+      "do",
+      "switch",
+      "case",
+      "break",
+      "continue",
+      "try",
+      "catch",
+      "throw",
+      "finally",
+      "default",
+      "extends",
+      "implements",
+      "static",
+      "private",
+      "public",
+      "protected",
+      "readonly",
+      "abstract",
+      "override",
+      "super",
+      "typeof",
+      "instanceof",
+      "in",
+      "of",
+      "as",
+      "is",
+      "keyof",
+      "enum",
+      "namespace",
+      "module",
+      "declare",
+      // Python
+      "def",
+      "self",
+      "cls",
+      "none",
+      "pass",
+      "yield",
+      "lambda",
+      "with",
+      "elif",
+      "except",
+      "raise",
+      "assert",
+      "global",
+      "nonlocal",
+      // Natural language stop words only — NOT domain terms that carry signal
+      "the",
+      "and",
+      "for",
+      "with",
+      "not",
+      "but",
+      "are",
+      "was",
+      "were",
+      "has",
+      "have",
+      "had",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "can",
+      "its",
+      "also",
+      "than",
+      "then",
+      "into",
+      "only",
+      "very",
+      "just",
+      "about",
+      "being",
+      "been",
+      "does",
+      "did",
+      "doing",
+      "todo",
+      "fixme",
+      "hack",
+      "note",
+      "xxx"
+    ]);
+    TERM_FAMILIES = [
+      ["authenticat", "auth"],
+      ["authori", "auth"],
+      ["configur", "config"],
+      ["connect", "connect"],
+      ["request", "request"],
+      ["response", "respons"],
+      ["middlewar", "middlewar"],
+      ["validat", "valid"],
+      ["initiali", "init"],
+      ["subscri", "subscrib"],
+      ["transform", "transform"],
+      ["seriali", "serial"],
+      ["deseriali", "serial"],
+      ["dependen", "depend"],
+      ["environ", "environ"],
+      ["permiss", "permiss"],
+      ["migrat", "migrat"],
+      ["transact", "transact"],
+      ["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"]
+    };
+  }
+});
+
+// src/engine/multi-repo.ts
+var multi_repo_exports = {};
+__export(multi_repo_exports, {
+  discoverSiblingRepos: () => discoverSiblingRepos,
+  parseSiblingPaths: () => parseSiblingPaths,
+  querySiblingRepos: () => querySiblingRepos,
+  renderMultiRepoSummary: () => renderMultiRepoSummary
+});
+import { readdirSync, readFileSync as readFileSync5, statSync as statSync2, existsSync as existsSync5 } from "fs";
+import { join as join7, basename as basename3, resolve as resolve5, relative as relative5 } from "path";
+function discoverSiblingRepos(projectPath) {
+  const absProject = resolve5(projectPath);
+  const parentDir = join7(absProject, "..");
+  const projectName = basename3(absProject);
+  const siblings = [];
+  let entries;
+  try {
+    entries = readdirSync(parentDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (entry === projectName) continue;
+    if (entry.startsWith(".")) continue;
+    if (SKIP_DIRS.has(entry)) continue;
+    const candidatePath = join7(parentDir, entry);
+    try {
+      if (!statSync2(candidatePath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const hasMarker = REPO_MARKERS.some((marker) => {
+      try {
+        return existsSync5(join7(candidatePath, marker));
+      } catch {
+        return false;
+      }
+    });
+    if (!hasMarker) continue;
+    const stack = detectStack2(candidatePath);
+    siblings.push({
+      path: candidatePath,
+      name: entry,
+      stack,
+      fileCount: 0
+      // filled during indexing
+    });
+  }
+  return siblings;
+}
+function detectStack2(repoPath) {
+  const stack = [];
+  try {
+    if (existsSync5(join7(repoPath, "tsconfig.json"))) stack.push("TypeScript");
+    if (existsSync5(join7(repoPath, "package.json"))) stack.push("Node.js");
+    if (existsSync5(join7(repoPath, "Cargo.toml"))) stack.push("Rust");
+    if (existsSync5(join7(repoPath, "go.mod"))) stack.push("Go");
+    if (existsSync5(join7(repoPath, "pyproject.toml"))) stack.push("Python");
+    if (existsSync5(join7(repoPath, "pom.xml"))) stack.push("Java");
+  } catch {
+  }
+  return stack;
+}
+function listSourceFiles(repoPath, maxFiles = MAX_FILES_PER_REPO) {
+  const files = [];
+  function walk(dir, depth) {
+    if (depth > 8 || files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      if (entry.startsWith(".")) continue;
+      if (SKIP_DIRS.has(entry)) continue;
+      const fullPath = join7(dir, entry);
+      try {
+        const stat3 = statSync2(fullPath);
+        if (stat3.isDirectory()) {
+          walk(fullPath, depth + 1);
+        } else if (stat3.isFile() && stat3.size <= MAX_FILE_SIZE) {
+          const ext = entry.split(".").pop()?.toLowerCase() ?? "";
+          if (SOURCE_EXTENSIONS.has(ext)) {
+            files.push(relative5(repoPath, fullPath));
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  walk(repoPath, 0);
+  return files;
+}
+function indexSiblingRepo(repo) {
+  const filePaths = listSourceFiles(repo.path);
+  repo.fileCount = filePaths.length;
+  const contents = [];
+  const contentMap = /* @__PURE__ */ new Map();
+  for (const relPath of filePaths) {
+    try {
+      const content = readFileSync5(join7(repo.path, relPath), "utf-8");
+      contents.push({ relativePath: relPath, content });
+      contentMap.set(relPath, content);
+    } catch {
+      contents.push({ relativePath: relPath, content: "" });
+    }
+  }
+  return { contents, contentMap };
+}
+function querySiblingRepos(siblings, task, maxPerRepo = 5, minScore = 0.3) {
+  const startTime = performance.now();
+  const allMatches = [];
+  for (const repo of siblings) {
+    const { contents, contentMap } = indexSiblingRepo(repo);
+    if (contents.length === 0) continue;
+    const index = buildIndex(contents);
+    const matches = query(index, task, maxPerRepo * 2);
+    const boosted = boostByPath(
+      matches,
+      contents.map((c) => c.relativePath),
+      task
+    );
+    for (const match of boosted.slice(0, maxPerRepo)) {
+      if (match.score < minScore) continue;
+      const content = contentMap.get(match.filePath) ?? "";
+      const tokens = Math.ceil(content.length / 4);
+      allMatches.push({
+        repoName: repo.name,
+        repoPath: repo.path,
+        relativePath: match.filePath,
+        absolutePath: join7(repo.path, match.filePath),
+        score: match.score,
+        content,
+        tokens
+      });
+    }
+  }
+  allMatches.sort((a, b) => b.score - a.score);
+  return {
+    siblings,
+    matches: allMatches,
+    timeMs: Math.round(performance.now() - startTime)
+  };
+}
+function parseSiblingPaths(pathsStr, projectPath) {
+  const absProject = resolve5(projectPath);
+  return pathsStr.split(",").map((p) => p.trim()).filter((p) => p.length > 0).map((p) => {
+    const absPath = resolve5(join7(absProject, ".."), p);
+    return {
+      path: absPath,
+      name: basename3(absPath),
+      stack: detectStack2(absPath),
+      fileCount: 0
+    };
+  }).filter((repo) => existsSync5(repo.path));
+}
+function renderMultiRepoSummary(result) {
+  const lines = [];
+  if (result.siblings.length === 0) {
+    lines.push("  No sibling repos found.");
+    return lines.join("\n");
+  }
+  lines.push(`  Sibling repos scanned: ${result.siblings.length} (${result.timeMs}ms)`);
+  for (const repo of result.siblings) {
+    lines.push(`    ${repo.name}/ \u2014 ${repo.fileCount} files [${repo.stack.join(", ") || "unknown"}]`);
+  }
+  if (result.matches.length === 0) {
+    lines.push("  No relevant files found in sibling repos.");
+  } else {
+    lines.push(`  Cross-repo matches: ${result.matches.length}`);
+    for (const m of result.matches.slice(0, 10)) {
+      const pct = Math.round(m.score * 100);
+      lines.push(`    ${m.repoName}/${m.relativePath}  sem: ${pct}%  (~${Math.round(m.tokens / 1e3)}K tok)`);
+    }
+  }
+  return lines.join("\n");
+}
+var REPO_MARKERS, SKIP_DIRS, SOURCE_EXTENSIONS, MAX_FILES_PER_REPO, MAX_FILE_SIZE;
+var init_multi_repo = __esm({
+  "src/engine/multi-repo.ts"() {
+    "use strict";
+    init_tfidf();
+    REPO_MARKERS = ["package.json", "tsconfig.json", "Cargo.toml", "go.mod", "pyproject.toml", "pom.xml"];
+    SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor"]);
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mjs",
+      "cjs",
+      "py",
+      "rs",
+      "go",
+      "java",
+      "kt",
+      "rb",
+      "c",
+      "cpp",
+      "h",
+      "hpp",
+      "cs",
+      "json",
+      "yaml",
+      "yml",
+      "toml",
+      "md",
+      "txt"
+    ]);
+    MAX_FILES_PER_REPO = 500;
+    MAX_FILE_SIZE = 1e5;
+  }
+});
 
 // src/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { resolve as resolve4 } from "path";
-import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
 
 // src/engine/analyzer.ts
 import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
-import { join as join2, extname, relative as relative2, resolve as resolve2, basename as basename2 } from "path";
+import { join as join3, extname, relative as relative3, resolve as resolve3, basename as basename2 } from "path";
 import { createHash } from "crypto";
 
 // src/types/engine.ts
@@ -33,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
   },
@@ -93,27 +873,742 @@ function estimateTokens(content, sizeInBytes, method = "chars4") {
 
 // src/engine/graph.ts
 import { Project, SyntaxKind } from "ts-morph";
-import { resolve, relative, dirname, join } from "path";
-import { existsSync } from "fs";
-var TS_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
-function createProject(projectPath, filePaths) {
-  const tsConfigPath = join(projectPath, "tsconfig.json");
-  const hasTsConfig = existsSync(tsConfigPath);
-  const project = new Project({
-    tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: hasTsConfig ? void 0 : {
-      allowJs: true,
-      jsx: 4,
-      // JsxEmit.ReactJSX
-      esModuleInterop: true,
-      moduleResolution: 100
-      // Bundler
+import { resolve as resolve2, relative as relative2, dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+
+// src/engine/polyglot-graph.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+var LANG_EXTENSIONS = {
+  "py": "python",
+  "pyw": "python",
+  "go": "go",
+  "java": "java",
+  "rs": "rust",
+  "ts": "typescript",
+  "tsx": "typescript",
+  "js": "typescript",
+  "jsx": "typescript",
+  "mts": "typescript",
+  "mjs": "typescript",
+  "cts": "typescript",
+  "cjs": "typescript"
+};
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return LANG_EXTENSIONS[ext] ?? null;
+}
+function parseImports(filePath, relativePath, projectPath, allRelativePaths, content) {
+  const lang = detectLanguage(relativePath);
+  if (!lang || lang === "typescript") return [];
+  const src = content ?? safeReadFile(filePath);
+  if (!src) return [];
+  const edges = [];
+  let specs;
+  switch (lang) {
+    case "python":
+      specs = parsePythonImports(src);
+      break;
+    case "go":
+      specs = parseGoImports(src);
+      break;
+    case "java":
+      specs = parseJavaImports(src);
+      break;
+    case "rust":
+      specs = parseRustImports(src);
+      break;
+    default:
+      return [];
+  }
+  for (const spec of specs) {
+    const resolved = resolveImportSpec(spec, relativePath, projectPath, allRelativePaths, lang);
+    if (resolved) {
+      edges.push({ from: relativePath, to: resolved, type: "import" });
     }
-  });
-  const tsFiles = filePaths.filter((f) => {
-    const ext = f.split(".").pop()?.toLowerCase() ?? "";
-    return TS_EXTENSIONS.has(ext);
+  }
+  return edges;
+}
+function parseAllPolyglotImports(files, projectPath) {
+  const allPaths = new Set(files.map((f) => f.relativePath));
+  const edges = [];
+  for (const file of files) {
+    const lang = detectLanguage(file.relativePath);
+    if (!lang || lang === "typescript") continue;
+    const fileEdges = parseImports(
+      file.absolutePath,
+      file.relativePath,
+      projectPath,
+      allPaths,
+      file.content
+    );
+    edges.push(...fileEdges);
+  }
+  return edges;
+}
+function estimateComplexity(content, lang) {
+  let complexity = 1;
+  const lines = content.split("\n");
+  const patterns = {
+    python: [
+      /^\s*if\s/,
+      /^\s*elif\s/,
+      /^\s*for\s/,
+      /^\s*while\s/,
+      /^\s*except\s/,
+      /\sif\s.*\selse\s/,
+      // ternary
+      /\sand\s/,
+      /\sor\s/
+    ],
+    go: [
+      /^\s*if\s/,
+      /^\s*for\s/,
+      /^\s*case\s/,
+      /^\s*select\s*{/,
+      /&&/,
+      /\|\|/
+    ],
+    java: [
+      /^\s*if\s*\(/,
+      /^\s*for\s*\(/,
+      /^\s*while\s*\(/,
+      /^\s*case\s/,
+      /^\s*catch\s*\(/,
+      /\?\s/,
+      // ternary
+      /&&/,
+      /\|\|/
+    ],
+    rust: [
+      /^\s*if\s/,
+      /^\s*for\s/,
+      /^\s*while\s/,
+      /^\s*match\s/,
+      /=>\s/,
+      // match arms
+      /&&/,
+      /\|\|/
+    ],
+    typescript: []
+    // handled by ts-morph
+  };
+  const langPatterns = patterns[lang];
+  for (const line of lines) {
+    for (const pattern of langPatterns) {
+      if (pattern.test(line)) {
+        complexity++;
+        break;
+      }
+    }
+  }
+  return complexity;
+}
+var PYTHON_STDLIB = /* @__PURE__ */ new Set([
+  "__future__",
+  "abc",
+  "aifc",
+  "argparse",
+  "array",
+  "ast",
+  "asynchat",
+  "asyncio",
+  "asyncore",
+  "atexit",
+  "audioop",
+  "base64",
+  "bdb",
+  "binascii",
+  "binhex",
+  "bisect",
+  "builtins",
+  "bz2",
+  "calendar",
+  "cgi",
+  "cgitb",
+  "chunk",
+  "cmath",
+  "cmd",
+  "code",
+  "codecs",
+  "codeop",
+  "collections",
+  "colorsys",
+  "compileall",
+  "concurrent",
+  "configparser",
+  "contextlib",
+  "contextvars",
+  "copy",
+  "copyreg",
+  "cProfile",
+  "crypt",
+  "csv",
+  "ctypes",
+  "curses",
+  "dataclasses",
+  "datetime",
+  "dbm",
+  "decimal",
+  "difflib",
+  "dis",
+  "distutils",
+  "doctest",
+  "email",
+  "encodings",
+  "enum",
+  "errno",
+  "faulthandler",
+  "fcntl",
+  "filecmp",
+  "fileinput",
+  "fnmatch",
+  "fractions",
+  "ftplib",
+  "functools",
+  "gc",
+  "getopt",
+  "getpass",
+  "gettext",
+  "glob",
+  "grp",
+  "gzip",
+  "hashlib",
+  "heapq",
+  "hmac",
+  "html",
+  "http",
+  "idlelib",
+  "imaplib",
+  "imghdr",
+  "imp",
+  "importlib",
+  "inspect",
+  "io",
+  "ipaddress",
+  "itertools",
+  "json",
+  "keyword",
+  "lib2to3",
+  "linecache",
+  "locale",
+  "logging",
+  "lzma",
+  "mailbox",
+  "mailcap",
+  "marshal",
+  "math",
+  "mimetypes",
+  "mmap",
+  "modulefinder",
+  "multiprocessing",
+  "netrc",
+  "nis",
+  "nntplib",
+  "numbers",
+  "operator",
+  "optparse",
+  "os",
+  "ossaudiodev",
+  "pathlib",
+  "pdb",
+  "pickle",
+  "pickletools",
+  "pipes",
+  "pkgutil",
+  "platform",
+  "plistlib",
+  "poplib",
+  "posix",
+  "posixpath",
+  "pprint",
+  "profile",
+  "pstats",
+  "pty",
+  "pwd",
+  "py_compile",
+  "pyclbr",
+  "pydoc",
+  "queue",
+  "quopri",
+  "random",
+  "re",
+  "readline",
+  "reprlib",
+  "resource",
+  "rlcompleter",
+  "runpy",
+  "sched",
+  "secrets",
+  "select",
+  "selectors",
+  "shelve",
+  "shlex",
+  "shutil",
+  "signal",
+  "site",
+  "smtpd",
+  "smtplib",
+  "sndhdr",
+  "socket",
+  "socketserver",
+  "spwd",
+  "sqlite3",
+  "ssl",
+  "stat",
+  "statistics",
+  "string",
+  "stringprep",
+  "struct",
+  "subprocess",
+  "sunau",
+  "symtable",
+  "sys",
+  "sysconfig",
+  "syslog",
+  "tabnanny",
+  "tarfile",
+  "telnetlib",
+  "tempfile",
+  "termios",
+  "test",
+  "textwrap",
+  "threading",
+  "time",
+  "timeit",
+  "tkinter",
+  "token",
+  "tokenize",
+  "tomllib",
+  "trace",
+  "traceback",
+  "tracemalloc",
+  "tty",
+  "turtle",
+  "turtledemo",
+  "types",
+  "typing",
+  "unicodedata",
+  "unittest",
+  "urllib",
+  "uu",
+  "uuid",
+  "venv",
+  "warnings",
+  "wave",
+  "weakref",
+  "webbrowser",
+  "winreg",
+  "winsound",
+  "wsgiref",
+  "xdrlib",
+  "xml",
+  "xmlrpc",
+  "zipapp",
+  "zipfile",
+  "zipimport",
+  "zlib",
+  "_thread"
+]);
+function isPythonStdlib(module) {
+  const topLevel = module.split(".")[0];
+  return PYTHON_STDLIB.has(topLevel);
+}
+function parsePythonImports(content) {
+  const specs = [];
+  const joined = content.replace(/\(\s*\n([^)]*?)\)/gs, (_, inner) => {
+    return "(" + inner.replace(/\n/g, " ").replace(/\s+/g, " ") + ")";
+  });
+  const lines = joined.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("#")) continue;
+    const fromMatch = trimmed.match(/^from\s+(\.{0,10}[\w.]*)\s+import\s+(.+)/);
+    if (fromMatch) {
+      const raw = fromMatch[1];
+      const isRelative = raw.startsWith(".");
+      if (!isRelative && isPythonStdlib(raw)) continue;
+      specs.push({ raw, isRelative });
+      continue;
+    }
+    const importMatch = trimmed.match(/^import\s+(.+)/);
+    if (importMatch) {
+      const modules = importMatch[1].split(",").map((m) => m.trim().split(/\s+as\s+/)[0].trim());
+      for (const mod of modules) {
+        if (!mod || !mod.match(/^[\w.]+$/)) continue;
+        if (isPythonStdlib(mod)) continue;
+        specs.push({ raw: mod, isRelative: false });
+      }
+    }
+  }
+  return specs;
+}
+var GO_STDLIB_PREFIXES = /* @__PURE__ */ new Set([
+  "archive",
+  "bufio",
+  "bytes",
+  "cmp",
+  "compress",
+  "container",
+  "context",
+  "crypto",
+  "database",
+  "debug",
+  "embed",
+  "encoding",
+  "errors",
+  "expvar",
+  "flag",
+  "fmt",
+  "go",
+  "hash",
+  "html",
+  "image",
+  "index",
+  "internal",
+  "io",
+  "iter",
+  "log",
+  "maps",
+  "math",
+  "mime",
+  "net",
+  "os",
+  "path",
+  "plugin",
+  "reflect",
+  "regexp",
+  "runtime",
+  "slices",
+  "sort",
+  "strconv",
+  "strings",
+  "structs",
+  "sync",
+  "syscall",
+  "testing",
+  "text",
+  "time",
+  "unicode",
+  "unsafe"
+]);
+function isGoStdlib(importPath) {
+  const firstSegment = importPath.split("/")[0];
+  if (firstSegment.includes(".")) return false;
+  return GO_STDLIB_PREFIXES.has(firstSegment);
+}
+function parseGoImports(content) {
+  const specs = [];
+  const singlePattern = /^\s*import\s+(?:[\w_.]+\s+)?"([^"]+)"/gm;
+  let match;
+  while ((match = singlePattern.exec(content)) !== null) {
+    const pkg = match[1];
+    if (isGoStdlib(pkg)) continue;
+    specs.push({ raw: pkg, isRelative: false });
+  }
+  const blockPattern = /import\s*\(([\s\S]*?)\)/g;
+  while ((match = blockPattern.exec(content)) !== null) {
+    const block = match[1];
+    const linePattern = /(?:[\w_.]+\s+)?"([^"]+)"/g;
+    let lineMatch;
+    while ((lineMatch = linePattern.exec(block)) !== null) {
+      const pkg = lineMatch[1];
+      if (isGoStdlib(pkg)) continue;
+      specs.push({ raw: pkg, isRelative: false });
+    }
+  }
+  return specs;
+}
+var JAVA_STDLIB_PREFIXES = /* @__PURE__ */ new Set([
+  "java",
+  "javax",
+  "jdk",
+  "sun",
+  "com.sun",
+  "org.w3c",
+  "org.xml",
+  "org.ietf"
+]);
+function isJavaStdlib(importPath) {
+  for (const prefix of JAVA_STDLIB_PREFIXES) {
+    if (importPath === prefix || importPath.startsWith(prefix + ".")) return true;
+  }
+  return false;
+}
+function parseJavaImports(content) {
+  const specs = [];
+  const pattern = /^\s*import\s+(?:static\s+)?([\w.*]+)\s*;/gm;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const raw = match[1];
+    if (isJavaStdlib(raw)) continue;
+    specs.push({ raw, isRelative: false });
+  }
+  return specs;
+}
+function parseRustImports(content) {
+  const specs = [];
+  const usePattern = /^\s*(?:pub\s+)?use\s+((?:crate|super|self)(?:::\w+)*)/gm;
+  let match;
+  while ((match = usePattern.exec(content)) !== null) {
+    const raw = match[1];
+    const isRelative = raw.startsWith("super") || raw.startsWith("self");
+    specs.push({ raw, isRelative });
+  }
+  const modPattern = /^\s*(?:pub\s+)?mod\s+(\w+)\s*;/gm;
+  while ((match = modPattern.exec(content)) !== null) {
+    specs.push({ raw: `mod::${match[1]}`, isRelative: true });
+  }
+  return specs;
+}
+function resolveImportSpec(spec, fromRelativePath, projectPath, allPaths, lang) {
+  switch (lang) {
+    case "python":
+      return resolvePythonImport(spec, fromRelativePath, allPaths);
+    case "go":
+      return resolveGoImport(spec, fromRelativePath, projectPath, allPaths);
+    case "java":
+      return resolveJavaImport(spec, allPaths);
+    case "rust":
+      return resolveRustImport(spec, fromRelativePath, allPaths);
+    default:
+      return null;
+  }
+}
+function resolvePythonImport(spec, fromRelativePath, allPaths) {
+  if (spec.isRelative) {
+    const dots = spec.raw.match(/^\.+/)?.[0].length ?? 0;
+    const modulePart = spec.raw.slice(dots);
+    let baseDir = dirname(fromRelativePath);
+    for (let i = 1; i < dots; i++) {
+      baseDir = dirname(baseDir);
+    }
+    if (!modulePart) {
+      return tryResolvePython(baseDir, "", allPaths);
+    }
+    const modulePath2 = modulePart.replace(/\./g, "/");
+    return tryResolvePython(baseDir, modulePath2, allPaths);
+  }
+  const modulePath = spec.raw.replace(/\./g, "/");
+  return tryResolvePython("", modulePath, allPaths);
+}
+function tryResolvePython(baseDir, modulePath, allPaths) {
+  const candidates = [];
+  if (!modulePath) {
+    candidates.push(join(baseDir, "__init__.py"));
+  } else {
+    candidates.push(
+      join(baseDir, `${modulePath}.py`),
+      join(baseDir, modulePath, "__init__.py")
+    );
+    if (baseDir) {
+      candidates.push(
+        `${modulePath}.py`,
+        join(modulePath, "__init__.py")
+      );
+    }
+    for (const prefix of ["src", "lib", "app"]) {
+      candidates.push(
+        join(prefix, `${modulePath}.py`),
+        join(prefix, modulePath, "__init__.py")
+      );
+    }
+  }
+  const normalized = candidates.map((p) => p.replace(/^\.[\\/]/, ""));
+  for (const candidate of normalized) {
+    if (allPaths.has(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveGoImport(spec, fromRelativePath, projectPath, allPaths) {
+  const dirFiles = /* @__PURE__ */ new Map();
+  for (const p of allPaths) {
+    if (!p.endsWith(".go")) continue;
+    if (p.endsWith("_test.go")) continue;
+    const dir = dirname(p);
+    const existing = dirFiles.get(dir);
+    if (existing) existing.push(p);
+    else dirFiles.set(dir, [p]);
+  }
+  const importParts = spec.raw.split("/");
+  const pkgName = importParts[importParts.length - 1];
+  let goModModule = "";
+  for (const p of allPaths) {
+    if (p === "go.mod" || p.endsWith("/go.mod")) {
+      try {
+        const goModContent = safeReadFile(join(projectPath, p));
+        if (goModContent) {
+          const modMatch = goModContent.match(/^module\s+(\S+)/m);
+          if (modMatch) goModModule = modMatch[1];
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  if (goModModule && spec.raw.startsWith(goModModule + "/")) {
+    const localPath = spec.raw.slice(goModModule.length + 1);
+    const files = dirFiles.get(localPath);
+    if (files && files.length > 0) return files.sort()[0];
+    for (const prefix of ["", "cmd/", "pkg/", "internal/"]) {
+      const tryPath = prefix + localPath;
+      const tryFiles = dirFiles.get(tryPath);
+      if (tryFiles && tryFiles.length > 0) return tryFiles.sort()[0];
+    }
+  }
+  for (const [dir, files] of dirFiles) {
+    const dirName = dir.split("/").pop();
+    if (dirName === pkgName) return files.sort()[0];
+  }
+  for (let depth = 2; depth <= Math.min(importParts.length, 4); depth++) {
+    const suffix = importParts.slice(-depth).join("/");
+    for (const [dir, files] of dirFiles) {
+      if (dir === suffix || dir.endsWith("/" + suffix)) {
+        return files.sort()[0];
+      }
+    }
+  }
+  return null;
+}
+function resolveJavaImport(spec, allPaths) {
+  const parts = spec.raw.split(".");
+  if (parts[parts.length - 1] === "*") {
+    const packagePath2 = parts.slice(0, -1).join("/");
+    for (const prefix of ["src/main/java/", "src/", ""]) {
+      for (const path of allPaths) {
+        if (path.startsWith(prefix + packagePath2 + "/") && path.endsWith(".java")) {
+          return path;
+        }
+      }
+    }
+    for (const path of allPaths) {
+      if (path.includes(packagePath2 + "/") && path.endsWith(".java")) {
+        return path;
+      }
+    }
+    return null;
+  }
+  let className = parts[parts.length - 1];
+  let packageParts = parts.slice(0, -1);
+  if (className[0] && className[0] === className[0].toLowerCase() && packageParts.length > 0) {
+    className = packageParts[packageParts.length - 1];
+    packageParts = packageParts.slice(0, -1);
+  }
+  if (packageParts.length > 0) {
+    const maybeOuter = packageParts[packageParts.length - 1];
+    if (maybeOuter[0] && maybeOuter[0] === maybeOuter[0].toUpperCase() && className[0] && className[0] === className[0].toUpperCase()) {
+      className = maybeOuter;
+      packageParts = packageParts.slice(0, -1);
+    }
+  }
+  const packagePath = packageParts.join("/");
+  const javaFile = `${className}.java`;
+  const fullPath = packagePath ? `${packagePath}/${javaFile}` : javaFile;
+  const prefixes = ["src/main/java/", "src/main/kotlin/", "src/", "app/src/main/java/", ""];
+  for (const prefix of prefixes) {
+    const candidate = prefix + fullPath;
+    if (allPaths.has(candidate)) return candidate;
+  }
+  for (const path of allPaths) {
+    if (path.endsWith(fullPath)) return path;
+  }
+  if (packageParts.length >= 2) {
+    const lastTwoPkg = packageParts.slice(-2).join("/");
+    for (const path of allPaths) {
+      if (path.endsWith(javaFile) && path.includes(lastTwoPkg)) return path;
+    }
+  }
+  return null;
+}
+function resolveRustImport(spec, fromRelativePath, allPaths) {
+  if (spec.raw.startsWith("mod::")) {
+    const modName = spec.raw.slice(5);
+    const dir = dirname(fromRelativePath);
+    const candidates = [
+      join(dir, `${modName}.rs`),
+      join(dir, modName, "mod.rs")
+    ];
+    for (const c of candidates) {
+      if (allPaths.has(c)) return c;
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("crate::")) {
+    const parts = spec.raw.replace("crate::", "").split("::");
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        `src/${modulePath}.rs`,
+        `src/${modulePath}/mod.rs`,
+        `${modulePath}.rs`,
+        `${modulePath}/mod.rs`
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("super::")) {
+    const parts = spec.raw.replace("super::", "").split("::");
+    const parentDir = dirname(dirname(fromRelativePath));
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        join(parentDir, `${modulePath}.rs`),
+        join(parentDir, modulePath, "mod.rs")
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("self::")) {
+    const parts = spec.raw.replace("self::", "").split("::");
+    const dir = dirname(fromRelativePath);
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        join(dir, `${modulePath}.rs`),
+        join(dir, modulePath, "mod.rs")
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function safeReadFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// src/engine/graph.ts
+var TS_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
+function createProject(projectPath, filePaths) {
+  const tsConfigPath = join2(projectPath, "tsconfig.json");
+  const hasTsConfig = existsSync2(tsConfigPath);
+  const project = new Project({
+    tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: hasTsConfig ? void 0 : {
+      allowJs: true,
+      jsx: 4,
+      // JsxEmit.ReactJSX
+      esModuleInterop: true,
+      moduleResolution: 100
+      // Bundler
+    }
+  });
+  const tsFiles = filePaths.filter((f) => {
+    const ext = f.split(".").pop()?.toLowerCase() ?? "";
+    return TS_EXTENSIONS.has(ext);
   });
   for (const filePath of tsFiles) {
     try {
@@ -124,9 +1619,11 @@ function createProject(projectPath, filePaths) {
   return project;
 }
 function buildProjectGraph(projectPath, files) {
-  const absPath = resolve(projectPath);
+  const absPath = resolve2(projectPath);
   const tsFiles = files.filter((f) => TS_EXTENSIONS.has(f.extension)).map((f) => f.path);
-  if (tsFiles.length === 0) {
+  const polyglotFiles = files.filter((f) => !TS_EXTENSIONS.has(f.extension)).map((f) => ({ relativePath: f.relativePath, absolutePath: f.path }));
+  const polyglotEdges = parseAllPolyglotImports(polyglotFiles, absPath);
+  if (tsFiles.length === 0 && polyglotEdges.length === 0) {
     return emptyGraph(files);
   }
   let project;
@@ -138,7 +1635,7 @@ function buildProjectGraph(projectPath, files) {
   const edges = [];
   const nodeSet = /* @__PURE__ */ new Set();
   for (const sourceFile of project.getSourceFiles()) {
-    const fromRel = relative(absPath, sourceFile.getFilePath());
+    const fromRel = relative2(absPath, sourceFile.getFilePath());
     if (fromRel.startsWith("..") || fromRel.includes("node_modules")) continue;
     nodeSet.add(fromRel);
     for (const imp of sourceFile.getImportDeclarations()) {
@@ -160,6 +1657,11 @@ function buildProjectGraph(projectPath, files) {
       }
     }
   }
+  for (const edge of polyglotEdges) {
+    nodeSet.add(edge.from);
+    nodeSet.add(edge.to);
+    edges.push(edge);
+  }
   const nodes = Array.from(nodeSet);
   const importedByCount = /* @__PURE__ */ new Map();
   const importCount = /* @__PURE__ */ new Map();
@@ -192,6 +1694,7 @@ function buildProjectGraph(projectPath, files) {
   const orphans = Array.from(allFileNodes).filter((n) => !connectedNodes.has(n));
   const clusters = detectClusters(nodes, edges, files);
   enrichComplexity(project, absPath, files);
+  enrichPolyglotComplexity(files);
   return { nodes, edges, hubs, leaves, orphans, clusters };
 }
 var UnionFind = class {
@@ -284,7 +1787,7 @@ function commonPrefix(paths) {
 function enrichComplexity(project, absPath, files) {
   const fileMap = new Map(files.map((f) => [f.relativePath, f]));
   for (const sourceFile of project.getSourceFiles()) {
-    const relPath = relative(absPath, sourceFile.getFilePath());
+    const relPath = relative2(absPath, sourceFile.getFilePath());
     if (relPath.startsWith("..") || relPath.includes("node_modules")) continue;
     const file = fileMap.get(relPath);
     if (!file) continue;
@@ -335,22 +1838,34 @@ function calculateCyclomaticComplexity(node) {
   });
   return complexity;
 }
+function enrichPolyglotComplexity(files) {
+  for (const file of files) {
+    if (TS_EXTENSIONS.has(file.extension)) continue;
+    const lang = detectLanguage(file.relativePath);
+    if (!lang) continue;
+    try {
+      const content = readFileSync2(file.path, "utf-8");
+      file.complexity = Math.max(1, estimateComplexity(content, lang));
+    } catch {
+    }
+  }
+}
 function resolveImport(sourceFile, moduleSpecifier, projectRoot) {
   if (!moduleSpecifier.startsWith(".")) return null;
-  const sourceDir = dirname(sourceFile.getFilePath());
-  const basePath = resolve(sourceDir, moduleSpecifier);
+  const sourceDir = dirname2(sourceFile.getFilePath());
+  const basePath = resolve2(sourceDir, moduleSpecifier);
   const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
   for (const ext of extensions) {
     const candidate = basePath.endsWith(ext) ? basePath : basePath + ext;
-    if (existsSync(candidate)) {
-      const rel = relative(projectRoot, candidate);
+    if (existsSync2(candidate)) {
+      const rel = relative2(projectRoot, candidate);
       if (!rel.startsWith("..")) return rel;
     }
   }
   if (moduleSpecifier.endsWith(".js")) {
     const tsPath = basePath.replace(/\.js$/, ".ts");
-    if (existsSync(tsPath)) {
-      const rel = relative(projectRoot, tsPath);
+    if (existsSync2(tsPath)) {
+      const rel = relative2(projectRoot, tsPath);
       if (!rel.startsWith("..")) return rel;
     }
   }
@@ -486,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;
     }
   }
@@ -510,7 +2029,7 @@ async function walkProject(rootPath, options) {
     }
     const promises = [];
     for (const entry of entries) {
-      const fullPath = join2(dir, entry.name);
+      const fullPath = join3(dir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirSet.has(entry.name) && !entry.name.startsWith(".")) {
           promises.push(walk(fullPath, depth + 1));
@@ -531,7 +2050,7 @@ async function walkProject(rootPath, options) {
               }
               results.push({
                 path: fullPath,
-                relativePath: relative2(rootPath, fullPath),
+                relativePath: relative3(rootPath, fullPath),
                 extension: ext,
                 size: fileStat.size,
                 lastModified: fileStat.mtime,
@@ -580,7 +2099,7 @@ function detectStack(files) {
   return stack;
 }
 async function analyzeProject(projectPath, config) {
-  const absPath = resolve2(projectPath);
+  const absPath = resolve3(projectPath);
   const projectName = basename2(absPath);
   const mergedConfig = mergeConfig(DEFAULT_CONFIG, config);
   const allExtensions = [
@@ -714,13 +2233,90 @@ function mergeConfig(base, overrides) {
   };
 }
 
-// src/engine/selector.ts
-import { createHash as createHash3 } from "crypto";
+// src/engine/learner.ts
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
+import { join as join4 } from "path";
+var MODEL_DIR = ".cto";
+var MODEL_FILE = "learner.json";
+var MIN_OBSERVATIONS = 3;
+async function loadLearner(projectPath) {
+  const modelPath = join4(projectPath, MODEL_DIR, MODEL_FILE);
+  try {
+    const raw = await readFile3(modelPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 2) return parsed;
+  } catch {
+  }
+  return createEmptyModel();
+}
+function getLearnerBoosts(model, taskType, files) {
+  if (model.totalSelections < MIN_OBSERVATIONS) return [];
+  const boosts = [];
+  const taskPatterns = model.taskPatterns[taskType] ?? {};
+  for (const file of files) {
+    const pattern = extractPattern(file);
+    const taskStats = taskPatterns[pattern];
+    const globalStats = model.patterns[pattern];
+    const stats = taskStats ?? globalStats;
+    if (!stats) continue;
+    const total = stats.alpha + stats.beta;
+    if (total < MIN_OBSERVATIONS) continue;
+    const p = stats.alpha / total;
+    const z2 = 1.96;
+    const denominator = 1 + z2 * z2 / total;
+    const center = p + z2 * z2 / (2 * total);
+    const spread = z2 * Math.sqrt((p * (1 - p) + z2 * z2 / (4 * total)) / total);
+    const lower = (center - spread) / denominator;
+    const boost = (lower - 0.5) * 2;
+    const confidence = Math.min(1, total / 20);
+    if (Math.abs(boost) > 0.05) {
+      boosts.push({
+        filePath: file,
+        boost,
+        confidence,
+        reason: taskStats ? `${pattern} selected ${Math.round(p * 100)}% of the time for ${taskType} tasks` : `${pattern} selected ${Math.round(p * 100)}% of the time globally`
+      });
+    }
+  }
+  return boosts.sort((a, b) => Math.abs(b.boost) - Math.abs(a.boost));
+}
+function createEmptyModel() {
+  return {
+    version: 2,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    patterns: {},
+    taskPatterns: {},
+    totalSelections: 0
+  };
+}
+function extractPattern(filePath) {
+  const parts = filePath.split("/");
+  const fileName = parts[parts.length - 1];
+  const ext = fileName.includes(".") ? "." + fileName.split(".").pop() : "";
+  if (fileName.includes(".test.") || fileName.includes(".spec.")) {
+    const testExt = fileName.includes(".test.") ? ".test" + ext : ".spec" + ext;
+    if (parts.includes("tests") || parts.includes("test") || parts.includes("__tests__")) {
+      return `tests/**/*${testExt}`;
+    }
+    return `*${testExt}`;
+  }
+  if (["config", "configuration", "settings"].some((c) => fileName.toLowerCase().includes(c))) {
+    return `config/*${ext}`;
+  }
+  if (fileName.endsWith(".d.ts") || parts.includes("types") || parts.includes("typings")) {
+    return `types/*${ext}`;
+  }
+  const meaningfulDirs = parts.slice(0, -1).filter((d) => d !== "src" && d !== "lib" && d !== "app");
+  if (meaningfulDirs.length > 0) {
+    return `${meaningfulDirs[0]}/*${ext}`;
+  }
+  return `*${ext}`;
+}
 
 // src/govern/secrets.ts
-import { readFile as readFile3 } from "fs/promises";
-import { readFileSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
-import { resolve as resolve3, relative as relative3, join as join3, dirname as dirname2 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolve4, relative as relative4, join as join5, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 var BUILTIN_PATTERNS = [
   // API Keys
@@ -847,8 +2443,8 @@ function scanContentForSecrets(content, filePath, customPatterns = [], extraPiiS
 }
 async function scanFileForSecrets(filePath, projectPath, customPatterns = []) {
   try {
-    const content = await readFile3(filePath, "utf-8");
-    const relPath = relative3(resolve3(projectPath), resolve3(filePath));
+    const content = await readFile4(filePath, "utf-8");
+    const relPath = relative4(resolve4(projectPath), resolve4(filePath));
     return scanContentForSecrets(content, relPath, customPatterns);
   } catch {
     return [];
@@ -941,8 +2537,42 @@ function deduplicateFindings(findings) {
   });
 }
 
+// src/interact/router.ts
+var TASK_KEYWORDS = {
+  debug: ["debug", "fix", "bug", "error", "issue", "broken", "crash", "failing", "wrong"],
+  review: ["review", "check", "assess", "evaluate", "audit", "inspect", "critique"],
+  refactor: ["refactor", "restructure", "reorganize", "clean up", "simplify", "extract", "move"],
+  test: ["test", "spec", "coverage", "unit test", "integration test", "e2e"],
+  docs: ["document", "docs", "readme", "jsdoc", "comment", "explain"],
+  feature: ["add", "implement", "create", "build", "new", "feature", "endpoint"],
+  architecture: ["architecture", "design", "system", "structure", "migrate", "pattern"],
+  "simple-edit": ["rename", "typo", "update", "change", "modify", "tweak", "adjust"]
+};
+function classifyTask(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  let bestType = "simple-edit";
+  let bestScore = 0;
+  for (const [type, keywords] of Object.entries(TASK_KEYWORDS)) {
+    let score = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+  return bestType;
+}
+
+// src/engine/context-pipeline.ts
+import { readFileSync as readFileSync6 } from "fs";
+
+// src/engine/selector.ts
+import { createHash as createHash3 } from "crypto";
+
 // src/engine/pruner.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs"]);
 async function pruneFile(file, level) {
   if (level === "excluded") {
@@ -961,7 +2591,7 @@ async function pruneFile(file, level) {
 async function pruneTypeScript(file, level) {
   let content;
   try {
-    content = await readFile4(file.path, "utf-8");
+    content = await readFile5(file.path, "utf-8");
   } catch {
     return emptyResult(file, level);
   }
@@ -1255,7 +2885,7 @@ function extractClassOutline(lines, start) {
 async function pruneGeneric(file, level) {
   let content;
   try {
-    content = await readFile4(file.path, "utf-8");
+    content = await readFile5(file.path, "utf-8");
   } catch {
     return emptyResult(file, level);
   }
@@ -1290,7 +2920,7 @@ function pruneGenericFromContent(file, content, level) {
 async function fullContent(file) {
   let content = "";
   try {
-    content = await readFile4(file.path, "utf-8");
+    content = await readFile5(file.path, "utf-8");
   } catch {
   }
   return {
@@ -1442,19 +3072,8 @@ async function selectContext(input) {
   for (const s of input.semanticScores ?? []) semanticMap.set(s.filePath, s.score);
   const learnerMap = /* @__PURE__ */ new Map();
   for (const b of input.learnerBoosts ?? []) learnerMap.set(b.filePath, b.boost);
-  let targetPaths = identifyTargetFiles(task, analysis.files);
-  if (targetPaths.length === 0 && semanticMap.size > 0) {
-    const sorted = [...semanticMap.entries()].sort((a, b) => b[1] - a[1]);
-    const threshold = 0.5;
-    targetPaths = sorted.filter(([, score]) => score >= threshold).slice(0, 10).map(([path]) => path);
-    if (targetPaths.length > 0) {
-      decisions.push({
-        file: targetPaths.join(", "),
-        action: "include-full",
-        reason: `Top ${targetPaths.length} file(s) identified via semantic matching (score \u2265 ${threshold})`
-      });
-    }
-  } else if (targetPaths.length > 0) {
+  const targetPaths = identifyTargetFiles(task, analysis.files);
+  if (targetPaths.length > 0) {
     decisions.push({
       file: targetPaths.join(", "),
       action: "include-full",
@@ -1486,7 +3105,7 @@ async function selectContext(input) {
   }
   const { mustInclude, mustExclude } = applyPolicies(analysis.files, policies);
   const candidateSet = /* @__PURE__ */ new Set([...expandedPaths, ...mustInclude]);
-  if (targetPaths.length === 0) {
+  if (semanticMap.size > 0 || targetPaths.length === 0) {
     for (const f of analysis.files) {
       candidateSet.add(f.relativePath);
     }
@@ -1525,22 +3144,34 @@ async function selectContext(input) {
     const riskNorm = file.riskScore / maxRisk;
     const semantic = semanticMap.get(file.relativePath) ?? 0;
     const learner = ((learnerMap.get(file.relativePath) ?? 0) + 1) / 2;
-    return riskNorm * 0.4 + semantic * 0.4 + learner * 0.2;
+    return semantic * 0.55 + riskNorm * 0.25 + learner * 0.2;
   }
+  const targetSet = new Set(targetPaths);
   const candidates = Array.from(candidateSet).map((p) => allFileMap.get(p)).filter((f) => f !== void 0).sort((a, b) => {
-    const aIsTarget = targetPaths.includes(a.relativePath) ? 0 : 1;
-    const bIsTarget = targetPaths.includes(b.relativePath) ? 0 : 1;
-    if (aIsTarget !== bIsTarget) return aIsTarget - bIsTarget;
-    const aIsMust = mustInclude.has(a.relativePath) ? 0 : 1;
-    const bIsMust = mustInclude.has(b.relativePath) ? 0 : 1;
-    if (aIsMust !== bIsMust) return aIsMust - bIsMust;
-    return compositeScore(b) - compositeScore(a);
+    const aBonus = (targetSet.has(a.relativePath) ? 0.3 : 0) + (mustInclude.has(a.relativePath) ? 0.15 : 0);
+    const bBonus = (targetSet.has(b.relativePath) ? 0.3 : 0) + (mustInclude.has(b.relativePath) ? 0.15 : 0);
+    return compositeScore(b) + bBonus - (compositeScore(a) + aBonus);
   });
   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 = targetPaths.includes(file.relativePath);
+    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 < semanticFloor && lrnBoost <= 0) {
+        decisions.push({
+          file: file.relativePath,
+          action: "exclude",
+          reason: `Skipped: semantic score ${semScore.toFixed(3)} below floor ${semanticFloor.toFixed(3)}`
+        });
+        continue;
+      }
+    }
     const defaultLevel = isTarget ? "full" : getPruneLevelForRisk(file.riskScore);
     const levels = getCascadeLevels(defaultLevel);
     let included = false;
@@ -1664,370 +3295,2105 @@ function buildReason(file, level, isTarget, isMustInclude) {
   return `Low relevance (risk ${file.riskScore}) \u2014 ${levelStr}`;
 }
 
-// src/engine/tfidf.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  // Language keywords
-  "import",
-  "export",
-  "from",
-  "const",
-  "let",
-  "var",
-  "function",
-  "class",
-  "interface",
-  "type",
-  "return",
-  "async",
-  "await",
+// 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";
+import { join as join6 } from "path";
+var CACHE_VERSION = 2;
+var CACHE_DIR = ".cto";
+var CACHE_FILE = "index-cache.json";
+function buildIndexCached(projectPath, files) {
+  const startTime = Date.now();
+  const cachePath = join6(projectPath, CACHE_DIR, CACHE_FILE);
+  const existing = loadCache(cachePath);
+  const cacheHit = existing !== null;
+  const cachedFiles = existing?.files ?? {};
+  const newCachedFiles = {};
+  let updatedFiles = 0;
+  let removedFiles = 0;
+  let cachedCount = 0;
+  const currentPaths = new Set(files.map((f) => f.relativePath));
+  if (existing) {
+    for (const path of Object.keys(cachedFiles)) {
+      if (!currentPaths.has(path)) {
+        removedFiles++;
+      }
+    }
+  }
+  for (const file of files) {
+    const cached = cachedFiles[file.relativePath];
+    let currentMtime = 0;
+    try {
+      const st = statSync(file.absolutePath);
+      currentMtime = st.mtimeMs;
+    } catch {
+      continue;
+    }
+    if (cached && cached.mtime === currentMtime) {
+      newCachedFiles[file.relativePath] = cached;
+      cachedCount++;
+    } else {
+      let content = file.content;
+      if (content === void 0) {
+        try {
+          content = readFileSync4(file.absolutePath, "utf-8");
+        } catch {
+          continue;
+        }
+      }
+      const terms = tokenize(content);
+      const termCounts = {};
+      for (const term of terms) {
+        termCounts[term] = (termCounts[term] ?? 0) + 1;
+      }
+      newCachedFiles[file.relativePath] = {
+        mtime: currentMtime,
+        terms: termCounts,
+        length: terms.length
+      };
+      updatedFiles++;
+    }
+  }
+  const index = rebuildIndex(newCachedFiles);
+  saveCache(cachePath, newCachedFiles);
+  const stats = {
+    totalFiles: Object.keys(newCachedFiles).length,
+    updatedFiles,
+    removedFiles,
+    cachedFiles: cachedCount,
+    cacheHit,
+    buildTimeMs: Date.now() - startTime
+  };
+  return { index, stats };
+}
+function loadCache(cachePath) {
+  try {
+    if (!existsSync4(cachePath)) return null;
+    const raw = readFileSync4(cachePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version !== CACHE_VERSION) return null;
+    if (!data.files || typeof data.files !== "object") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCache(cachePath, files) {
+  try {
+    const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const data = {
+      version: CACHE_VERSION,
+      builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files
+    };
+    writeFileSync2(cachePath, JSON.stringify(data));
+  } catch {
+  }
+}
+function rebuildIndex(cachedFiles) {
+  const documents = /* @__PURE__ */ new Map();
+  const docFreq = /* @__PURE__ */ new Map();
+  let totalLength = 0;
+  for (const [path, cached] of Object.entries(cachedFiles)) {
+    const termMap = /* @__PURE__ */ new Map();
+    for (const [term, count] of Object.entries(cached.terms)) {
+      termMap.set(term, count);
+    }
+    documents.set(path, { terms: termMap, length: cached.length });
+    totalLength += cached.length;
+    for (const term of termMap.keys()) {
+      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const totalDocs = documents.size;
+  const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
+  const idf = /* @__PURE__ */ new Map();
+  for (const [term, df] of docFreq) {
+    idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
+  }
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
+}
+
+// src/engine/reranker.ts
+init_tfidf();
+var WEIGHTS = {
+  termCoverage: 0.35,
+  // What fraction of query terms does the file match?
+  termSpecificity: 0.25,
+  // Are matched terms rare or common?
+  bigramProximity: 0.15,
+  // Do query terms appear near each other?
+  dependencySignal: 0.1,
+  // Is this file connected to a top match?
+  pathRelevance: 0.15
+  // Does the file path match query terms?
+};
+var ABSOLUTE_FLOOR = 0.18;
+var ELBOW_DROP_RATIO = 0.35;
+var MIN_TERM_COVERAGE = 0.3;
+function rerank(input) {
+  const startTime = Date.now();
+  const { task, candidates, index, fileContents, dependencies, allFilePaths } = input;
+  const emptyTelemetry = {
+    candidatesIn: candidates.length,
+    candidatesOut: 0,
+    candidatesFiltered: 0,
+    durationMs: 0,
+    weights: { ...WEIGHTS },
+    gateConfig: { absoluteFloor: ABSOLUTE_FLOOR, elbowDropRatio: ELBOW_DROP_RATIO, minTermCoverage: MIN_TERM_COVERAGE },
+    signalStats: {
+      termCoverage: { min: 0, max: 0, mean: 0, median: 0 },
+      termSpecificity: { min: 0, max: 0, mean: 0, median: 0 },
+      bigramProximity: { min: 0, max: 0, mean: 0, median: 0 },
+      dependencySignal: { min: 0, max: 0, mean: 0, median: 0 },
+      pathRelevance: { min: 0, max: 0, mean: 0, median: 0 }
+    },
+    filterReasons: {},
+    scoreDistribution: [0, 0, 0, 0, 0],
+    queryTermCount: 0,
+    relevanceConeSize: 0
+  };
+  if (candidates.length === 0) {
+    return { files: [], filtered: [], qualityThreshold: 0, telemetry: { ...emptyTelemetry, durationMs: Date.now() - startTime } };
+  }
+  const queryTerms = tokenize(task);
+  const uniqueQueryTerms = [...new Set(queryTerms)];
+  if (uniqueQueryTerms.length === 0) {
+    return { files: [], filtered: [], qualityThreshold: 0, telemetry: { ...emptyTelemetry, durationMs: Date.now() - startTime } };
+  }
+  const queryTermIdfs = /* @__PURE__ */ new Map();
+  for (const term of uniqueQueryTerms) {
+    queryTermIdfs.set(term, index.idf.get(term) ?? 0);
+  }
+  const maxIdf = Math.max(1, ...queryTermIdfs.values());
+  const pathTermsCache = /* @__PURE__ */ new Map();
+  for (const fp of allFilePaths) {
+    pathTermsCache.set(fp, new Set(tokenize(fp.replace(/[/\\.]/g, " "))));
+  }
+  const scored = [];
+  for (const candidate of candidates) {
+    const doc = index.documents.get(candidate.filePath);
+    if (!doc) continue;
+    const matchedQueryTerms = /* @__PURE__ */ new Set();
+    for (const term of uniqueQueryTerms) {
+      if ((doc.terms.get(term) ?? 0) > 0) {
+        matchedQueryTerms.add(term);
+      }
+    }
+    const termCoverage = matchedQueryTerms.size / uniqueQueryTerms.length;
+    let specificitySum = 0;
+    let specificityMax = 0;
+    for (const term of matchedQueryTerms) {
+      const idf = queryTermIdfs.get(term) ?? 0;
+      specificitySum += idf;
+      specificityMax += maxIdf;
+    }
+    const termSpecificity = specificityMax > 0 ? specificitySum / specificityMax : 0;
+    const content = fileContents.get(candidate.filePath) ?? "";
+    const bigramProximity = computeBigramProximity(content, uniqueQueryTerms);
+    const dependencySignal = 0;
+    const pathTerms = pathTermsCache.get(candidate.filePath) ?? /* @__PURE__ */ new Set();
+    const queryTermSet = new Set(uniqueQueryTerms);
+    let pathHits = 0;
+    for (const pt of pathTerms) {
+      if (queryTermSet.has(pt)) pathHits++;
+    }
+    const pathRelevance = Math.min(1, pathHits / Math.max(1, uniqueQueryTerms.length) * 2);
+    const score = termCoverage * WEIGHTS.termCoverage + termSpecificity * WEIGHTS.termSpecificity + bigramProximity * WEIGHTS.bigramProximity + dependencySignal * WEIGHTS.dependencySignal + pathRelevance * WEIGHTS.pathRelevance;
+    scored.push({
+      filePath: candidate.filePath,
+      score,
+      bm25Score: candidate.score,
+      signals: {
+        termCoverage,
+        termSpecificity,
+        bigramProximity,
+        dependencySignal,
+        pathRelevance
+      }
+    });
+  }
+  const topByScore = [...scored].sort((a, b) => b.score - a.score).slice(0, 5);
+  const relevanceCone = /* @__PURE__ */ new Set();
+  for (const top of topByScore) {
+    relevanceCone.add(top.filePath);
+    const deps = dependencies.get(top.filePath) ?? [];
+    for (const dep of deps) relevanceCone.add(dep);
+    for (const [from, tos] of dependencies) {
+      if (tos.includes(top.filePath)) relevanceCone.add(from);
+    }
+  }
+  for (const item of scored) {
+    const inCone = relevanceCone.has(item.filePath) ? 1 : 0;
+    item.signals.dependencySignal = inCone;
+    item.score = item.signals.termCoverage * WEIGHTS.termCoverage + item.signals.termSpecificity * WEIGHTS.termSpecificity + item.signals.bigramProximity * WEIGHTS.bigramProximity + item.signals.dependencySignal * WEIGHTS.dependencySignal + item.signals.pathRelevance * WEIGHTS.pathRelevance;
+  }
+  scored.sort((a, b) => b.score - a.score);
+  const { passed, filtered, threshold } = applyQualityGate(scored);
+  const filterReasons = {};
+  for (const f of filtered) {
+    const reason = f.reason.replace(/\([^)]+\)/g, "").trim();
+    filterReasons[reason] = (filterReasons[reason] ?? 0) + 1;
+  }
+  const allScores = scored.map((s) => s.score).sort((a, b) => a - b);
+  const signalNames = ["termCoverage", "termSpecificity", "bigramProximity", "dependencySignal", "pathRelevance"];
+  const signalStats = {};
+  for (const name of signalNames) {
+    const vals = scored.map((s) => s.signals[name]).sort((a, b) => a - b);
+    signalStats[name] = {
+      min: vals[0] ?? 0,
+      max: vals[vals.length - 1] ?? 0,
+      mean: vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0,
+      median: vals.length > 0 ? vals[Math.floor(vals.length / 2)] : 0
+    };
+  }
+  const telemetry = {
+    candidatesIn: candidates.length,
+    candidatesOut: passed.length,
+    candidatesFiltered: filtered.length,
+    durationMs: Date.now() - startTime,
+    weights: { ...WEIGHTS },
+    gateConfig: { absoluteFloor: ABSOLUTE_FLOOR, elbowDropRatio: ELBOW_DROP_RATIO, minTermCoverage: MIN_TERM_COVERAGE },
+    signalStats,
+    filterReasons,
+    scoreDistribution: [
+      allScores[0] ?? 0,
+      allScores[Math.floor(allScores.length * 0.25)] ?? 0,
+      allScores[Math.floor(allScores.length * 0.5)] ?? 0,
+      allScores[Math.floor(allScores.length * 0.75)] ?? 0,
+      allScores[allScores.length - 1] ?? 0
+    ],
+    queryTermCount: uniqueQueryTerms.length,
+    relevanceConeSize: relevanceCone.size
+  };
+  return {
+    files: passed,
+    filtered,
+    qualityThreshold: threshold,
+    telemetry
+  };
+}
+function computeBigramProximity(content, queryTerms) {
+  if (queryTerms.length < 2 || !content) return 0;
+  const contentTokens = tokenize(content);
+  const termPositions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < contentTokens.length; i++) {
+    const token = contentTokens[i];
+    if (queryTerms.includes(token)) {
+      const positions = termPositions.get(token) ?? [];
+      positions.push(i);
+      termPositions.set(token, positions);
+    }
+  }
+  let totalScore = 0;
+  let pairCount = 0;
+  for (let i = 0; i < queryTerms.length; i++) {
+    for (let j = i + 1; j < queryTerms.length; j++) {
+      const posA = termPositions.get(queryTerms[i]);
+      const posB = termPositions.get(queryTerms[j]);
+      if (!posA || !posB) continue;
+      let minDist = Infinity;
+      for (const a of posA) {
+        for (const b of posB) {
+          minDist = Math.min(minDist, Math.abs(a - b));
+        }
+      }
+      if (minDist < Infinity) {
+        totalScore += Math.max(0, 1 - minDist / 20);
+        pairCount++;
+      }
+    }
+  }
+  return pairCount > 0 ? totalScore / pairCount : 0;
+}
+function applyQualityGate(scored) {
+  const passed = [];
+  const filtered = [];
+  if (scored.length === 0) {
+    return { passed, filtered, threshold: 0 };
+  }
+  let elbowIndex = scored.length;
+  if (scored.length >= 3) {
+    let maxDrop = 0;
+    for (let i = 1; i < scored.length; i++) {
+      if (scored[i - 1].score > 0) {
+        const drop = (scored[i - 1].score - scored[i].score) / scored[i - 1].score;
+        if (drop > maxDrop && drop >= ELBOW_DROP_RATIO) {
+          maxDrop = drop;
+          elbowIndex = i;
+        }
+      }
+    }
+  }
+  const threshold = Math.max(
+    ABSOLUTE_FLOOR,
+    elbowIndex < scored.length ? scored[elbowIndex].score : 0
+  );
+  for (let i = 0; i < scored.length; i++) {
+    const item = scored[i];
+    if (item.score < ABSOLUTE_FLOOR) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Below absolute floor (${item.score.toFixed(3)} < ${ABSOLUTE_FLOOR})` });
+      continue;
+    }
+    if (item.signals.termCoverage < MIN_TERM_COVERAGE) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Low term coverage (${(item.signals.termCoverage * 100).toFixed(0)}% < ${MIN_TERM_COVERAGE * 100}%)` });
+      continue;
+    }
+    if (i >= elbowIndex && item.score < scored[0].score * 0.5) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Below elbow cutoff (rank ${i + 1}, score ${item.score.toFixed(3)})` });
+      continue;
+    }
+    passed.push(item);
+  }
+  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",
-  "null",
-  "undefined",
-  "void",
   "string",
   "number",
   "boolean",
-  "any",
-  "unknown",
-  "never",
-  "object",
-  "array",
-  "promise",
-  "if",
-  "else",
-  "for",
-  "while",
-  "do",
-  "switch",
-  "case",
-  "break",
-  "continue",
-  "try",
-  "catch",
-  "throw",
-  "finally",
+  "int",
+  "impl",
   "default",
-  "extends",
-  "implements",
-  "static",
+  "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",
-  "readonly",
-  "abstract",
+  "static",
+  "final",
   "override",
-  "super",
-  "typeof",
-  "instanceof",
-  "in",
-  "of",
-  "as",
-  "is",
-  "keyof",
-  "enum",
-  "namespace",
-  "module",
-  "declare",
-  // Python
-  "def",
-  "self",
-  "cls",
-  "none",
-  "pass",
-  "yield",
-  "lambda",
-  "with",
-  "elif",
-  "except",
-  "raise",
-  "assert",
-  "global",
-  "nonlocal",
-  // Natural language stop words only — NOT domain terms that carry signal
+  "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",
-  "and",
-  "for",
-  "with",
-  "not",
-  "but",
+  "a",
+  "an",
+  "is",
   "are",
   "was",
   "were",
-  "has",
+  "be",
+  "been",
+  "being",
   "have",
+  "has",
   "had",
+  "do",
+  "does",
+  "did",
   "will",
   "would",
-  "could",
+  "shall",
   "should",
   "may",
+  "might",
+  "must",
   "can",
-  "its",
-  "also",
-  "than",
-  "then",
-  "into",
-  "only",
-  "very",
-  "just",
+  "could",
+  "need",
+  "not",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "for",
+  "yet",
+  "so",
+  "in",
+  "on",
+  "at",
+  "to",
+  "from",
+  "by",
+  "with",
   "about",
-  "being",
-  "been",
-  "does",
-  "did",
-  "doing",
-  "todo",
-  "fixme",
-  "hack",
-  "note",
-  "xxx"
+  "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"
 ]);
-function buildIndex(files) {
-  const documents = /* @__PURE__ */ new Map();
-  const docFreq = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const terms = tokenize(file.content);
-    const termCounts = /* @__PURE__ */ new Map();
-    for (const term of terms) {
-      termCounts.set(term, (termCounts.get(term) ?? 0) + 1);
-    }
-    documents.set(file.relativePath, { terms: termCounts, length: terms.length });
-    for (const term of termCounts.keys()) {
-      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
-    }
-  }
-  const totalDocs = files.length;
-  const idf = /* @__PURE__ */ new Map();
-  for (const [term, df] of docFreq) {
-    idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
+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);
   }
-  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 [...new Set(entities)];
 }
-function query(index, taskDescription, maxResults = 50) {
-  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);
-  }
-  const results = [];
-  const k1 = 1.5;
-  const b = 0.75;
-  for (const [filePath, doc] of index.documents) {
-    let score = 0;
-    const matchedTerms = [];
-    for (const [qTerm, qCount] of querySet) {
-      const tf = doc.terms.get(qTerm) ?? 0;
-      if (tf === 0) continue;
-      const termIdf = index.idf.get(qTerm) ?? 0;
-      if (termIdf <= 0) continue;
-      const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / index.avgDocLength));
-      score += termIdf * tfNorm * qCount;
-      matchedTerms.push(qTerm);
-    }
-    if (score > 0) {
-      results.push({ filePath, score, matchedTerms });
+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 maxScore = results.reduce((max, r) => Math.max(max, r.score), 0);
-  if (maxScore > 0) {
-    for (const r of results) r.score = r.score / maxScore;
+  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 results.sort((a, b2) => b2.score - a.score).slice(0, maxResults);
+  return [...new Set(operations)];
 }
-function tokenize(text) {
-  const tokens = [];
-  const rawTokens = text.match(/[a-zA-Z][a-zA-Z0-9]*|[0-9]+/g) ?? [];
-  for (const raw of rawTokens) {
-    const parts = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
-    for (const part of parts) {
-      if (part.length < 2) continue;
-      const stemmed = stem(part);
-      if (stemmed.length < 2) continue;
-      if (STOP_WORDS.has(stemmed)) continue;
-      tokens.push(stemmed);
+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 tokens;
+  return [...new Set(qualifiers)];
 }
-function stem(word) {
-  let w = word.toLowerCase();
-  if (w.endsWith("tion")) return w.slice(0, -4);
-  if (w.endsWith("sion")) return w.slice(0, -4);
-  if (w.endsWith("ment")) return w.slice(0, -4);
-  if (w.endsWith("ness")) return w.slice(0, -4);
-  if (w.endsWith("able")) return w.slice(0, -4);
-  if (w.endsWith("ible")) return w.slice(0, -4);
-  if (w.endsWith("ator")) return w.slice(0, -4);
-  if (w.endsWith("izer")) return w.slice(0, -4);
-  if (w.endsWith("ling")) return w.slice(0, -4);
-  if (w.endsWith("ing") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ies") && w.length > 4) return w.slice(0, -3) + "y";
-  if (w.endsWith("ous") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ful") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ess") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ity") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ive") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ed") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("er") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("ly") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("al") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("s") && !w.endsWith("ss") && w.length > 3) return w.slice(0, -1);
-  return w;
+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 boostByPath(matches, allFiles, taskDescription) {
-  const queryTerms = new Set(tokenize(taskDescription));
-  const boosted = /* @__PURE__ */ new Map();
-  for (const m of matches) {
-    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+function buildWeightedQuery(intent) {
+  const parts = [];
+  for (const entity of intent.entities) {
+    parts.push(entity, entity, entity);
   }
-  for (const filePath of allFiles) {
-    const pathTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
-    const pathMatches = pathTerms.filter((t) => queryTerms.has(t));
-    if (pathMatches.length > 0) {
-      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) {
-          if (!existing.matchedTerms.includes(t)) existing.matchedTerms.push(t);
+  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];
         }
-      } else {
-        boosted.set(filePath, {
-          filePath,
-          score: Math.min(1, pathBoost),
-          matchedTerms: pathMatches
-        });
+      }
+      if (dot > 0) {
+        results.push({ filePath, score: dot });
       }
     }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
   }
-  return [...boosted.values()].sort((a, b) => b.score - a.score);
+  return {
+    backend: "tfidf-cosine",
+    dimensions,
+    documentCount: docVectors.size,
+    query: queryFn
+  };
 }
-
-// src/engine/learner.ts
-import { readFile as readFile5, writeFile as writeFile2, mkdir } from "fs/promises";
-import { join as join4 } from "path";
-var MODEL_DIR = ".cto";
-var MODEL_FILE = "learner.json";
-var MIN_OBSERVATIONS = 3;
-async function loadLearner(projectPath) {
-  const modelPath = join4(projectPath, MODEL_DIR, MODEL_FILE);
-  try {
-    const raw = await readFile5(modelPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version === 2) return parsed;
-  } catch {
+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);
   }
-  return createEmptyModel();
+  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 getLearnerBoosts(model, taskType, files) {
-  if (model.totalSelections < MIN_OBSERVATIONS) return [];
-  const boosts = [];
-  const taskPatterns = model.taskPatterns[taskType] ?? {};
-  for (const file of files) {
-    const pattern = extractPattern(file);
-    const taskStats = taskPatterns[pattern];
-    const globalStats = model.patterns[pattern];
-    const stats = taskStats ?? globalStats;
-    if (!stats) continue;
-    const total = stats.alpha + stats.beta;
-    if (total < MIN_OBSERVATIONS) continue;
-    const p = stats.alpha / total;
-    const z2 = 1.96;
-    const denominator = 1 + z2 * z2 / total;
-    const center = p + z2 * z2 / (2 * total);
-    const spread = z2 * Math.sqrt((p * (1 - p) + z2 * z2 / (4 * total)) / total);
-    const lower = (center - spread) / denominator;
-    const boost = (lower - 0.5) * 2;
-    const confidence = Math.min(1, total / 20);
-    if (Math.abs(boost) > 0.05) {
-      boosts.push({
-        filePath: file,
-        boost,
-        confidence,
-        reason: taskStats ? `${pattern} selected ${Math.round(p * 100)}% of the time for ${taskType} tasks` : `${pattern} selected ${Math.round(p * 100)}% of the time globally`
-      });
-    }
+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 boosts.sort((a, b) => Math.abs(b.boost) - Math.abs(a.boost));
+  return 1;
 }
-function createEmptyModel() {
-  return {
-    version: 2,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    patterns: {},
-    taskPatterns: {},
-    totalSelections: 0
-  };
+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;
 }
-function extractPattern(filePath) {
-  const parts = filePath.split("/");
-  const fileName = parts[parts.length - 1];
-  const ext = fileName.includes(".") ? "." + fileName.split(".").pop() : "";
-  if (fileName.includes(".test.") || fileName.includes(".spec.")) {
-    const testExt = fileName.includes(".test.") ? ".test" + ext : ".spec" + ext;
-    if (parts.includes("tests") || parts.includes("test") || parts.includes("__tests__")) {
-      return `tests/**/*${testExt}`;
+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) {
+    try {
+      const content = readFileSync6(file.path, "utf-8");
+      fileContentMap.set(file.relativePath, content);
+      fileContents.push({ relativePath: file.relativePath, content });
+    } catch {
+      fileContents.push({ relativePath: file.relativePath, content: "" });
     }
-    return `*${testExt}`;
   }
-  if (["config", "configuration", "settings"].some((c) => fileName.toLowerCase().includes(c))) {
-    return `config/*${ext}`;
+  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 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);
   }
-  if (fileName.endsWith(".d.ts") || parts.includes("types") || parts.includes("typings")) {
-    return `types/*${ext}`;
+  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 meaningfulDirs = parts.slice(0, -1).filter((d) => d !== "src" && d !== "lib" && d !== "app");
-  if (meaningfulDirs.length > 0) {
-    return `${meaningfulDirs[0]}/*${ext}`;
+  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,
+    index,
+    fileContents: fileContentMap,
+    dependencies: depMap,
+    allFilePaths: analysis.files.map((f) => f.relativePath)
+  });
+  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);
   }
-  return `*${ext}`;
-}
-
-// src/interact/router.ts
-var TASK_KEYWORDS = {
-  debug: ["debug", "fix", "bug", "error", "issue", "broken", "crash", "failing", "wrong"],
-  review: ["review", "check", "assess", "evaluate", "audit", "inspect", "critique"],
-  refactor: ["refactor", "restructure", "reorganize", "clean up", "simplify", "extract", "move"],
-  test: ["test", "spec", "coverage", "unit test", "integration test", "e2e"],
-  docs: ["document", "docs", "readme", "jsdoc", "comment", "explain"],
-  feature: ["add", "implement", "create", "build", "new", "feature", "endpoint"],
-  architecture: ["architecture", "design", "system", "structure", "migrate", "pattern"],
-  "simple-edit": ["rename", "typo", "update", "change", "modify", "tweak", "adjust"]
-};
-function classifyTask(taskDescription) {
-  const lower = taskDescription.toLowerCase();
-  let bestType = "simple-edit";
-  let bestScore = 0;
-  for (const [type, keywords] of Object.entries(TASK_KEYWORDS)) {
-    let score = 0;
-    for (const kw of keywords) {
-      if (lower.includes(kw)) score++;
-    }
-    if (score > bestScore) {
-      bestScore = score;
-      bestType = type;
-    }
+  const learner = await loadLearner(projectPath);
+  const learnerBoosts = getLearnerBoosts(
+    learner,
+    taskType,
+    analysis.files.map((f) => f.relativePath)
+  );
+  const semanticScores = rerankedMatches.map((m) => ({ filePath: m.filePath, score: m.score }));
+  const learnerBoostInputs = learnerBoosts.map((b) => ({ filePath: b.filePath, boost: b.boost }));
+  const selection = await selectContext({
+    task,
+    analysis,
+    budget,
+    semanticScores,
+    learnerBoosts: learnerBoostInputs
+  });
+  const semanticMap = new Map(rerankedMatches.map((m) => [m.filePath, m]));
+  const learnerMap = new Map(learnerBoosts.map((b) => [b.filePath, b]));
+  let multiRepo;
+  if (input.siblingRepos && input.siblingRepos.length > 0) {
+    const { querySiblingRepos: querySiblingRepos2 } = await Promise.resolve().then(() => (init_multi_repo(), multi_repo_exports));
+    multiRepo = querySiblingRepos2(input.siblingRepos, task, 5, 0.3);
   }
-  return bestType;
+  return { selection, taskType, fileContentMap, semanticMap, learnerMap, queryIntent, multiRepo, indexCacheStats };
 }
 
 // src/mcp/index.ts
 var server = new McpServer({
   name: "cto",
-  version: "6.0.0"
+  version: "6.1.0"
 });
 var lastAnalysis = null;
 var lastProjectPath = null;
 async function getAnalysis(projectPath) {
-  const absPath = resolve4(projectPath);
+  const absPath = resolve6(projectPath);
   if (lastAnalysis && lastProjectPath === absPath) return lastAnalysis;
   lastAnalysis = await analyzeProject(absPath);
   lastProjectPath = absPath;
@@ -2048,35 +5414,10 @@ server.tool(
   },
   async ({ projectPath, task, budget, includeContents }) => {
     try {
-      const absPath = resolve4(projectPath);
+      const absPath = resolve6(projectPath);
       const analysis = await getAnalysis(absPath);
       const tokenBudget = budget ?? 5e4;
-      const taskType = classifyTask(task);
-      const fileContents = [];
-      for (const file of analysis.files) {
-        try {
-          const content = readFileSync2(file.path, "utf-8");
-          fileContents.push({ relativePath: file.relativePath, content });
-        } catch {
-          fileContents.push({ relativePath: file.relativePath, content: "" });
-        }
-      }
-      const index = buildIndex(fileContents);
-      const semanticMatches = query(index, task, 50);
-      const boosted = boostByPath(semanticMatches, analysis.files.map((f) => f.relativePath), task);
-      const semanticMap = new Map(boosted.map((m) => [m.filePath, m]));
-      const learner = await loadLearner(absPath);
-      const learnerBoosts = getLearnerBoosts(learner, taskType, analysis.files.map((f) => f.relativePath));
-      const learnerMap = new Map(learnerBoosts.map((b) => [b.filePath, b]));
-      const semanticScores = boosted.map((m) => ({ filePath: m.filePath, score: m.score }));
-      const learnerBoostInputs = learnerBoosts.map((b) => ({ filePath: b.filePath, boost: b.boost }));
-      const selection = await selectContext({
-        task,
-        analysis,
-        budget: tokenBudget,
-        semanticScores,
-        learnerBoosts: learnerBoostInputs
-      });
+      const { selection, taskType, fileContentMap, semanticMap, learnerMap } = await runContextPipeline({ projectPath: absPath, task, analysis, budget: tokenBudget });
       const files = selection.files.map((f) => {
         const sem = semanticMap.get(f.relativePath);
         const lb = learnerMap.get(f.relativePath);
@@ -2090,11 +5431,11 @@ server.tool(
           learnerBoost: lb?.boost ?? 0
         };
         if (includeContents) {
-          const fc = fileContents.find((c) => c.relativePath === f.relativePath);
-          entry.content = sanitizeContent(fc?.content ?? "");
+          entry.content = sanitizeContent(fileContentMap.get(f.relativePath) ?? "");
         }
         return entry;
       });
+      const learner = await loadLearner(absPath);
       const result = {
         task,
         taskType,
@@ -2121,7 +5462,7 @@ server.tool(
   },
   async ({ projectPath, files }) => {
     try {
-      const absPath = resolve4(projectPath);
+      const absPath = resolve6(projectPath);
       const analysis = await getAnalysis(absPath);
       const filePaths = files ?? analysis.files.map((f) => f.path);
       const findings = await scanProjectForSecrets(absPath, filePaths);
@@ -2156,42 +5497,21 @@ server.tool(
   },
   async ({ projectPath, task, filePath }) => {
     try {
-      const absPath = resolve4(projectPath);
+      const absPath = resolve6(projectPath);
       const analysis = await getAnalysis(absPath);
       const taskType = classifyTask(task);
       const file = analysis.files.find((f) => f.relativePath === filePath);
       if (!file) {
         return { content: [{ type: "text", text: `File not found in project: ${filePath}` }] };
       }
-      const fileContents = [];
-      for (const f of analysis.files) {
-        try {
-          fileContents.push({ relativePath: f.relativePath, content: readFileSync2(f.path, "utf-8") });
-        } catch {
-          fileContents.push({ relativePath: f.relativePath, content: "" });
-        }
-      }
-      const idx = buildIndex(fileContents);
-      const semMatches = query(idx, task, 50);
-      const boosted = boostByPath(semMatches, analysis.files.map((f) => f.relativePath), task);
-      const semanticScores = boosted.map((m) => ({ filePath: m.filePath, score: m.score }));
-      const learner = await loadLearner(absPath);
-      const allBoosts = getLearnerBoosts(learner, taskType, analysis.files.map((f) => f.relativePath));
-      const learnerBoostInputs = allBoosts.map((b) => ({ filePath: b.filePath, boost: b.boost }));
-      const selection = await selectContext({
-        task,
-        analysis,
-        budget: 5e4,
-        semanticScores,
-        learnerBoosts: learnerBoostInputs
-      });
+      const { selection, semanticMap, learnerMap } = await runContextPipeline({ projectPath: absPath, task, analysis, budget: 5e4 });
       const isSelected = selection.files.some((f) => f.relativePath === filePath);
       const selectionEntry = selection.files.find((f) => f.relativePath === filePath);
-      const semEntry = boosted.find((m) => m.filePath === filePath);
+      const semEntry = semanticMap.get(filePath);
       const semanticScore = semEntry?.score ?? 0;
       const semanticTerms = semEntry?.matchedTerms ?? [];
-      const boosts = getLearnerBoosts(learner, taskType, [filePath]);
-      const learnerBoost = boosts.length > 0 ? boosts[0] : null;
+      const lbEntry = learnerMap.get(filePath);
+      const learnerBoost = lbEntry ?? null;
       const importedBy = file.importedBy;
       const imports = file.imports;
       const explanation = {