cto-ai-cli 7.1.0 → 8.0.1

package/dist/engine/index.js

@@ -8,6 +8,152 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/engine/synonyms.ts
+function buildBidirectionalIndex() {
+  for (const [canonical, synonyms] of Object.entries(SYNONYM_MAP)) {
+    if (!BIDIRECTIONAL_INDEX.has(canonical)) {
+      BIDIRECTIONAL_INDEX.set(canonical, /* @__PURE__ */ new Set());
+    }
+    const canonicalSet = BIDIRECTIONAL_INDEX.get(canonical);
+    for (const syn of synonyms) {
+      canonicalSet.add(syn);
+    }
+    canonicalSet.add(canonical);
+    for (const syn of synonyms) {
+      if (!BIDIRECTIONAL_INDEX.has(syn)) {
+        BIDIRECTIONAL_INDEX.set(syn, /* @__PURE__ */ new Set());
+      }
+      const synSet = BIDIRECTIONAL_INDEX.get(syn);
+      synSet.add(canonical);
+      for (const otherSyn of synonyms) {
+        if (otherSyn !== syn) synSet.add(otherSyn);
+      }
+    }
+  }
+}
+function expandTerm(term) {
+  const normalized = term.toLowerCase().trim();
+  const related = BIDIRECTIONAL_INDEX.get(normalized);
+  if (!related) return [normalized];
+  return [normalized, ...Array.from(related)];
+}
+function expandQuery(query2) {
+  const terms = query2.toLowerCase().match(/[a-z][a-z0-9]*/g) ?? [];
+  const expanded = /* @__PURE__ */ new Set();
+  for (const term of terms) {
+    const related = expandTerm(term);
+    for (const r of related) expanded.add(r);
+  }
+  return Array.from(expanded);
+}
+function getExpansionDetails(query2) {
+  const terms = query2.toLowerCase().match(/[a-z][a-z0-9]*/g) ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const term of terms) {
+    if (seen.has(term)) continue;
+    seen.add(term);
+    const expanded = expandTerm(term);
+    if (expanded.length > 1) {
+      results.push({ original: term, expanded: expanded.filter((e) => e !== term) });
+    }
+  }
+  return results;
+}
+function getSynonymStats() {
+  const canonicalTerms = Object.keys(SYNONYM_MAP).length;
+  let totalSynonyms = 0;
+  for (const syns of Object.values(SYNONYM_MAP)) {
+    totalSynonyms += syns.length;
+  }
+  return {
+    canonicalTerms,
+    totalSynonyms,
+    avgSynonymsPerTerm: totalSynonyms / canonicalTerms,
+    bidirectionalEntries: BIDIRECTIONAL_INDEX.size
+  };
+}
+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();
@@ -31,15 +177,29 @@ function buildIndex(files) {
   let totalLength = 0;
   for (const doc of documents.values()) totalLength += doc.length;
   const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
-  return { documents, idf, avgDocLength, totalDocs };
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
 }
-function query(index, taskDescription, maxResults = 50) {
+function query(index, taskDescription, maxResults = 50, expandSynonyms = true) {
   const queryTerms = tokenize(taskDescription);
   if (queryTerms.length === 0) return [];
   const querySet = /* @__PURE__ */ new Map();
   for (const term of queryTerms) {
     querySet.set(term, (querySet.get(term) ?? 0) + 1);
   }
+  if (expandSynonyms) {
+    const expandedSet = /* @__PURE__ */ new Map();
+    for (const [term, count] of querySet) {
+      const synonyms = expandTerm(term);
+      for (const syn of synonyms) {
+        const weight = syn === term ? count : count * 0.7;
+        expandedSet.set(syn, (expandedSet.get(syn) ?? 0) + weight);
+      }
+    }
+    querySet.clear();
+    for (const [term, weight] of expandedSet) {
+      querySet.set(term, weight);
+    }
+  }
   const results = [];
   const k1 = 1.5;
   const b = 0.75;
@@ -51,8 +211,11 @@ function query(index, taskDescription, maxResults = 50) {
       if (tf === 0) continue;
       const termIdf = index.idf.get(qTerm) ?? 0;
       if (termIdf <= 0) continue;
+      const df = index.docFreq.get(qTerm) ?? 0;
+      const dfRatio = index.totalDocs > 0 ? df / index.totalDocs : 0;
+      const domainDamp = dfRatio > 0.5 ? (1 - dfRatio) * (1 - dfRatio) : 1;
       const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / index.avgDocLength));
-      score += termIdf * tfNorm * qCount;
+      score += termIdf * tfNorm * qCount * domainDamp;
       matchedTerms.push(qTerm);
     }
     if (score > 0) {
@@ -134,32 +297,224 @@ function boostByPath(matches, allFiles, taskDescription) {
   for (const m of matches) {
     boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
   }
+  const pathTermDocFreq = /* @__PURE__ */ new Map();
+  const allPathTokenSets = /* @__PURE__ */ new Map();
+  for (const filePath of allFiles) {
+    const 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 pathTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
-    const pathMatches = pathTerms.filter((t) => queryTerms.has(t));
-    if (pathMatches.length > 0) {
+    const parts = filePath.replace(/\\/g, "/").split("/");
+    const fileName = parts.pop() ?? "";
+    const dirSegments = parts;
+    const dirTerms = tokenize(dirSegments.join(" ").replace(/[/\\.]/g, " "));
+    const fileTerms = tokenize(fileName.replace(/[.\-_]/g, " "));
+    const dirMatches = dirTerms.filter((t) => queryTerms.has(t));
+    const fileMatches = fileTerms.filter((t) => queryTerms.has(t));
+    const allPathMatches = [.../* @__PURE__ */ new Set([...dirMatches, ...fileMatches])];
+    if (allPathMatches.length > 0) {
+      const uniqueDirMatches = [...new Set(dirMatches)];
+      const uniqueFileMatches = [...new Set(fileMatches)].filter((t) => !uniqueDirMatches.includes(t));
+      const maxIdf = Math.log(N + 1);
+      let pathBoost = 0;
+      for (const t of uniqueDirMatches) {
+        pathBoost += 0.4 * (pathIdf(t) / maxIdf);
+      }
+      for (const t of uniqueFileMatches) {
+        pathBoost += 0.25 * (pathIdf(t) / maxIdf);
+      }
       const existing = boosted.get(filePath);
-      const pathBoost = pathMatches.length * 0.3;
       if (existing) {
-        existing.score = Math.min(1, existing.score + pathBoost);
-        for (const t of pathMatches) {
+        existing.score = existing.score + pathBoost;
+        for (const t of allPathMatches) {
           if (!existing.matchedTerms.includes(t)) existing.matchedTerms.push(t);
         }
       } else {
         boosted.set(filePath, {
           filePath,
-          score: Math.min(1, pathBoost),
-          matchedTerms: pathMatches
+          score: pathBoost,
+          matchedTerms: allPathMatches
+        });
+      }
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+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);
 }
-var STOP_WORDS, TERM_FAMILIES;
+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()}]`]
+    });
+  }
+}
+function reciprocalRankFusion(bm25Matches, allFiles, taskDescription, dependencies, k = 60) {
+  const bm25Ranked = [...bm25Matches].sort((a, b) => b.score - a.score);
+  const bm25RankMap = /* @__PURE__ */ new Map();
+  bm25Ranked.forEach((m, i) => bm25RankMap.set(m.filePath, i + 1));
+  const queryTerms = new Set(tokenize(taskDescription));
+  const pathScores = [];
+  for (const filePath of allFiles) {
+    const parts = filePath.replace(/\\/g, "/").split("/");
+    const fileName = parts.pop() ?? "";
+    const dirTerms = tokenize(parts.join(" ").replace(/[/\\.]/g, " "));
+    const fileTerms = tokenize(fileName.replace(/[.\-_]/g, " "));
+    const dirHits = [...new Set(dirTerms.filter((t) => queryTerms.has(t)))].length;
+    const fileHits = [...new Set(fileTerms.filter((t) => queryTerms.has(t)))].length;
+    const score = dirHits * 2 + fileHits;
+    if (score > 0) pathScores.push({ filePath, score });
+  }
+  pathScores.sort((a, b) => b.score - a.score);
+  const pathRankMap = /* @__PURE__ */ new Map();
+  pathScores.forEach((p, i) => pathRankMap.set(p.filePath, i + 1));
+  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 top10 = new Set(bm25Ranked.slice(0, 10).map((m) => m.filePath));
+  const importScores = [];
+  for (const filePath of allFiles) {
+    let connections = 0;
+    for (const dep of dependencies.get(filePath) ?? []) {
+      if (top10.has(dep)) connections++;
+    }
+    for (const imp of reverseDeps.get(filePath) ?? []) {
+      if (top10.has(imp)) connections++;
+    }
+    if (top10.has(filePath)) connections += 2;
+    if (connections > 0) importScores.push({ filePath, score: connections });
+  }
+  importScores.sort((a, b) => b.score - a.score);
+  const importRankMap = /* @__PURE__ */ new Map();
+  importScores.forEach((p, i) => importRankMap.set(p.filePath, i + 1));
+  const classNameScores = [];
+  for (const filePath of allFiles) {
+    const fileName = filePath.split("/").pop() ?? "";
+    const baseName = fileName.replace(/\.[^.]+$/, "");
+    const classTokens = tokenize(baseName.replace(/([a-z])([A-Z])/g, "$1 $2"));
+    const hits = classTokens.filter((t) => queryTerms.has(t));
+    const coverage = queryTerms.size > 0 ? hits.length / queryTerms.size : 0;
+    if (hits.length > 0) {
+      classNameScores.push({ filePath, score: hits.length + coverage });
+    }
+  }
+  classNameScores.sort((a, b) => b.score - a.score);
+  const classRankMap = /* @__PURE__ */ new Map();
+  classNameScores.forEach((p, i) => classRankMap.set(p.filePath, i + 1));
+  const WEIGHTS2 = { bm25: 0.4, path: 0.25, imports: 0.2, className: 0.15 };
+  const allCandidates = /* @__PURE__ */ new Set();
+  for (const m of bm25Ranked) allCandidates.add(m.filePath);
+  for (const p of pathScores) allCandidates.add(p.filePath);
+  for (const p of importScores) allCandidates.add(p.filePath);
+  for (const p of classNameScores) allCandidates.add(p.filePath);
+  const defaultRank = allFiles.length + 1;
+  const fused = [];
+  for (const filePath of allCandidates) {
+    const bm25Rank = bm25RankMap.get(filePath) ?? defaultRank;
+    const pathRank = pathRankMap.get(filePath) ?? defaultRank;
+    const importRank = importRankMap.get(filePath) ?? defaultRank;
+    const classRank = classRankMap.get(filePath) ?? defaultRank;
+    const rrfScore = WEIGHTS2.bm25 / (k + bm25Rank) + WEIGHTS2.path / (k + pathRank) + WEIGHTS2.imports / (k + importRank) + WEIGHTS2.className / (k + classRank);
+    const bm25Match = bm25Ranked.find((m) => m.filePath === filePath);
+    const matchedTerms = bm25Match ? [...bm25Match.matchedTerms] : [];
+    fused.push({ filePath, score: rrfScore, matchedTerms });
+  }
+  return fused.sort((a, b) => b.score - a.score);
+}
+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",
@@ -303,6 +658,29 @@ var init_tfidf = __esm({
       ["encryp", "encrypt"],
       ["decryp", "encrypt"]
     ];
+    LAYER_MAP = {
+      // Query terms → directory segments that should be boosted
+      "endpoint": ["endpoint", "controller", "handler", "route", "router", "api", "rest"],
+      "api": ["endpoint", "controller", "handler", "route", "router", "api", "rest"],
+      "controller": ["endpoint", "controller", "handler", "route", "router"],
+      "repositori": ["repositori", "dao", "store", "persist"],
+      "databas": ["repositori", "dao", "store", "persist", "migrat"],
+      "storag": ["repositori", "dao", "store", "persist"],
+      "cach": ["cach", "redis", "memcach", "store"],
+      "servic": ["servic", "usecas", "core"],
+      "usecas": ["usecas", "servic", "core"],
+      "config": ["config", "inject", "setup", "bootstrap"],
+      "inject": ["config", "inject", "setup"],
+      "depend": ["config", "inject", "setup"],
+      "event": ["event", "listen", "handler", "subscrib"],
+      "error": ["error", "except", "handler", "fault"],
+      "except": ["except", "error", "handler", "fault"],
+      "model": ["model", "entiti", "dto", "domain", "schema"],
+      "entiti": ["entiti", "model", "dto", "domain"],
+      "metric": ["metric", "monitor", "observ", "telemetri"],
+      "test": ["test", "spec", "mock", "fixtur"],
+      "migrat": ["migrat", "schema", "databas"]
+    };
   }
 });
 
@@ -548,7 +926,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
   },
@@ -1760,11 +2150,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;
     }
   }
@@ -3142,17 +3536,19 @@ async function selectContext(input) {
   const selectedFiles = [];
   let usedTokens = 0;
   const hasSemanticSignal = semanticMap.size > 0;
+  const maxSemanticScore = hasSemanticSignal ? Math.max(...Array.from(semanticMap.values())) : 0;
+  const semanticFloor = maxSemanticScore * 0.1;
   for (const file of candidates) {
     const isTarget = targetSet.has(file.relativePath);
     const isMustInclude = mustInclude.has(file.relativePath);
     if (hasSemanticSignal && !isTarget && !isMustInclude) {
       const semScore = semanticMap.get(file.relativePath) ?? 0;
       const lrnBoost = learnerMap.get(file.relativePath) ?? 0;
-      if (semScore === 0 && lrnBoost === 0) {
+      if (semScore < semanticFloor && lrnBoost <= 0) {
         decisions.push({
           file: file.relativePath,
           action: "exclude",
-          reason: "Skipped: no semantic relevance to task"
+          reason: `Skipped: semantic score ${semScore.toFixed(3)} below floor ${semanticFloor.toFixed(3)}`
         });
         continue;
       }
@@ -3284,6 +3680,222 @@ function buildReason(file, level, isTarget, isMustInclude) {
 import { readFileSync as readFileSync6 } from "fs";
 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;
+}
+function getStructuralSummary(content, filePath) {
+  const s = extractStructuralTokens(content, filePath);
+  const parts = [];
+  if (s.classNames.length > 0) parts.push(`classes: [${s.classNames.join(", ")}]`);
+  if (s.methodNames.length > 0) parts.push(`methods: [${s.methodNames.join(", ")}]`);
+  if (s.annotations.length > 0) parts.push(`annotations: [@${s.annotations.join(", @")}]`);
+  if (s.parents.length > 0) parts.push(`extends/implements: [${s.parents.join(", ")}]`);
+  if (s.packageName) parts.push(`package: ${s.packageName}`);
+  return parts.length > 0 ? `[${s.language}] ${parts.join(" | ")}` : `[${s.language}] (no structural tokens)`;
+}
+
 // src/engine/index-cache.ts
 init_tfidf();
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, statSync } from "fs";
@@ -3422,7 +4034,7 @@ function rebuildIndex(cachedFiles) {
   for (const [term, df] of docFreq) {
     idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
   }
-  return { documents, idf, avgDocLength, totalDocs };
+  return { documents, idf, docFreq, avgDocLength, totalDocs };
 }
 
 // src/engine/reranker.ts
@@ -3825,130 +4437,1668 @@ function classifyTask(taskDescription) {
   return bestType;
 }
 
-// src/engine/context-pipeline.ts
-async function runContextPipeline(input) {
-  const { projectPath, task, analysis, budget = 5e4 } = input;
-  const taskType = classifyTask(task);
-  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: "" });
-    }
-  }
-  const indexFiles = analysis.files.map((f) => ({
-    relativePath: f.relativePath,
-    absolutePath: f.path,
-    content: fileContentMap.get(f.relativePath)
-  }));
-  const { index, stats: indexCacheStats } = buildIndexCached(projectPath, indexFiles);
-  const semanticMatches = query(index, task, 50);
-  const boostedMatches = boostByPath(
-    semanticMatches,
-    analysis.files.map((f) => f.relativePath),
-    task
-  );
-  const depMap = /* @__PURE__ */ new Map();
-  for (const file of analysis.files) {
-    depMap.set(file.relativePath, file.imports);
+// 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
+    });
   }
-  const rerankResult = rerank({
-    task,
-    candidates: boostedMatches,
-    index,
-    fileContents: fileContentMap,
-    dependencies: depMap,
-    allFilePaths: analysis.files.map((f) => f.relativePath)
-  });
-  const rerankedMatches = rerankResult.files.map((rf) => ({
-    filePath: rf.filePath,
-    score: rf.bm25Score,
-    // Keep original BM25 score for composite
-    matchedTerms: boostedMatches.find((m) => m.filePath === rf.filePath)?.matchedTerms ?? []
-  }));
-  const 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 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 { selection, taskType, fileContentMap, semanticMap, learnerMap, multiRepo, indexCacheStats };
+  return defs;
 }
-
-// src/engine/index.ts
-init_tfidf();
-
-// src/engine/ab-testing.ts
-import { createHash as createHash4 } from "crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join8 } from "path";
-var EXPERIMENTS_FILE = "experiments.json";
-function loadExperiments(projectPath) {
-  const path = join8(projectPath, ".cto", EXPERIMENTS_FILE);
-  try {
-    if (!existsSync6(path)) return [];
-    return JSON.parse(readFileSync7(path, "utf-8"));
-  } catch {
-    return [];
+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 saveExperiments(projectPath, experiments) {
-  const dir = join8(projectPath, ".cto");
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
-  writeFileSync3(join8(dir, EXPERIMENTS_FILE), JSON.stringify(experiments, null, 2));
+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 createExperiment(id, name, description, controlParams, variantParams, options = {}) {
-  return {
-    id,
-    name,
-    description,
-    status: "running",
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    trafficSplit: options.trafficSplit ?? 0.5,
-    minObservations: options.minObservations ?? 30,
-    significanceThreshold: options.significanceThreshold ?? 0.05,
-    control: {
-      name: "control",
-      params: controlParams,
-      metrics: emptyMetrics()
-    },
-    variant: {
-      name: "variant",
-      params: variantParams,
-      metrics: emptyMetrics()
+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 emptyMetrics() {
-  return {
-    total: 0,
-    successes: 0,
-    acceptRate: 0,
-    avgTimeToAccept: 0,
-    compilableRate: 0,
-    timeSum: 0,
-    compilableCount: 0
-  };
+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 similarity2 = union > 0 ? coCommits / union : 0;
+    const entry = { fileA, fileB, coCommits, similarity: similarity2 };
+    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);
+}
+function getGitRecency(projectPath, days = 30) {
+  const recency = /* @__PURE__ */ new Map();
+  try {
+    const since = `${days} days ago`;
+    const output = execSync(
+      `git log --no-merges --diff-filter=ACMR --name-only --format="%aI" --since="${since}"`,
+      { cwd: projectPath, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024, timeout: 1e4 }
+    );
+    const now = Date.now();
+    const msPerDay = 864e5;
+    let currentDate = null;
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      if (trimmed.match(/^\d{4}-\d{2}-\d{2}/)) {
+        currentDate = new Date(trimmed).getTime();
+        continue;
+      }
+      if (currentDate !== null) {
+        const ageMs = now - currentDate;
+        const ageDays = ageMs / msPerDay;
+        const halfLife = days / 3;
+        const score = Math.exp(-ageDays / halfLife);
+        const existing = recency.get(trimmed) ?? 0;
+        if (score > existing) {
+          recency.set(trimmed, score);
+        }
+      }
+    }
+  } catch {
+  }
+  return recency;
+}
+
+// src/engine/multi-hop.ts
+init_tfidf();
+var DEFAULT_CONFIG2 = {
+  maxHops: 2,
+  topKPerHop: 5,
+  decayFactor: 0.5,
+  minScoreThreshold: 0.2
+};
+function multiHopQuery(index, task, deps, callEdges, fileContents, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const hops = [];
+  const callsTo = /* @__PURE__ */ new Map();
+  const calledBy = /* @__PURE__ */ new Map();
+  for (const edge of callEdges) {
+    const fwd = callsTo.get(edge.from) ?? /* @__PURE__ */ new Set();
+    fwd.add(edge.to);
+    callsTo.set(edge.from, fwd);
+    const rev = calledBy.get(edge.to) ?? /* @__PURE__ */ new Set();
+    rev.add(edge.from);
+    calledBy.set(edge.to, rev);
+  }
+  const aggregateScores = /* @__PURE__ */ new Map();
+  const aggregateTerms = /* @__PURE__ */ new Map();
+  const explored = /* @__PURE__ */ new Set();
+  const initialResults = query(index, task, 50);
+  for (const m of initialResults) {
+    aggregateScores.set(m.filePath, m.score);
+    aggregateTerms.set(m.filePath, new Set(m.matchedTerms));
+    explored.add(m.filePath);
+  }
+  hops.push({
+    hop: 0,
+    seedFiles: [],
+    newFiles: initialResults.slice(0, cfg.topKPerHop).map((m) => m.filePath),
+    expandedTerms: tokenize(task)
+  });
+  let currentSeeds = initialResults.slice(0, cfg.topKPerHop);
+  for (let hop = 1; hop <= cfg.maxHops; hop++) {
+    if (currentSeeds.length === 0) break;
+    const seedFiles = currentSeeds.map((m) => m.filePath);
+    const newFiles = [];
+    const expandedTerms = [];
+    const connectedFiles = /* @__PURE__ */ new Set();
+    for (const seed of seedFiles) {
+      const importDeps = deps.get(seed) ?? [];
+      for (const dep of importDeps) {
+        if (!explored.has(dep)) connectedFiles.add(dep);
+      }
+      const calls = callsTo.get(seed) ?? /* @__PURE__ */ new Set();
+      for (const called of calls) {
+        if (!explored.has(called)) connectedFiles.add(called);
+      }
+      const callers = calledBy.get(seed) ?? /* @__PURE__ */ new Set();
+      for (const caller of callers) {
+        if (!explored.has(caller)) connectedFiles.add(caller);
+      }
+    }
+    for (const seed of seedFiles) {
+      const content = fileContents.get(seed);
+      if (!content) continue;
+      const identifiers = extractKeyIdentifiers(content, seed);
+      expandedTerms.push(...identifiers);
+    }
+    const decayMultiplier = Math.pow(cfg.decayFactor, hop);
+    const uniqueExpandedTerms = [...new Set(expandedTerms)];
+    const expandedQuery = task + " " + uniqueExpandedTerms.slice(0, 10).join(" ");
+    const expandedResults = query(index, expandedQuery, 30);
+    for (const connected of connectedFiles) {
+      const expandedMatch = expandedResults.find((r) => r.filePath === connected);
+      const graphScore = 0.3;
+      const bm25Score = expandedMatch?.score ?? 0;
+      const hopScore = (graphScore + bm25Score) * decayMultiplier;
+      if (hopScore >= cfg.minScoreThreshold * decayMultiplier) {
+        const existing = aggregateScores.get(connected) ?? 0;
+        aggregateScores.set(connected, existing + hopScore);
+        const terms = aggregateTerms.get(connected) ?? /* @__PURE__ */ new Set();
+        terms.add(`[hop-${hop}]`);
+        if (expandedMatch) {
+          for (const t of expandedMatch.matchedTerms) terms.add(t);
+        }
+        aggregateTerms.set(connected, terms);
+        if (!explored.has(connected)) {
+          newFiles.push(connected);
+          explored.add(connected);
+        }
+      }
+    }
+    for (const r of expandedResults) {
+      if (!explored.has(r.filePath)) {
+        const hopScore = r.score * decayMultiplier * 0.5;
+        if (hopScore >= cfg.minScoreThreshold * decayMultiplier) {
+          const existing = aggregateScores.get(r.filePath) ?? 0;
+          aggregateScores.set(r.filePath, existing + hopScore);
+          const terms = aggregateTerms.get(r.filePath) ?? /* @__PURE__ */ new Set();
+          terms.add(`[hop-${hop}-bm25]`);
+          for (const t of r.matchedTerms) terms.add(t);
+          aggregateTerms.set(r.filePath, terms);
+          newFiles.push(r.filePath);
+          explored.add(r.filePath);
+        }
+      }
+    }
+    hops.push({ hop, seedFiles, newFiles, expandedTerms: uniqueExpandedTerms.slice(0, 20) });
+    const newScored = newFiles.map((f) => ({ filePath: f, score: aggregateScores.get(f) ?? 0 })).sort((a, b) => b.score - a.score).slice(0, cfg.topKPerHop);
+    currentSeeds = newScored.map((s) => ({
+      filePath: s.filePath,
+      score: s.score,
+      matchedTerms: [...aggregateTerms.get(s.filePath) ?? []]
+    }));
+  }
+  const matches = [];
+  for (const [filePath, score] of aggregateScores) {
+    const terms = aggregateTerms.get(filePath) ?? /* @__PURE__ */ new Set();
+    matches.push({ filePath, score, matchedTerms: [...terms] });
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return {
+    matches,
+    hops,
+    totalFilesExplored: explored.size
+  };
+}
+function extractKeyIdentifiers(content, filePath) {
+  const identifiers = [];
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (ext === "java") {
+    const classMatches = content.match(/(?:class|interface)\s+(\w+)/g) ?? [];
+    for (const m of classMatches) {
+      const name = m.replace(/(?:class|interface)\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+    const methodRegex = /(?:public|protected)\s+[\w<>\[\],\s?]+\s+(\w+)\s*\(/gm;
+    let match;
+    while ((match = methodRegex.exec(content)) !== null) {
+      identifiers.push(...splitCamelCase(match[1]));
+    }
+  } else if (["ts", "tsx", "js", "jsx"].includes(ext)) {
+    const exportMatches = content.match(/export\s+(?:class|function|const|interface|type)\s+(\w+)/g) ?? [];
+    for (const m of exportMatches) {
+      const name = m.replace(/export\s+(?:class|function|const|interface|type)\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+  } else if (ext === "py") {
+    const defMatches = content.match(/^(?:class|def)\s+(\w+)/gm) ?? [];
+    for (const m of defMatches) {
+      const name = m.replace(/^(?:class|def)\s+/, "");
+      identifiers.push(...splitSnakeCase(name));
+    }
+  } else if (ext === "go") {
+    const funcMatches = content.match(/^func\s+(?:\([^)]+\)\s+)?([A-Z]\w+)/gm) ?? [];
+    for (const m of funcMatches) {
+      const name = m.replace(/^func\s+(?:\([^)]+\)\s+)?/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+    const typeMatches = content.match(/^type\s+([A-Z]\w+)/gm) ?? [];
+    for (const m of typeMatches) {
+      const name = m.replace(/^type\s+/, "");
+      identifiers.push(...splitCamelCase(name));
+    }
+  }
+  return [...new Set(identifiers)].filter((id) => id.length >= 3 && !NOISE_IDENTIFIERS.has(id.toLowerCase())).slice(0, 30);
+}
+function splitCamelCase(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((s) => s.length >= 3);
+}
+function splitSnakeCase(name) {
+  return name.split("_").filter((s) => s.length >= 3);
+}
+var NOISE_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "has",
+  "add",
+  "put",
+  "new",
+  "run",
+  "map",
+  "for",
+  "the",
+  "and",
+  "not",
+  "with",
+  "from",
+  "this",
+  "that",
+  "test",
+  "spec",
+  "mock",
+  "void",
+  "null",
+  "true",
+  "false",
+  "string",
+  "number",
+  "boolean",
+  "int",
+  "impl",
+  "default",
+  "abstract",
+  "base",
+  "main",
+  "init",
+  "setup",
+  "util",
+  "utils",
+  "helper",
+  "helpers",
+  "common",
+  "config",
+  "model",
+  "entity",
+  "service",
+  "repository",
+  "controller",
+  "handler",
+  "interface",
+  "type",
+  "class",
+  "function",
+  "const",
+  "return",
+  "import",
+  "export",
+  "private",
+  "public",
+  "protected",
+  "static",
+  "final",
+  "override",
+  "async",
+  "await"
+]);
+
+// src/engine/query-intent.ts
+var ACTION_PATTERNS = [
+  [/\b(fix|bug|debug|repair|resolve|broken|crash|error|issue|wrong)\b/i, "fix"],
+  [/\b(add|implement|create|build|new|feature|introduce|wire)\b/i, "add"],
+  [/\b(refactor|restructure|clean|extract|split|move|rename|simplify)\b/i, "refactor"],
+  [/\b(trace|follow|understand|find|where|how|flow|path|chain)\b/i, "trace"],
+  [/\b(test|spec|coverage|assert|mock|verify)\b/i, "test"],
+  [/\b(doc|document|describe|explain|readme|comment)\b/i, "docs"],
+  [/\b(remove|delete|deprecate|drop|kill|eliminate)\b/i, "remove"],
+  [/\b(optimize|performance|speed|fast|slow|latency|efficient)\b/i, "optimize"]
+];
+function detectAction(task) {
+  for (const [pattern, action] of ACTION_PATTERNS) {
+    if (pattern.test(task)) return action;
+  }
+  return "unknown";
+}
+var LAYER_KEYWORDS = [
+  [["controller", "endpoint", "handler", "router", "route", "api", "rest", "entrypoint"], "endpoint"],
+  [["usecase", "use case", "use-case", "interactor", "application service"], "usecase"],
+  [["service", "domain service", "business logic"], "service"],
+  [["repository", "repo", "dao", "data access", "persistence", "database", "db", "store"], "repository"],
+  [["cache", "redis", "memcached", "caching", "ttl", "invalidat"], "cache"],
+  [["client", "http client", "api client", "rest client", "feign", "retrofit"], "client"],
+  [["model", "entity", "dto", "domain object", "value object", "pojo"], "model"],
+  [["config", "configuration", "injector", "module", "bean", "provider", "dependency injection"], "config"],
+  [["queue", "kafka", "rabbit", "sqs", "event", "listener", "consumer", "producer", "message"], "queue"],
+  [["middleware", "interceptor", "filter", "guard", "pipe"], "middleware"]
+];
+function detectLayers(task) {
+  const lower = task.toLowerCase();
+  const layers = [];
+  for (const [keywords, layer] of LAYER_KEYWORDS) {
+    if (keywords.some((kw) => lower.includes(kw))) {
+      layers.push(layer);
+    }
+  }
+  return [...new Set(layers)];
+}
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "shall",
+  "should",
+  "may",
+  "might",
+  "must",
+  "can",
+  "could",
+  "need",
+  "not",
+  "and",
+  "but",
+  "or",
+  "nor",
+  "for",
+  "yet",
+  "so",
+  "in",
+  "on",
+  "at",
+  "to",
+  "from",
+  "by",
+  "with",
+  "about",
+  "between",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "up",
+  "down",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "just",
+  "because",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "of",
+  "if"
+]);
+var ACTION_WORDS = /* @__PURE__ */ new Set([
+  "fix",
+  "add",
+  "create",
+  "build",
+  "implement",
+  "refactor",
+  "trace",
+  "follow",
+  "find",
+  "update",
+  "modify",
+  "change",
+  "remove",
+  "delete",
+  "debug",
+  "test",
+  "check",
+  "verify",
+  "validate",
+  "handle",
+  "process",
+  "resolve",
+  "repair",
+  "optimize",
+  "improve",
+  "speed",
+  "clean",
+  "bug",
+  "error",
+  "issue",
+  "problem",
+  "flow",
+  "path",
+  "chain"
+]);
+var OPERATION_WORDS = /* @__PURE__ */ new Set([
+  "create",
+  "read",
+  "update",
+  "delete",
+  "save",
+  "load",
+  "fetch",
+  "retrieve",
+  "store",
+  "persist",
+  "insert",
+  "remove",
+  "invalidate",
+  "validate",
+  "parse",
+  "transform",
+  "convert",
+  "render",
+  "display",
+  "send",
+  "receive",
+  "publish",
+  "subscribe",
+  "emit",
+  "listen",
+  "authenticate",
+  "authorize",
+  "encrypt",
+  "decrypt",
+  "hash",
+  "serialize",
+  "deserialize",
+  "encode",
+  "decode",
+  "compress",
+  "replicate",
+  "sync",
+  "migrate",
+  "export",
+  "import",
+  "upload",
+  "download",
+  "search",
+  "index",
+  "query",
+  "filter",
+  "sort"
+]);
+function extractEntities(task) {
+  const words = task.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/);
+  const entities = [];
+  for (const word of words) {
+    if (word.length < 3) continue;
+    if (STOP_WORDS2.has(word)) continue;
+    if (ACTION_WORDS.has(word)) continue;
+    if (OPERATION_WORDS.has(word)) continue;
+    const isLayer = LAYER_KEYWORDS.some(([kws]) => kws.includes(word));
+    if (isLayer) continue;
+    entities.push(word);
+  }
+  return [...new Set(entities)];
+}
+function extractOperations(task) {
+  const words = task.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/);
+  const operations = [];
+  for (const word of words) {
+    if (OPERATION_WORDS.has(word)) {
+      operations.push(word);
+    }
+  }
+  const opPatterns = task.toLowerCase().match(/\b(on|after|before|during)\s+(\w+)/g);
+  if (opPatterns) {
+    for (const pattern of opPatterns) {
+      const parts = pattern.split(/\s+/);
+      if (parts.length >= 2 && OPERATION_WORDS.has(parts[1])) {
+        operations.push(parts[1]);
+      }
+    }
+  }
+  return [...new Set(operations)];
+}
+function extractQualifiers(task) {
+  const qualifiers = [];
+  const patterns = task.match(/\b(on|for|in|via|from|through)\s+(\w+(?:\s+\w+)?)/gi);
+  if (patterns) {
+    for (const p of patterns) {
+      const parts = p.split(/\s+/);
+      if (parts.length >= 2) {
+        const qualifier = parts.slice(1).join(" ").toLowerCase();
+        if (!STOP_WORDS2.has(qualifier) && qualifier.length >= 2) {
+          qualifiers.push(qualifier);
+        }
+      }
+    }
+  }
+  return [...new Set(qualifiers)];
+}
+function parseQueryIntent(task) {
+  const action = detectAction(task);
+  const entities = extractEntities(task);
+  const operations = extractOperations(task);
+  const layers = detectLayers(task);
+  const qualifiers = extractQualifiers(task);
+  const signals = [
+    action !== "unknown" ? 1 : 0,
+    entities.length > 0 ? 1 : 0,
+    operations.length > 0 ? 1 : 0,
+    layers.length > 0 ? 1 : 0
+  ];
+  const confidence = signals.reduce((a, b) => a + b, 0) / signals.length;
+  return { original: task, action, entities, operations, layers, qualifiers, confidence };
+}
+function buildWeightedQuery(intent) {
+  const parts = [];
+  for (const entity of intent.entities) {
+    parts.push(entity, entity, entity);
+  }
+  for (const op of intent.operations) {
+    parts.push(op, op);
+  }
+  for (const layer of intent.layers) {
+    parts.push(layer);
+  }
+  for (const q of intent.qualifiers) {
+    parts.push(q);
+  }
+  if (parts.length === 0) return intent.original;
+  return parts.join(" ");
+}
+function expandLayers(layers) {
+  const expanded = new Set(layers);
+  for (const layer of layers) {
+    switch (layer) {
+      case "endpoint":
+        expanded.add("usecase");
+        expanded.add("service");
+        break;
+      case "usecase":
+        expanded.add("service");
+        expanded.add("repository");
+        break;
+      case "service":
+        expanded.add("usecase");
+        expanded.add("repository");
+        break;
+      case "repository":
+        expanded.add("service");
+        expanded.add("model");
+        break;
+      case "cache":
+        expanded.add("repository");
+        expanded.add("service");
+        break;
+      case "client":
+        expanded.add("service");
+        expanded.add("config");
+        break;
+    }
+  }
+  return [...expanded];
+}
+
+// src/engine/embeddings.ts
+function buildTfIdfEmbeddingIndex(index) {
+  const allTerms = [...index.idf.keys()];
+  const termToIdx = new Map(allTerms.map((t, i) => [t, i]));
+  const dimensions = allTerms.length;
+  const docVectors = /* @__PURE__ */ new Map();
+  const docNorms = /* @__PURE__ */ new Map();
+  for (const [filePath, doc] of index.documents) {
+    const vec = new Float32Array(dimensions);
+    let norm = 0;
+    for (const [term, tf] of doc.terms) {
+      const idx = termToIdx.get(term);
+      if (idx === void 0) continue;
+      const idf = index.idf.get(term) ?? 0;
+      const weight = tf * idf;
+      vec[idx] = weight;
+      norm += weight * weight;
+    }
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+      for (let i = 0; i < dimensions; i++) {
+        vec[i] /= norm;
+      }
+    }
+    docVectors.set(filePath, vec);
+    docNorms.set(filePath, norm);
+  }
+  function queryFn(text, topK) {
+    const queryTerms = tokenizeForEmbedding(text);
+    const termCounts = /* @__PURE__ */ new Map();
+    for (const t of queryTerms) {
+      termCounts.set(t, (termCounts.get(t) ?? 0) + 1);
+    }
+    const queryVec = new Float32Array(dimensions);
+    let queryNorm = 0;
+    for (const [term, count] of termCounts) {
+      const idx = termToIdx.get(term);
+      if (idx === void 0) continue;
+      const idf = index.idf.get(term) ?? 0;
+      const weight = count * idf;
+      queryVec[idx] = weight;
+      queryNorm += weight * weight;
+    }
+    queryNorm = Math.sqrt(queryNorm);
+    if (queryNorm > 0) {
+      for (let i = 0; i < dimensions; i++) {
+        queryVec[i] /= queryNorm;
+      }
+    }
+    const results = [];
+    for (const [filePath, docVec] of docVectors) {
+      let dot = 0;
+      for (const [term] of termCounts) {
+        const idx = termToIdx.get(term);
+        if (idx !== void 0) {
+          dot += queryVec[idx] * docVec[idx];
+        }
+      }
+      if (dot > 0) {
+        results.push({ filePath, score: dot });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  return {
+    backend: "tfidf-cosine",
+    dimensions,
+    documentCount: docVectors.size,
+    query: queryFn
+  };
+}
+function reciprocalRankFusion2(bm25Results, embeddingResults, k = 60, bm25Weight = 0.6, embeddingWeight = 0.4) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let i = 0; i < bm25Results.length; i++) {
+    const rrf = bm25Weight / (k + i + 1);
+    const existing = scores.get(bm25Results[i].filePath) ?? 0;
+    scores.set(bm25Results[i].filePath, existing + rrf);
+  }
+  for (let i = 0; i < embeddingResults.length; i++) {
+    const rrf = embeddingWeight / (k + i + 1);
+    const existing = scores.get(embeddingResults[i].filePath) ?? 0;
+    scores.set(embeddingResults[i].filePath, existing + rrf);
+  }
+  return [...scores.entries()].map(([filePath, score]) => ({ filePath, score })).sort((a, b) => b.score - a.score);
+}
+function tokenizeForEmbedding(text) {
+  return text.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[^a-z0-9]/g, " ").split(/\s+/).filter((t) => t.length >= 2);
+}
+async function isOnnxAvailable() {
+  try {
+    await Function('return import("onnxruntime-node")')();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildNeuralEmbeddingIndex(_files, modelPath) {
+  try {
+    const ort = await Function('return import("onnxruntime-node")')();
+    if (!modelPath || !ort) return null;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/engine/context-pipeline.ts
+var RANKING_NOISE_PATTERNS = [
+  /^changelog/i,
+  /^license/i,
+  /^contributing/i,
+  /^code_of_conduct/i,
+  /^authors/i,
+  /^codeowners$/i,
+  /^security/i,
+  /\.lock$/,
+  /^package-lock\.json$/,
+  /^yarn\.lock$/,
+  /^pnpm-lock\.yaml$/,
+  /^Gemfile\.lock$/
+];
+function isRankingNoise(filePath) {
+  const basename4 = filePath.split("/").pop() ?? filePath;
+  return RANKING_NOISE_PATTERNS.some((re) => re.test(basename4));
+}
+function fileTypePenalty(filePath, taskType) {
+  const lower = filePath.toLowerCase();
+  const isTest = /[/\\]test[s]?[/\\]|\.test\.|\.spec\.|_test\./i.test(lower);
+  const isDoc = /\.md$|\.txt$|\.rst$|^docs[/\\]/i.test(lower);
+  const isConfig = /\.xml$|\.yml$|\.yaml$|\.properties$|\.gradle$/i.test(lower);
+  if (taskType === "debug") {
+    if (isTest) return 0.4;
+    if (isDoc) return 0.2;
+    if (isConfig) return 0.6;
+  } else if (taskType === "test") {
+    if (isTest) return 1.2;
+    if (isDoc) return 0.3;
+  } else if (taskType === "docs") {
+    if (isDoc) return 1.2;
+    if (isTest) return 0.3;
+  } else if (taskType === "feature" || taskType === "refactor") {
+    if (isTest) return 0.5;
+    if (isDoc) return 0.4;
+  }
+  return 1;
+}
+function detectComplexQuery(task) {
+  const lower = task.toLowerCase();
+  const words = lower.split(/\s+/).filter((w) => w.length > 2);
+  const chainIndicators = /\b(when|after|then|through|from .+ to|via|chain|flow|trace|path|propagat|cascade|invalidat\w+ on|calls?|invokes?)\b/;
+  if (chainIndicators.test(lower)) return true;
+  const layers = [
+    "controller",
+    "endpoint",
+    "router",
+    "handler",
+    "service",
+    "usecase",
+    "use case",
+    "repository",
+    "repo",
+    "cache",
+    "database",
+    "queue",
+    "client",
+    "adapter",
+    "gateway",
+    "interceptor",
+    "middleware",
+    "listener",
+    "consumer",
+    "producer",
+    "publisher",
+    "subscriber"
+  ];
+  const layerCount = layers.filter((l) => lower.includes(l)).length;
+  if (layerCount >= 2) return true;
+  if (words.length >= 10) return true;
+  const entityConnectors = lower.match(/\b(on|for|in|from|to|with|after|before|during)\b/g);
+  if (entityConnectors && entityConnectors.length >= 3) return true;
+  return false;
+}
+async function runContextPipeline(input) {
+  const { projectPath, task, analysis, budget = 5e4 } = input;
+  const taskType = classifyTask(task);
+  const queryIntent = parseQueryIntent(task);
+  const weightedQuery = buildWeightedQuery(queryIntent);
+  const fileContentMap = /* @__PURE__ */ new Map();
+  const fileContents = [];
+  for (const file of analysis.files) {
+    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: "" });
+    }
+  }
+  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);
+  }
+  const callGraph = buildCallGraph(
+    fileContents.filter((f) => f.content.length > 0)
+  );
+  const callEdges = [...analysis.graph.edges.filter((e) => e.type === "call"), ...callGraph.edges];
+  const isComplexQuery = detectComplexQuery(task);
+  const embeddingIndex = buildTfIdfEmbeddingIndex(index);
+  const embeddingResults = embeddingIndex.query(weightedQuery, adaptiveTopK);
+  let bm25Matches;
+  if (isComplexQuery) {
+    const hopResult = multiHopQuery(index, weightedQuery, depMap, callEdges, fileContentMap, {
+      maxHops: 2,
+      topKPerHop: 5,
+      decayFactor: 0.5,
+      minScoreThreshold: 0.15
+    });
+    bm25Matches = hopResult.matches.slice(0, adaptiveTopK);
+  } else {
+    bm25Matches = query(index, weightedQuery, adaptiveTopK);
+  }
+  const fusedResults = reciprocalRankFusion2(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);
+  }
+  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 { selection, taskType, fileContentMap, semanticMap, learnerMap, queryIntent, multiRepo, indexCacheStats };
+}
+
+// src/engine/index.ts
+init_tfidf();
+init_synonyms();
+
+// src/engine/ab-testing.ts
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join8 } from "path";
+var EXPERIMENTS_FILE = "experiments.json";
+function loadExperiments(projectPath) {
+  const path = join8(projectPath, ".cto", EXPERIMENTS_FILE);
+  try {
+    if (!existsSync6(path)) return [];
+    return JSON.parse(readFileSync7(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveExperiments(projectPath, experiments) {
+  const dir = join8(projectPath, ".cto");
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync3(join8(dir, EXPERIMENTS_FILE), JSON.stringify(experiments, null, 2));
+}
+function createExperiment(id, name, description, controlParams, variantParams, options = {}) {
+  return {
+    id,
+    name,
+    description,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    trafficSplit: options.trafficSplit ?? 0.5,
+    minObservations: options.minObservations ?? 30,
+    significanceThreshold: options.significanceThreshold ?? 0.05,
+    control: {
+      name: "control",
+      params: controlParams,
+      metrics: emptyMetrics()
+    },
+    variant: {
+      name: "variant",
+      params: variantParams,
+      metrics: emptyMetrics()
+    }
+  };
+}
+function emptyMetrics() {
+  return {
+    total: 0,
+    successes: 0,
+    acceptRate: 0,
+    avgTimeToAccept: 0,
+    compilableRate: 0,
+    timeSum: 0,
+    compilableCount: 0
+  };
 }
 function assignGroup(experiment, task) {
   if (experiment.status !== "running") return null;
@@ -4080,6 +6230,757 @@ function renderExperimentSummary(experiment) {
 // src/engine/index.ts
 init_multi_repo();
 
+// src/engine/semantic-expand.ts
+init_tfidf();
+function expandQueryWithPMI(index, queryTerms, topK = 3, minPmi = 1, expansionWeight = 0.5) {
+  const uniqueQuery = [...new Set(queryTerms)];
+  const expanded = /* @__PURE__ */ new Map();
+  const expansions = [];
+  for (const term of uniqueQuery) {
+    expanded.set(term, 1);
+  }
+  const N = index.totalDocs;
+  if (N < 5) return { original: uniqueQuery, expanded, expansions };
+  const queryTermDocs = /* @__PURE__ */ new Map();
+  for (const term of uniqueQuery) {
+    const docs = /* @__PURE__ */ new Set();
+    for (const [filePath, doc] of index.documents) {
+      if ((doc.terms.get(term) ?? 0) > 0) docs.add(filePath);
+    }
+    queryTermDocs.set(term, docs);
+  }
+  const queryTermSet = new Set(uniqueQuery);
+  for (const queryTerm of uniqueQuery) {
+    const queryDocs = queryTermDocs.get(queryTerm);
+    if (!queryDocs || queryDocs.size === 0) continue;
+    const pA = queryDocs.size / N;
+    const candidates = [];
+    for (const [candidateTerm] of index.idf) {
+      if (queryTermSet.has(candidateTerm)) continue;
+      if (candidateTerm.length < 3) continue;
+      let cooccurrence = 0;
+      let candidateCount = 0;
+      for (const [filePath, doc] of index.documents) {
+        const hasCand = (doc.terms.get(candidateTerm) ?? 0) > 0;
+        if (hasCand) {
+          candidateCount++;
+          if (queryDocs.has(filePath)) cooccurrence++;
+        }
+      }
+      const minCooc = N >= 20 ? 2 : 1;
+      if (cooccurrence < minCooc) continue;
+      if (candidateCount < minCooc) continue;
+      const pB = candidateCount / N;
+      const pAB = cooccurrence / N;
+      const pmi = Math.log2(pAB / (pA * pB));
+      if (pmi >= minPmi) {
+        candidates.push({ term: candidateTerm, pmi });
+      }
+    }
+    candidates.sort((a, b) => b.pmi - a.pmi);
+    for (const cand of candidates.slice(0, topK)) {
+      const weight = expansionWeight * Math.min(1, cand.pmi / 3);
+      const existing = expanded.get(cand.term) ?? 0;
+      expanded.set(cand.term, Math.max(existing, weight));
+      expansions.push({
+        term: cand.term,
+        source: queryTerm,
+        pmi: cand.pmi,
+        weight
+      });
+    }
+  }
+  return { original: uniqueQuery, expanded, expansions };
+}
+function buildCorpusEmbeddings(index, dimension = 128, nnz = 6, seed = 42) {
+  const termVectors = /* @__PURE__ */ new Map();
+  let rngState = seed;
+  function nextRandom() {
+    rngState = rngState * 1664525 + 1013904223 & 2147483647;
+    return rngState / 2147483647;
+  }
+  for (const [term] of index.idf) {
+    const indices = [];
+    const signs = [];
+    const usedIndices = /* @__PURE__ */ new Set();
+    for (let i = 0; i < nnz; i++) {
+      let idx;
+      do {
+        idx = Math.floor(nextRandom() * dimension);
+      } while (usedIndices.has(idx));
+      usedIndices.add(idx);
+      indices.push(idx);
+      signs.push(nextRandom() > 0.5 ? 1 : -1);
+    }
+    termVectors.set(term, { indices, signs });
+  }
+  const documents = /* @__PURE__ */ new Map();
+  for (const [filePath, doc] of index.documents) {
+    const embedding = new Float64Array(dimension);
+    for (const [term, count] of doc.terms) {
+      const idf = index.idf.get(term) ?? 0;
+      const tfidfWeight = count * idf;
+      const vec = termVectors.get(term);
+      if (!vec) continue;
+      for (let i = 0; i < vec.indices.length; i++) {
+        embedding[vec.indices[i]] += tfidfWeight * vec.signs[i];
+      }
+    }
+    documents.set(filePath, embedding);
+  }
+  return { documents, dimension, termVectors };
+}
+function embedQuery(query2, embeddings) {
+  const terms = tokenize(query2);
+  const vec = new Float64Array(embeddings.dimension);
+  for (const term of terms) {
+    const tv = embeddings.termVectors.get(term);
+    if (!tv) continue;
+    for (let i = 0; i < tv.indices.length; i++) {
+      vec[tv.indices[i]] += tv.signs[i];
+    }
+  }
+  return vec;
+}
+function queryByEmbedding(queryVec, embeddings, maxResults = 50) {
+  const results = [];
+  const queryNorm = Math.sqrt(queryVec.reduce((s, v) => s + v * v, 0));
+  if (queryNorm === 0) return results;
+  for (const [filePath, docVec] of embeddings.documents) {
+    let dot = 0;
+    let docNorm = 0;
+    for (let i = 0; i < docVec.length; i++) {
+      dot += queryVec[i] * docVec[i];
+      docNorm += docVec[i] * docVec[i];
+    }
+    docNorm = Math.sqrt(docNorm);
+    if (docNorm === 0) continue;
+    const sim = dot / (queryNorm * docNorm);
+    if (sim > 0) results.push({ filePath, similarity: sim });
+  }
+  results.sort((a, b) => b.similarity - a.similarity);
+  return results.slice(0, maxResults);
+}
+
+// src/engine/weight-tuner.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { join as join9 } from "path";
+var MODEL_DIR2 = ".cto";
+var MODEL_FILE2 = "weight-tuner.json";
+var MIN_FEEDBACK = 5;
+var MAX_HISTORY = 20;
+var DEFAULT_SIGNALS = [
+  { name: "bm25", defaultWeight: 0.4 },
+  { name: "path", defaultWeight: 0.25 },
+  { name: "imports", defaultWeight: 0.2 },
+  { name: "className", defaultWeight: 0.15 }
+];
+function loadWeightTuner(projectPath) {
+  const modelPath = join9(projectPath, MODEL_DIR2, MODEL_FILE2);
+  try {
+    if (existsSync7(modelPath)) {
+      const raw = readFileSync8(modelPath, "utf-8");
+      const model = JSON.parse(raw);
+      if (model.version === 1) return model;
+    }
+  } catch {
+  }
+  return createFreshModel();
+}
+function saveWeightTuner(projectPath, model) {
+  const dir = join9(projectPath, MODEL_DIR2);
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync4(join9(dir, MODEL_FILE2), JSON.stringify(model, null, 2));
+}
+function createFreshModel() {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    signals: DEFAULT_SIGNALS.map((s) => ({
+      ...s,
+      alpha: 1,
+      // uniform prior
+      beta: 1
+    })),
+    totalFeedback: 0,
+    history: []
+  };
+}
+function recordFeedback(model, feedback) {
+  const updated = { ...model, signals: model.signals.map((s) => ({ ...s })) };
+  for (const fb of feedback) {
+    const signal = updated.signals.find((s) => s.name === fb.signal);
+    if (!signal) continue;
+    if (fb.accepted) {
+      signal.alpha += 1;
+    } else {
+      signal.beta += 1;
+    }
+  }
+  updated.totalFeedback += feedback.length;
+  updated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const currentWeights = getOptimizedWeights(updated);
+  updated.history.push({
+    timestamp: updated.updatedAt,
+    weights: currentWeights.weights
+  });
+  if (updated.history.length > MAX_HISTORY) {
+    updated.history = updated.history.slice(-MAX_HISTORY);
+  }
+  return updated;
+}
+function getOptimizedWeights(model) {
+  if (model.totalFeedback < MIN_FEEDBACK) {
+    const weights2 = {};
+    for (const s of model.signals) {
+      weights2[s.name] = s.defaultWeight;
+    }
+    return { weights: weights2, confidence: 0, source: "default" };
+  }
+  const rawWeights = {};
+  let total = 0;
+  for (const s of model.signals) {
+    const mean = s.alpha / (s.alpha + s.beta);
+    rawWeights[s.name] = mean;
+    total += mean;
+  }
+  const weights = {};
+  for (const [name, raw] of Object.entries(rawWeights)) {
+    weights[name] = total > 0 ? raw / total : 1 / Object.keys(rawWeights).length;
+  }
+  const confidence = Math.min(1, model.totalFeedback / 50);
+  return { weights, confidence, source: "learned" };
+}
+function attributeToSignal(signalRanks) {
+  let bestSignal = "";
+  let bestRank = Infinity;
+  for (const [signal, rank] of Object.entries(signalRanks)) {
+    if (rank < bestRank) {
+      bestRank = rank;
+      bestSignal = signal;
+    }
+  }
+  return bestSignal;
+}
+function renderWeightStatus(model) {
+  const tuned = getOptimizedWeights(model);
+  const lines = [];
+  lines.push(`  Signal Weights (${tuned.source}, confidence: ${(tuned.confidence * 100).toFixed(0)}%):`);
+  for (const s of model.signals) {
+    const w = tuned.weights[s.name] ?? 0;
+    const bar = "\u2588".repeat(Math.round(w * 20));
+    const pad = "\u2591".repeat(20 - Math.round(w * 20));
+    const delta = w - s.defaultWeight;
+    const deltaStr = delta >= 0 ? `+${(delta * 100).toFixed(1)}` : `${(delta * 100).toFixed(1)}`;
+    lines.push(`    ${s.name.padEnd(12)} ${bar}${pad} ${(w * 100).toFixed(1)}% (${deltaStr}% vs default)`);
+  }
+  lines.push(`  Total feedback: ${model.totalFeedback} observations`);
+  return lines.join("\n");
+}
+
+// src/engine/ide-telemetry.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join10 } from "path";
+var EMPTY_MODEL = {
+  version: 1,
+  sessions: [],
+  fileOpenCounts: {},
+  fileTaskCounts: {},
+  lastUpdated: 0
+};
+var MAX_SESSIONS = 200;
+function loadTelemetry(projectPath) {
+  const filePath = join10(projectPath, ".cto", "telemetry.json");
+  try {
+    if (!existsSync8(filePath)) return { ...EMPTY_MODEL };
+    const raw = readFileSync9(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version !== 1) return { ...EMPTY_MODEL };
+    return data;
+  } catch {
+    return { ...EMPTY_MODEL };
+  }
+}
+function saveTelemetry(projectPath, model) {
+  const dir = join10(projectPath, ".cto");
+  try {
+    if (!existsSync8(dir)) mkdirSync5(dir, { recursive: true });
+    model.lastUpdated = Date.now();
+    writeFileSync5(join10(dir, "telemetry.json"), JSON.stringify(model, null, 2));
+  } catch {
+  }
+}
+function recordFileOpen(model, filePath, taskContext) {
+  model.fileOpenCounts[filePath] = (model.fileOpenCounts[filePath] ?? 0) + 1;
+  if (taskContext) {
+    const taskType = extractTaskType(taskContext);
+    if (!model.fileTaskCounts[filePath]) {
+      model.fileTaskCounts[filePath] = {};
+    }
+    model.fileTaskCounts[filePath][taskType] = (model.fileTaskCounts[filePath][taskType] ?? 0) + 1;
+  }
+  return model;
+}
+function recordSession(model, taskDescription, suggestedFiles, openedFiles) {
+  model.sessions.push({
+    taskDescription,
+    suggestedFiles,
+    openedFiles,
+    timestamp: Date.now()
+  });
+  if (model.sessions.length > MAX_SESSIONS) {
+    model.sessions = model.sessions.slice(-MAX_SESSIONS);
+  }
+  for (const file of openedFiles) {
+    recordFileOpen(model, file, taskDescription);
+  }
+  return model;
+}
+function getTelemetryBoosts(model, taskType, candidateFiles) {
+  const boosts = /* @__PURE__ */ new Map();
+  if (model.sessions.length === 0) return boosts;
+  const suggestCount = /* @__PURE__ */ new Map();
+  const openCount = /* @__PURE__ */ new Map();
+  for (const session of model.sessions) {
+    const sessionTaskType = extractTaskType(session.taskDescription);
+    const typeMatch = sessionTaskType === taskType ? 1.5 : 1;
+    const openedSet = new Set(session.openedFiles);
+    for (const file of session.suggestedFiles) {
+      suggestCount.set(file, (suggestCount.get(file) ?? 0) + typeMatch);
+      if (openedSet.has(file)) {
+        openCount.set(file, (openCount.get(file) ?? 0) + typeMatch);
+      }
+    }
+  }
+  for (const file of candidateFiles) {
+    const suggested = suggestCount.get(file) ?? 0;
+    if (suggested < 2) continue;
+    const opened = openCount.get(file) ?? 0;
+    const acceptRate = opened / suggested;
+    const boost = acceptRate - 0.5;
+    boosts.set(file, boost);
+  }
+  return boosts;
+}
+function extractTaskType(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  if (lower.match(/fix|bug|error|debug|crash|broken/)) return "debug";
+  if (lower.match(/test|spec|coverage/)) return "test";
+  if (lower.match(/refactor|restructure|clean/)) return "refactor";
+  if (lower.match(/doc|readme|comment/)) return "docs";
+  if (lower.match(/add|implement|create|build|feature/)) return "feature";
+  return "general";
+}
+function renderTelemetrySummary(model) {
+  const lines = [];
+  lines.push(`IDE Telemetry: ${model.sessions.length} sessions tracked`);
+  const sorted = Object.entries(model.fileOpenCounts).sort(([, a], [, b]) => b - a).slice(0, 10);
+  if (sorted.length > 0) {
+    lines.push("Most opened files:");
+    for (const [file, count] of sorted) {
+      lines.push(`  ${count}\xD7 ${file}`);
+    }
+  }
+  if (model.sessions.length > 0) {
+    const last10 = model.sessions.slice(-10);
+    const totalSuggested = last10.reduce((s, sess) => s + sess.suggestedFiles.length, 0);
+    const totalOpened = last10.reduce((s, sess) => s + sess.openedFiles.length, 0);
+    const rate = totalSuggested > 0 ? (totalOpened / totalSuggested * 100).toFixed(1) : "0";
+    lines.push(`Last 10 sessions: ${rate}% acceptance rate (${totalOpened}/${totalSuggested} files used)`);
+  }
+  return lines.join("\n");
+}
+
+// src/engine/chunk-retrieval.ts
+init_tfidf();
+function chunkJava(content, filePath) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let i = 0;
+  const importStart = lines.findIndex((l) => l.trim().startsWith("import "));
+  if (importStart >= 0) {
+    let importEnd = importStart;
+    while (importEnd < lines.length && (lines[importEnd].trim().startsWith("import ") || lines[importEnd].trim() === "")) {
+      importEnd++;
+    }
+    if (importEnd > importStart) {
+      chunks.push({
+        filePath,
+        startLine: importStart + 1,
+        endLine: importEnd,
+        content: lines.slice(importStart, importEnd).join("\n"),
+        kind: "import",
+        name: "imports",
+        score: 0,
+        tokens: estimateTokens2(lines.slice(importStart, importEnd).join("\n"))
+      });
+    }
+  }
+  i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    const classMatch = line.match(/^(?:public|abstract|private|protected)?\s*(?:static\s+)?(?:final\s+)?(?:class|interface|enum)\s+(\w+)/);
+    if (classMatch) {
+      const classEnd = findBraceEnd(lines, i);
+      chunks.push({
+        filePath,
+        startLine: i + 1,
+        endLine: classEnd + 1,
+        content: lines.slice(i, classEnd + 1).join("\n"),
+        kind: line.includes("interface") ? "interface" : "class",
+        name: classMatch[1],
+        score: 0,
+        tokens: estimateTokens2(lines.slice(i, classEnd + 1).join("\n"))
+      });
+    }
+    const methodMatch = line.match(/^(?:@\w+\s+)*(?:public|private|protected|static|\s)+\s+[\w<>\[\],\s?]+\s+(\w+)\s*\(/);
+    if (methodMatch && !classMatch) {
+      const name = methodMatch[1];
+      if (!["if", "for", "while", "switch", "catch", "return"].includes(name)) {
+        let methodStart = i;
+        while (methodStart > 0 && lines[methodStart - 1].trim().startsWith("@")) {
+          methodStart--;
+        }
+        const methodEnd = findBraceEnd(lines, i);
+        const className = findEnclosingClass(lines, i);
+        chunks.push({
+          filePath,
+          startLine: methodStart + 1,
+          endLine: methodEnd + 1,
+          content: lines.slice(methodStart, methodEnd + 1).join("\n"),
+          kind: "method",
+          name,
+          className,
+          score: 0,
+          tokens: estimateTokens2(lines.slice(methodStart, methodEnd + 1).join("\n"))
+        });
+        i = methodEnd + 1;
+        continue;
+      }
+    }
+    i++;
+  }
+  return chunks;
+}
+function chunkTypeScript(content, filePath) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let i = 0;
+  const importLines = [];
+  let importStart = -1;
+  for (let j = 0; j < lines.length; j++) {
+    if (lines[j].trim().startsWith("import ")) {
+      if (importStart === -1) importStart = j;
+      importLines.push(lines[j]);
+    } else if (importStart >= 0 && lines[j].trim() === "") {
+      continue;
+    } else if (importStart >= 0) {
+      break;
+    }
+  }
+  if (importLines.length > 0) {
+    chunks.push({
+      filePath,
+      startLine: importStart + 1,
+      endLine: importStart + importLines.length,
+      content: importLines.join("\n"),
+      kind: "import",
+      name: "imports",
+      score: 0,
+      tokens: estimateTokens2(importLines.join("\n"))
+    });
+  }
+  i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    const funcMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    const classMatch = line.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+    const interfaceMatch = line.match(/^(?:export\s+)?(?:interface|type)\s+(\w+)/);
+    const arrowMatch = line.match(/^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+    if (funcMatch || classMatch || arrowMatch) {
+      const name = (funcMatch || classMatch || arrowMatch)[1];
+      const blockEnd = findBraceEnd(lines, i);
+      const kind = classMatch ? "class" : "function";
+      chunks.push({
+        filePath,
+        startLine: i + 1,
+        endLine: blockEnd + 1,
+        content: lines.slice(i, blockEnd + 1).join("\n"),
+        kind,
+        name,
+        score: 0,
+        tokens: estimateTokens2(lines.slice(i, blockEnd + 1).join("\n"))
+      });
+      if (kind === "function") {
+        i = blockEnd + 1;
+        continue;
+      }
+    }
+    if (interfaceMatch) {
+      const blockEnd = findBraceEnd(lines, i);
+      chunks.push({
+        filePath,
+        startLine: i + 1,
+        endLine: blockEnd + 1,
+        content: lines.slice(i, blockEnd + 1).join("\n"),
+        kind: "interface",
+        name: interfaceMatch[1],
+        score: 0,
+        tokens: estimateTokens2(lines.slice(i, blockEnd + 1).join("\n"))
+      });
+      i = blockEnd + 1;
+      continue;
+    }
+    i++;
+  }
+  return chunks;
+}
+function chunkPython(content, filePath) {
+  const lines = content.split("\n");
+  const chunks = [];
+  const importLines = [];
+  for (let j = 0; j < lines.length; j++) {
+    if (lines[j].trim().startsWith("import ") || lines[j].trim().startsWith("from ")) {
+      importLines.push(j);
+    }
+  }
+  if (importLines.length > 0) {
+    const start = importLines[0];
+    const end = importLines[importLines.length - 1];
+    chunks.push({
+      filePath,
+      startLine: start + 1,
+      endLine: end + 1,
+      content: lines.slice(start, end + 1).join("\n"),
+      kind: "import",
+      name: "imports",
+      score: 0,
+      tokens: estimateTokens2(lines.slice(start, end + 1).join("\n"))
+    });
+  }
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const classMatch = trimmed.match(/^class\s+(\w+)/);
+    const funcMatch = trimmed.match(/^(?:async\s+)?def\s+(\w+)/);
+    const decoratorStart = trimmed.startsWith("@") ? i : -1;
+    if (classMatch || funcMatch) {
+      const name = (classMatch || funcMatch)[1];
+      const indent = line.length - line.trimStart().length;
+      let blockStart = decoratorStart >= 0 ? decoratorStart : i;
+      if (decoratorStart < 0 && i > 0 && lines[i - 1].trim().startsWith("@")) {
+        blockStart = i - 1;
+        while (blockStart > 0 && lines[blockStart - 1].trim().startsWith("@")) blockStart--;
+      }
+      let end = i + 1;
+      while (end < lines.length) {
+        const nextLine = lines[end];
+        if (nextLine.trim() === "") {
+          end++;
+          continue;
+        }
+        const nextIndent = nextLine.length - nextLine.trimStart().length;
+        if (nextIndent <= indent && nextLine.trim() !== "") break;
+        end++;
+      }
+      const kind = classMatch ? "class" : "function";
+      let className;
+      if (funcMatch && indent > 0) {
+        for (let j = i - 1; j >= 0; j--) {
+          const prevMatch = lines[j].trim().match(/^class\s+(\w+)/);
+          if (prevMatch) {
+            className = prevMatch[1];
+            break;
+          }
+        }
+      }
+      chunks.push({
+        filePath,
+        startLine: blockStart + 1,
+        endLine: end,
+        content: lines.slice(blockStart, end).join("\n"),
+        kind: className ? "method" : kind,
+        name,
+        className,
+        score: 0,
+        tokens: estimateTokens2(lines.slice(blockStart, end).join("\n"))
+      });
+      i = end;
+      continue;
+    }
+    i++;
+  }
+  return chunks;
+}
+function chunkGo(content, filePath) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    const funcMatch = line.match(/^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/);
+    const typeMatch = line.match(/^type\s+(\w+)\s+(struct|interface)/);
+    if (funcMatch) {
+      const end = findBraceEnd(lines, i);
+      const receiverMatch = line.match(/^func\s+\(\s*\w+\s+\*?(\w+)\s*\)/);
+      chunks.push({
+        filePath,
+        startLine: i + 1,
+        endLine: end + 1,
+        content: lines.slice(i, end + 1).join("\n"),
+        kind: receiverMatch ? "method" : "function",
+        name: funcMatch[1],
+        className: receiverMatch?.[1],
+        score: 0,
+        tokens: estimateTokens2(lines.slice(i, end + 1).join("\n"))
+      });
+      i = end + 1;
+      continue;
+    }
+    if (typeMatch) {
+      const end = findBraceEnd(lines, i);
+      chunks.push({
+        filePath,
+        startLine: i + 1,
+        endLine: end + 1,
+        content: lines.slice(i, end + 1).join("\n"),
+        kind: typeMatch[2] === "interface" ? "interface" : "class",
+        name: typeMatch[1],
+        score: 0,
+        tokens: estimateTokens2(lines.slice(i, end + 1).join("\n"))
+      });
+      i = end + 1;
+      continue;
+    }
+    i++;
+  }
+  return chunks;
+}
+function findBraceEnd(lines, start) {
+  let depth = 0;
+  let foundOpen = false;
+  for (let i = start; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      }
+      if (ch === "}") {
+        depth--;
+      }
+      if (foundOpen && depth === 0) return i;
+    }
+  }
+  return Math.min(start + 30, lines.length - 1);
+}
+function findEnclosingClass(lines, methodLine) {
+  for (let i = methodLine - 1; i >= 0; i--) {
+    const match = lines[i].trim().match(/(?:class|interface|enum)\s+(\w+)/);
+    if (match) return match[1];
+  }
+  return void 0;
+}
+function estimateTokens2(content) {
+  return Math.ceil(content.length / 4);
+}
+function getLanguage2(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 chunkFile(content, filePath) {
+  const lang = getLanguage2(filePath);
+  if (!lang) return [];
+  switch (lang) {
+    case "java":
+      return chunkJava(content, filePath);
+    case "ts":
+      return chunkTypeScript(content, filePath);
+    case "python":
+      return chunkPython(content, filePath);
+    case "go":
+      return chunkGo(content, filePath);
+  }
+}
+function scoreChunks(chunks, task) {
+  const queryTerms = tokenize(task);
+  const queryTermSet = new Set(queryTerms);
+  for (const chunk of chunks) {
+    const chunkTerms = tokenize(chunk.content);
+    const chunkTermSet = new Set(chunkTerms);
+    let termOverlap = 0;
+    for (const qt of queryTermSet) {
+      if (chunkTermSet.has(qt)) termOverlap++;
+    }
+    const termCoverage = queryTermSet.size > 0 ? termOverlap / queryTermSet.size : 0;
+    let nameBonus = 0;
+    const nameTerms = tokenize(chunk.name + (chunk.className ? " " + chunk.className : ""));
+    for (const nt of nameTerms) {
+      if (queryTermSet.has(nt)) nameBonus += 0.3;
+    }
+    const kindBonus = chunk.kind === "method" || chunk.kind === "function" ? 0.1 : chunk.kind === "class" || chunk.kind === "interface" ? 0.05 : 0;
+    const sizePenalty = chunk.tokens > 500 ? 0.9 : chunk.tokens > 1e3 ? 0.7 : 1;
+    chunk.score = (termCoverage + nameBonus + kindBonus) * sizePenalty;
+  }
+  return chunks.sort((a, b) => b.score - a.score);
+}
+function retrieveChunks(files, task, tokenBudget = 3e4, minScore = 0.1) {
+  const allChunks = [];
+  for (const file of files) {
+    const chunks = chunkFile(file.content, file.relativePath);
+    allChunks.push(...chunks);
+  }
+  scoreChunks(allChunks, task);
+  const selectedChunks = [];
+  const fileChunks = /* @__PURE__ */ new Map();
+  let tokensUsed = 0;
+  for (const chunk of allChunks) {
+    if (chunk.score < minScore) continue;
+    if (tokensUsed + chunk.tokens > tokenBudget) continue;
+    selectedChunks.push(chunk);
+    tokensUsed += chunk.tokens;
+    const existing = fileChunks.get(chunk.filePath) ?? [];
+    existing.push(chunk);
+    fileChunks.set(chunk.filePath, existing);
+  }
+  for (const [, chunks] of fileChunks) {
+    chunks.sort((a, b) => a.startLine - b.startLine);
+  }
+  return {
+    chunks: selectedChunks,
+    fileChunks,
+    totalChunks: allChunks.length,
+    totalTokensUsed: tokensUsed
+  };
+}
+function renderFileChunks(filePath, chunks, ext) {
+  if (chunks.length === 0) return "";
+  let result = `### ${filePath}
+\`\`\`${ext}
+`;
+  for (let i = 0; i < chunks.length; i++) {
+    if (i > 0) {
+      const prevEnd = chunks[i - 1].endLine;
+      const currStart = chunks[i].startLine;
+      if (currStart > prevEnd + 1) {
+        result += `
+// ... lines ${prevEnd + 1}-${currStart - 1} omitted ...
+
+`;
+      }
+    }
+    result += `// L${chunks[i].startLine}-${chunks[i].endLine}: ${chunks[i].kind} ${chunks[i].name}
+`;
+    result += chunks[i].content + "\n";
+  }
+  result += "```\n\n";
+  return result;
+}
+
 // src/engine/logger.ts
 var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
 var currentLevel = process.env.CTO_LOG_LEVEL ?? "warn";
@@ -4160,59 +7061,103 @@ export {
   CtoError,
   analyzeProject,
   assignGroup,
+  attributeToSignal,
   auditProject,
+  augmentContentWithStructure,
   bfsBidirectional,
+  boostByCallGraph,
+  boostByGitCoChange,
+  boostByImports,
+  boostByLayer,
   boostByPath,
   buildAdjacencyList,
+  buildCallGraph,
+  buildCoChangeMatrix,
+  buildCorpusEmbeddings,
   buildIndex,
   buildIndexCached,
+  buildNeuralEmbeddingIndex,
   buildProjectGraph,
+  buildTfIdfEmbeddingIndex,
+  buildWeightedQuery,
   calculateCoverage,
+  chunkFile,
   classifyFileKind,
   countTokensChars4,
   countTokensTiktoken,
   createExperiment,
+  createFreshModel,
   createLogger,
   createProject,
   detectLanguage,
   detectStack,
   discoverSiblingRepos,
+  embedQuery,
+  reciprocalRankFusion2 as embeddingRRF,
   estimateComplexity,
   estimateFileTokens,
   estimateTokens,
+  expandLayers,
+  expandQuery,
+  expandQueryWithPMI,
+  expandTerm,
   extractPattern,
+  extractStructuralTokens,
   freeEncoder,
   getActiveExperiment,
   getCacheInfo,
   getConcludedExperiments,
+  getExpansionDetails,
+  getGitRecency,
   getLearnerBoosts,
   getLearnerStats,
+  getOptimizedWeights,
   getPruneLevelForRisk,
+  getStructuralSummary,
+  getSynonymStats,
+  getTelemetryBoosts,
   invalidateCache,
   isCtoError,
+  isOnnxAvailable,
   loadExperiments,
   loadLearner,
+  loadTelemetry,
+  loadWeightTuner,
+  multiHopQuery,
   optimizeBudget,
   parseAllPolyglotImports,
   parseImports,
+  parseQueryIntent,
   parseSiblingPaths,
   pruneFile,
   pruneFiles,
   query,
+  queryByEmbedding,
   querySiblingRepos,
+  reciprocalRankFusion,
+  recordFeedback,
+  recordFileOpen,
   recordOutcome,
   recordSelection,
+  recordSession,
   renderExperimentSummary,
+  renderFileChunks,
   renderMultiRepoSummary,
+  renderTelemetrySummary,
+  renderWeightStatus,
   rerank,
+  retrieveChunks,
   runContextPipeline,
   sanitizeContent,
   saveExperiments,
   saveLearner,
+  saveTelemetry,
+  saveWeightTuner,
   scanContentForSecrets,
   scanFileForSecrets,
   scanProjectForSecrets,
   scoreAllFiles,
+  scoreChunks,
   scoreFile,
   selectContext,
   setJsonLogging,