cto-ai-cli 6.1.0 → 7.1.0

package/dist/engine/index.js

@@ -1,6 +1,530 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/engine/tfidf.ts
+function buildIndex(files) {
+  const documents = /* @__PURE__ */ new Map();
+  const docFreq = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const terms = tokenize(file.content);
+    const termCounts = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      termCounts.set(term, (termCounts.get(term) ?? 0) + 1);
+    }
+    documents.set(file.relativePath, { terms: termCounts, length: terms.length });
+    for (const term of termCounts.keys()) {
+      docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const totalDocs = files.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const [term, df] of docFreq) {
+    idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
+  }
+  let totalLength = 0;
+  for (const doc of documents.values()) totalLength += doc.length;
+  const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
+  return { documents, idf, avgDocLength, totalDocs };
+}
+function query(index, taskDescription, maxResults = 50) {
+  const queryTerms = tokenize(taskDescription);
+  if (queryTerms.length === 0) return [];
+  const querySet = /* @__PURE__ */ new Map();
+  for (const term of queryTerms) {
+    querySet.set(term, (querySet.get(term) ?? 0) + 1);
+  }
+  const results = [];
+  const k1 = 1.5;
+  const b = 0.75;
+  for (const [filePath, doc] of index.documents) {
+    let score = 0;
+    const matchedTerms = [];
+    for (const [qTerm, qCount] of querySet) {
+      const tf = doc.terms.get(qTerm) ?? 0;
+      if (tf === 0) continue;
+      const termIdf = index.idf.get(qTerm) ?? 0;
+      if (termIdf <= 0) continue;
+      const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / index.avgDocLength));
+      score += termIdf * tfNorm * qCount;
+      matchedTerms.push(qTerm);
+    }
+    if (score > 0) {
+      results.push({ filePath, score, matchedTerms });
+    }
+  }
+  const maxScore = results.reduce((max, r) => Math.max(max, r.score), 0);
+  if (maxScore > 0) {
+    for (const r of results) r.score = r.score / maxScore;
+  }
+  return results.sort((a, b2) => b2.score - a.score).slice(0, maxResults);
+}
+function similarity(index, pathA, pathB) {
+  const docA = index.documents.get(pathA);
+  const docB = index.documents.get(pathB);
+  if (!docA || !docB) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  const allTerms = /* @__PURE__ */ new Set([...docA.terms.keys(), ...docB.terms.keys()]);
+  for (const term of allTerms) {
+    const idf = index.idf.get(term) ?? 0;
+    const wA = (docA.terms.get(term) ?? 0) * idf;
+    const wB = (docB.terms.get(term) ?? 0) * idf;
+    dotProduct += wA * wB;
+    normA += wA * wA;
+    normB += wB * wB;
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom > 0 ? dotProduct / denom : 0;
+}
+function tokenize(text) {
+  const tokens = [];
+  const rawTokens = text.match(/[a-zA-Z][a-zA-Z0-9]*|[0-9]+/g) ?? [];
+  for (const raw of rawTokens) {
+    const parts = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
+    for (const part of parts) {
+      if (part.length < 2) continue;
+      const stemmed = stem(part);
+      if (stemmed.length < 2) continue;
+      if (STOP_WORDS.has(stemmed)) continue;
+      tokens.push(stemmed);
+    }
+  }
+  return tokens;
+}
+function stem(word) {
+  let w = word.toLowerCase();
+  for (const [prefix, root] of TERM_FAMILIES) {
+    if (w.startsWith(prefix) || w === root) return root;
+  }
+  if (w.endsWith("ication") && w.length > 9) return w.slice(0, -7);
+  if (w.endsWith("ation") && w.length > 7) return w.slice(0, -5);
+  if (w.endsWith("tion") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("sion") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ment") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ness") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("able") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ible") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ator") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("izer") && w.length > 6) return w.slice(0, -4);
+  if (w.endsWith("ing") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ies") && w.length > 4) return w.slice(0, -3) + "y";
+  if (w.endsWith("ous") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ful") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ity") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ive") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ion") && w.length > 5) return w.slice(0, -3);
+  if (w.endsWith("ed") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("er") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("ly") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("al") && w.length > 4) return w.slice(0, -2);
+  if (w.endsWith("s") && !w.endsWith("ss") && w.length > 3) return w.slice(0, -1);
+  return w;
+}
+function boostByPath(matches, allFiles, taskDescription) {
+  const queryTerms = new Set(tokenize(taskDescription));
+  const boosted = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+  }
+  for (const filePath of allFiles) {
+    const pathTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
+    const pathMatches = pathTerms.filter((t) => queryTerms.has(t));
+    if (pathMatches.length > 0) {
+      const existing = boosted.get(filePath);
+      const pathBoost = pathMatches.length * 0.3;
+      if (existing) {
+        existing.score = Math.min(1, existing.score + pathBoost);
+        for (const t of pathMatches) {
+          if (!existing.matchedTerms.includes(t)) existing.matchedTerms.push(t);
+        }
+      } else {
+        boosted.set(filePath, {
+          filePath,
+          score: Math.min(1, pathBoost),
+          matchedTerms: pathMatches
+        });
+      }
+    }
+  }
+  return [...boosted.values()].sort((a, b) => b.score - a.score);
+}
+var STOP_WORDS, TERM_FAMILIES;
+var init_tfidf = __esm({
+  "src/engine/tfidf.ts"() {
+    "use strict";
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      // Language keywords
+      "import",
+      "export",
+      "from",
+      "const",
+      "let",
+      "var",
+      "function",
+      "class",
+      "interface",
+      "type",
+      "return",
+      "async",
+      "await",
+      "new",
+      "this",
+      "that",
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "void",
+      "string",
+      "number",
+      "boolean",
+      "any",
+      "unknown",
+      "never",
+      "object",
+      "array",
+      "promise",
+      "if",
+      "else",
+      "for",
+      "while",
+      "do",
+      "switch",
+      "case",
+      "break",
+      "continue",
+      "try",
+      "catch",
+      "throw",
+      "finally",
+      "default",
+      "extends",
+      "implements",
+      "static",
+      "private",
+      "public",
+      "protected",
+      "readonly",
+      "abstract",
+      "override",
+      "super",
+      "typeof",
+      "instanceof",
+      "in",
+      "of",
+      "as",
+      "is",
+      "keyof",
+      "enum",
+      "namespace",
+      "module",
+      "declare",
+      // Python
+      "def",
+      "self",
+      "cls",
+      "none",
+      "pass",
+      "yield",
+      "lambda",
+      "with",
+      "elif",
+      "except",
+      "raise",
+      "assert",
+      "global",
+      "nonlocal",
+      // Natural language stop words only — NOT domain terms that carry signal
+      "the",
+      "and",
+      "for",
+      "with",
+      "not",
+      "but",
+      "are",
+      "was",
+      "were",
+      "has",
+      "have",
+      "had",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "can",
+      "its",
+      "also",
+      "than",
+      "then",
+      "into",
+      "only",
+      "very",
+      "just",
+      "about",
+      "being",
+      "been",
+      "does",
+      "did",
+      "doing",
+      "todo",
+      "fixme",
+      "hack",
+      "note",
+      "xxx"
+    ]);
+    TERM_FAMILIES = [
+      ["authenticat", "auth"],
+      ["authori", "auth"],
+      ["configur", "config"],
+      ["connect", "connect"],
+      ["request", "request"],
+      ["response", "respons"],
+      ["middlewar", "middlewar"],
+      ["validat", "valid"],
+      ["initiali", "init"],
+      ["subscri", "subscrib"],
+      ["transform", "transform"],
+      ["seriali", "serial"],
+      ["deseriali", "serial"],
+      ["dependen", "depend"],
+      ["environ", "environ"],
+      ["permiss", "permiss"],
+      ["migrat", "migrat"],
+      ["transact", "transact"],
+      ["encryp", "encrypt"],
+      ["decryp", "encrypt"]
+    ];
+  }
+});
+
+// src/engine/multi-repo.ts
+var multi_repo_exports = {};
+__export(multi_repo_exports, {
+  discoverSiblingRepos: () => discoverSiblingRepos,
+  parseSiblingPaths: () => parseSiblingPaths,
+  querySiblingRepos: () => querySiblingRepos,
+  renderMultiRepoSummary: () => renderMultiRepoSummary
+});
+import { readdirSync, readFileSync as readFileSync5, statSync as statSync2, existsSync as existsSync5 } from "fs";
+import { join as join7, basename as basename3, resolve as resolve5, relative as relative5 } from "path";
+function discoverSiblingRepos(projectPath) {
+  const absProject = resolve5(projectPath);
+  const parentDir = join7(absProject, "..");
+  const projectName = basename3(absProject);
+  const siblings = [];
+  let entries;
+  try {
+    entries = readdirSync(parentDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (entry === projectName) continue;
+    if (entry.startsWith(".")) continue;
+    if (SKIP_DIRS.has(entry)) continue;
+    const candidatePath = join7(parentDir, entry);
+    try {
+      if (!statSync2(candidatePath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const hasMarker = REPO_MARKERS.some((marker) => {
+      try {
+        return existsSync5(join7(candidatePath, marker));
+      } catch {
+        return false;
+      }
+    });
+    if (!hasMarker) continue;
+    const stack = detectStack2(candidatePath);
+    siblings.push({
+      path: candidatePath,
+      name: entry,
+      stack,
+      fileCount: 0
+      // filled during indexing
+    });
+  }
+  return siblings;
+}
+function detectStack2(repoPath) {
+  const stack = [];
+  try {
+    if (existsSync5(join7(repoPath, "tsconfig.json"))) stack.push("TypeScript");
+    if (existsSync5(join7(repoPath, "package.json"))) stack.push("Node.js");
+    if (existsSync5(join7(repoPath, "Cargo.toml"))) stack.push("Rust");
+    if (existsSync5(join7(repoPath, "go.mod"))) stack.push("Go");
+    if (existsSync5(join7(repoPath, "pyproject.toml"))) stack.push("Python");
+    if (existsSync5(join7(repoPath, "pom.xml"))) stack.push("Java");
+  } catch {
+  }
+  return stack;
+}
+function listSourceFiles(repoPath, maxFiles = MAX_FILES_PER_REPO) {
+  const files = [];
+  function walk(dir, depth) {
+    if (depth > 8 || files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      if (entry.startsWith(".")) continue;
+      if (SKIP_DIRS.has(entry)) continue;
+      const fullPath = join7(dir, entry);
+      try {
+        const stat3 = statSync2(fullPath);
+        if (stat3.isDirectory()) {
+          walk(fullPath, depth + 1);
+        } else if (stat3.isFile() && stat3.size <= MAX_FILE_SIZE) {
+          const ext = entry.split(".").pop()?.toLowerCase() ?? "";
+          if (SOURCE_EXTENSIONS.has(ext)) {
+            files.push(relative5(repoPath, fullPath));
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  walk(repoPath, 0);
+  return files;
+}
+function indexSiblingRepo(repo) {
+  const filePaths = listSourceFiles(repo.path);
+  repo.fileCount = filePaths.length;
+  const contents = [];
+  const contentMap = /* @__PURE__ */ new Map();
+  for (const relPath of filePaths) {
+    try {
+      const content = readFileSync5(join7(repo.path, relPath), "utf-8");
+      contents.push({ relativePath: relPath, content });
+      contentMap.set(relPath, content);
+    } catch {
+      contents.push({ relativePath: relPath, content: "" });
+    }
+  }
+  return { contents, contentMap };
+}
+function querySiblingRepos(siblings, task, maxPerRepo = 5, minScore = 0.3) {
+  const startTime = performance.now();
+  const allMatches = [];
+  for (const repo of siblings) {
+    const { contents, contentMap } = indexSiblingRepo(repo);
+    if (contents.length === 0) continue;
+    const index = buildIndex(contents);
+    const matches = query(index, task, maxPerRepo * 2);
+    const boosted = boostByPath(
+      matches,
+      contents.map((c) => c.relativePath),
+      task
+    );
+    for (const match of boosted.slice(0, maxPerRepo)) {
+      if (match.score < minScore) continue;
+      const content = contentMap.get(match.filePath) ?? "";
+      const tokens = Math.ceil(content.length / 4);
+      allMatches.push({
+        repoName: repo.name,
+        repoPath: repo.path,
+        relativePath: match.filePath,
+        absolutePath: join7(repo.path, match.filePath),
+        score: match.score,
+        content,
+        tokens
+      });
+    }
+  }
+  allMatches.sort((a, b) => b.score - a.score);
+  return {
+    siblings,
+    matches: allMatches,
+    timeMs: Math.round(performance.now() - startTime)
+  };
+}
+function parseSiblingPaths(pathsStr, projectPath) {
+  const absProject = resolve5(projectPath);
+  return pathsStr.split(",").map((p) => p.trim()).filter((p) => p.length > 0).map((p) => {
+    const absPath = resolve5(join7(absProject, ".."), p);
+    return {
+      path: absPath,
+      name: basename3(absPath),
+      stack: detectStack2(absPath),
+      fileCount: 0
+    };
+  }).filter((repo) => existsSync5(repo.path));
+}
+function renderMultiRepoSummary(result) {
+  const lines = [];
+  if (result.siblings.length === 0) {
+    lines.push("  No sibling repos found.");
+    return lines.join("\n");
+  }
+  lines.push(`  Sibling repos scanned: ${result.siblings.length} (${result.timeMs}ms)`);
+  for (const repo of result.siblings) {
+    lines.push(`    ${repo.name}/ \u2014 ${repo.fileCount} files [${repo.stack.join(", ") || "unknown"}]`);
+  }
+  if (result.matches.length === 0) {
+    lines.push("  No relevant files found in sibling repos.");
+  } else {
+    lines.push(`  Cross-repo matches: ${result.matches.length}`);
+    for (const m of result.matches.slice(0, 10)) {
+      const pct = Math.round(m.score * 100);
+      lines.push(`    ${m.repoName}/${m.relativePath}  sem: ${pct}%  (~${Math.round(m.tokens / 1e3)}K tok)`);
+    }
+  }
+  return lines.join("\n");
+}
+var REPO_MARKERS, SKIP_DIRS, SOURCE_EXTENSIONS, MAX_FILES_PER_REPO, MAX_FILE_SIZE;
+var init_multi_repo = __esm({
+  "src/engine/multi-repo.ts"() {
+    "use strict";
+    init_tfidf();
+    REPO_MARKERS = ["package.json", "tsconfig.json", "Cargo.toml", "go.mod", "pyproject.toml", "pom.xml"];
+    SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor"]);
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mjs",
+      "cjs",
+      "py",
+      "rs",
+      "go",
+      "java",
+      "kt",
+      "rb",
+      "c",
+      "cpp",
+      "h",
+      "hpp",
+      "cs",
+      "json",
+      "yaml",
+      "yml",
+      "toml",
+      "md",
+      "txt"
+    ]);
+    MAX_FILES_PER_REPO = 500;
+    MAX_FILE_SIZE = 1e5;
+  }
+});
+
 // src/engine/analyzer.ts
 import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
-import { join as join2, extname, relative as relative2, resolve as resolve2, basename as basename2 } from "path";
+import { join as join3, extname, relative as relative3, resolve as resolve3, basename as basename2 } from "path";
 import { createHash } from "crypto";
 
 // src/types/engine.ts
@@ -100,12 +624,727 @@ function freeEncoder() {
 
 // src/engine/graph.ts
 import { Project, SyntaxKind } from "ts-morph";
-import { resolve, relative, dirname, join } from "path";
-import { existsSync } from "fs";
+import { resolve as resolve2, relative as relative2, dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+
+// src/engine/polyglot-graph.ts
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+var LANG_EXTENSIONS = {
+  "py": "python",
+  "pyw": "python",
+  "go": "go",
+  "java": "java",
+  "rs": "rust",
+  "ts": "typescript",
+  "tsx": "typescript",
+  "js": "typescript",
+  "jsx": "typescript",
+  "mts": "typescript",
+  "mjs": "typescript",
+  "cts": "typescript",
+  "cjs": "typescript"
+};
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return LANG_EXTENSIONS[ext] ?? null;
+}
+function parseImports(filePath, relativePath, projectPath, allRelativePaths, content) {
+  const lang = detectLanguage(relativePath);
+  if (!lang || lang === "typescript") return [];
+  const src = content ?? safeReadFile(filePath);
+  if (!src) return [];
+  const edges = [];
+  let specs;
+  switch (lang) {
+    case "python":
+      specs = parsePythonImports(src);
+      break;
+    case "go":
+      specs = parseGoImports(src);
+      break;
+    case "java":
+      specs = parseJavaImports(src);
+      break;
+    case "rust":
+      specs = parseRustImports(src);
+      break;
+    default:
+      return [];
+  }
+  for (const spec of specs) {
+    const resolved = resolveImportSpec(spec, relativePath, projectPath, allRelativePaths, lang);
+    if (resolved) {
+      edges.push({ from: relativePath, to: resolved, type: "import" });
+    }
+  }
+  return edges;
+}
+function parseAllPolyglotImports(files, projectPath) {
+  const allPaths = new Set(files.map((f) => f.relativePath));
+  const edges = [];
+  for (const file of files) {
+    const lang = detectLanguage(file.relativePath);
+    if (!lang || lang === "typescript") continue;
+    const fileEdges = parseImports(
+      file.absolutePath,
+      file.relativePath,
+      projectPath,
+      allPaths,
+      file.content
+    );
+    edges.push(...fileEdges);
+  }
+  return edges;
+}
+function estimateComplexity(content, lang) {
+  let complexity = 1;
+  const lines = content.split("\n");
+  const patterns = {
+    python: [
+      /^\s*if\s/,
+      /^\s*elif\s/,
+      /^\s*for\s/,
+      /^\s*while\s/,
+      /^\s*except\s/,
+      /\sif\s.*\selse\s/,
+      // ternary
+      /\sand\s/,
+      /\sor\s/
+    ],
+    go: [
+      /^\s*if\s/,
+      /^\s*for\s/,
+      /^\s*case\s/,
+      /^\s*select\s*{/,
+      /&&/,
+      /\|\|/
+    ],
+    java: [
+      /^\s*if\s*\(/,
+      /^\s*for\s*\(/,
+      /^\s*while\s*\(/,
+      /^\s*case\s/,
+      /^\s*catch\s*\(/,
+      /\?\s/,
+      // ternary
+      /&&/,
+      /\|\|/
+    ],
+    rust: [
+      /^\s*if\s/,
+      /^\s*for\s/,
+      /^\s*while\s/,
+      /^\s*match\s/,
+      /=>\s/,
+      // match arms
+      /&&/,
+      /\|\|/
+    ],
+    typescript: []
+    // handled by ts-morph
+  };
+  const langPatterns = patterns[lang];
+  for (const line of lines) {
+    for (const pattern of langPatterns) {
+      if (pattern.test(line)) {
+        complexity++;
+        break;
+      }
+    }
+  }
+  return complexity;
+}
+var PYTHON_STDLIB = /* @__PURE__ */ new Set([
+  "__future__",
+  "abc",
+  "aifc",
+  "argparse",
+  "array",
+  "ast",
+  "asynchat",
+  "asyncio",
+  "asyncore",
+  "atexit",
+  "audioop",
+  "base64",
+  "bdb",
+  "binascii",
+  "binhex",
+  "bisect",
+  "builtins",
+  "bz2",
+  "calendar",
+  "cgi",
+  "cgitb",
+  "chunk",
+  "cmath",
+  "cmd",
+  "code",
+  "codecs",
+  "codeop",
+  "collections",
+  "colorsys",
+  "compileall",
+  "concurrent",
+  "configparser",
+  "contextlib",
+  "contextvars",
+  "copy",
+  "copyreg",
+  "cProfile",
+  "crypt",
+  "csv",
+  "ctypes",
+  "curses",
+  "dataclasses",
+  "datetime",
+  "dbm",
+  "decimal",
+  "difflib",
+  "dis",
+  "distutils",
+  "doctest",
+  "email",
+  "encodings",
+  "enum",
+  "errno",
+  "faulthandler",
+  "fcntl",
+  "filecmp",
+  "fileinput",
+  "fnmatch",
+  "fractions",
+  "ftplib",
+  "functools",
+  "gc",
+  "getopt",
+  "getpass",
+  "gettext",
+  "glob",
+  "grp",
+  "gzip",
+  "hashlib",
+  "heapq",
+  "hmac",
+  "html",
+  "http",
+  "idlelib",
+  "imaplib",
+  "imghdr",
+  "imp",
+  "importlib",
+  "inspect",
+  "io",
+  "ipaddress",
+  "itertools",
+  "json",
+  "keyword",
+  "lib2to3",
+  "linecache",
+  "locale",
+  "logging",
+  "lzma",
+  "mailbox",
+  "mailcap",
+  "marshal",
+  "math",
+  "mimetypes",
+  "mmap",
+  "modulefinder",
+  "multiprocessing",
+  "netrc",
+  "nis",
+  "nntplib",
+  "numbers",
+  "operator",
+  "optparse",
+  "os",
+  "ossaudiodev",
+  "pathlib",
+  "pdb",
+  "pickle",
+  "pickletools",
+  "pipes",
+  "pkgutil",
+  "platform",
+  "plistlib",
+  "poplib",
+  "posix",
+  "posixpath",
+  "pprint",
+  "profile",
+  "pstats",
+  "pty",
+  "pwd",
+  "py_compile",
+  "pyclbr",
+  "pydoc",
+  "queue",
+  "quopri",
+  "random",
+  "re",
+  "readline",
+  "reprlib",
+  "resource",
+  "rlcompleter",
+  "runpy",
+  "sched",
+  "secrets",
+  "select",
+  "selectors",
+  "shelve",
+  "shlex",
+  "shutil",
+  "signal",
+  "site",
+  "smtpd",
+  "smtplib",
+  "sndhdr",
+  "socket",
+  "socketserver",
+  "spwd",
+  "sqlite3",
+  "ssl",
+  "stat",
+  "statistics",
+  "string",
+  "stringprep",
+  "struct",
+  "subprocess",
+  "sunau",
+  "symtable",
+  "sys",
+  "sysconfig",
+  "syslog",
+  "tabnanny",
+  "tarfile",
+  "telnetlib",
+  "tempfile",
+  "termios",
+  "test",
+  "textwrap",
+  "threading",
+  "time",
+  "timeit",
+  "tkinter",
+  "token",
+  "tokenize",
+  "tomllib",
+  "trace",
+  "traceback",
+  "tracemalloc",
+  "tty",
+  "turtle",
+  "turtledemo",
+  "types",
+  "typing",
+  "unicodedata",
+  "unittest",
+  "urllib",
+  "uu",
+  "uuid",
+  "venv",
+  "warnings",
+  "wave",
+  "weakref",
+  "webbrowser",
+  "winreg",
+  "winsound",
+  "wsgiref",
+  "xdrlib",
+  "xml",
+  "xmlrpc",
+  "zipapp",
+  "zipfile",
+  "zipimport",
+  "zlib",
+  "_thread"
+]);
+function isPythonStdlib(module) {
+  const topLevel = module.split(".")[0];
+  return PYTHON_STDLIB.has(topLevel);
+}
+function parsePythonImports(content) {
+  const specs = [];
+  const joined = content.replace(/\(\s*\n([^)]*?)\)/gs, (_, inner) => {
+    return "(" + inner.replace(/\n/g, " ").replace(/\s+/g, " ") + ")";
+  });
+  const lines = joined.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("#")) continue;
+    const fromMatch = trimmed.match(/^from\s+(\.{0,10}[\w.]*)\s+import\s+(.+)/);
+    if (fromMatch) {
+      const raw = fromMatch[1];
+      const isRelative = raw.startsWith(".");
+      if (!isRelative && isPythonStdlib(raw)) continue;
+      specs.push({ raw, isRelative });
+      continue;
+    }
+    const importMatch = trimmed.match(/^import\s+(.+)/);
+    if (importMatch) {
+      const modules = importMatch[1].split(",").map((m) => m.trim().split(/\s+as\s+/)[0].trim());
+      for (const mod of modules) {
+        if (!mod || !mod.match(/^[\w.]+$/)) continue;
+        if (isPythonStdlib(mod)) continue;
+        specs.push({ raw: mod, isRelative: false });
+      }
+    }
+  }
+  return specs;
+}
+var GO_STDLIB_PREFIXES = /* @__PURE__ */ new Set([
+  "archive",
+  "bufio",
+  "bytes",
+  "cmp",
+  "compress",
+  "container",
+  "context",
+  "crypto",
+  "database",
+  "debug",
+  "embed",
+  "encoding",
+  "errors",
+  "expvar",
+  "flag",
+  "fmt",
+  "go",
+  "hash",
+  "html",
+  "image",
+  "index",
+  "internal",
+  "io",
+  "iter",
+  "log",
+  "maps",
+  "math",
+  "mime",
+  "net",
+  "os",
+  "path",
+  "plugin",
+  "reflect",
+  "regexp",
+  "runtime",
+  "slices",
+  "sort",
+  "strconv",
+  "strings",
+  "structs",
+  "sync",
+  "syscall",
+  "testing",
+  "text",
+  "time",
+  "unicode",
+  "unsafe"
+]);
+function isGoStdlib(importPath) {
+  const firstSegment = importPath.split("/")[0];
+  if (firstSegment.includes(".")) return false;
+  return GO_STDLIB_PREFIXES.has(firstSegment);
+}
+function parseGoImports(content) {
+  const specs = [];
+  const singlePattern = /^\s*import\s+(?:[\w_.]+\s+)?"([^"]+)"/gm;
+  let match;
+  while ((match = singlePattern.exec(content)) !== null) {
+    const pkg = match[1];
+    if (isGoStdlib(pkg)) continue;
+    specs.push({ raw: pkg, isRelative: false });
+  }
+  const blockPattern = /import\s*\(([\s\S]*?)\)/g;
+  while ((match = blockPattern.exec(content)) !== null) {
+    const block = match[1];
+    const linePattern = /(?:[\w_.]+\s+)?"([^"]+)"/g;
+    let lineMatch;
+    while ((lineMatch = linePattern.exec(block)) !== null) {
+      const pkg = lineMatch[1];
+      if (isGoStdlib(pkg)) continue;
+      specs.push({ raw: pkg, isRelative: false });
+    }
+  }
+  return specs;
+}
+var JAVA_STDLIB_PREFIXES = /* @__PURE__ */ new Set([
+  "java",
+  "javax",
+  "jdk",
+  "sun",
+  "com.sun",
+  "org.w3c",
+  "org.xml",
+  "org.ietf"
+]);
+function isJavaStdlib(importPath) {
+  for (const prefix of JAVA_STDLIB_PREFIXES) {
+    if (importPath === prefix || importPath.startsWith(prefix + ".")) return true;
+  }
+  return false;
+}
+function parseJavaImports(content) {
+  const specs = [];
+  const pattern = /^\s*import\s+(?:static\s+)?([\w.*]+)\s*;/gm;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const raw = match[1];
+    if (isJavaStdlib(raw)) continue;
+    specs.push({ raw, isRelative: false });
+  }
+  return specs;
+}
+function parseRustImports(content) {
+  const specs = [];
+  const usePattern = /^\s*(?:pub\s+)?use\s+((?:crate|super|self)(?:::\w+)*)/gm;
+  let match;
+  while ((match = usePattern.exec(content)) !== null) {
+    const raw = match[1];
+    const isRelative = raw.startsWith("super") || raw.startsWith("self");
+    specs.push({ raw, isRelative });
+  }
+  const modPattern = /^\s*(?:pub\s+)?mod\s+(\w+)\s*;/gm;
+  while ((match = modPattern.exec(content)) !== null) {
+    specs.push({ raw: `mod::${match[1]}`, isRelative: true });
+  }
+  return specs;
+}
+function resolveImportSpec(spec, fromRelativePath, projectPath, allPaths, lang) {
+  switch (lang) {
+    case "python":
+      return resolvePythonImport(spec, fromRelativePath, allPaths);
+    case "go":
+      return resolveGoImport(spec, fromRelativePath, projectPath, allPaths);
+    case "java":
+      return resolveJavaImport(spec, allPaths);
+    case "rust":
+      return resolveRustImport(spec, fromRelativePath, allPaths);
+    default:
+      return null;
+  }
+}
+function resolvePythonImport(spec, fromRelativePath, allPaths) {
+  if (spec.isRelative) {
+    const dots = spec.raw.match(/^\.+/)?.[0].length ?? 0;
+    const modulePart = spec.raw.slice(dots);
+    let baseDir = dirname(fromRelativePath);
+    for (let i = 1; i < dots; i++) {
+      baseDir = dirname(baseDir);
+    }
+    if (!modulePart) {
+      return tryResolvePython(baseDir, "", allPaths);
+    }
+    const modulePath2 = modulePart.replace(/\./g, "/");
+    return tryResolvePython(baseDir, modulePath2, allPaths);
+  }
+  const modulePath = spec.raw.replace(/\./g, "/");
+  return tryResolvePython("", modulePath, allPaths);
+}
+function tryResolvePython(baseDir, modulePath, allPaths) {
+  const candidates = [];
+  if (!modulePath) {
+    candidates.push(join(baseDir, "__init__.py"));
+  } else {
+    candidates.push(
+      join(baseDir, `${modulePath}.py`),
+      join(baseDir, modulePath, "__init__.py")
+    );
+    if (baseDir) {
+      candidates.push(
+        `${modulePath}.py`,
+        join(modulePath, "__init__.py")
+      );
+    }
+    for (const prefix of ["src", "lib", "app"]) {
+      candidates.push(
+        join(prefix, `${modulePath}.py`),
+        join(prefix, modulePath, "__init__.py")
+      );
+    }
+  }
+  const normalized = candidates.map((p) => p.replace(/^\.[\\/]/, ""));
+  for (const candidate of normalized) {
+    if (allPaths.has(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveGoImport(spec, fromRelativePath, projectPath, allPaths) {
+  const dirFiles = /* @__PURE__ */ new Map();
+  for (const p of allPaths) {
+    if (!p.endsWith(".go")) continue;
+    if (p.endsWith("_test.go")) continue;
+    const dir = dirname(p);
+    const existing = dirFiles.get(dir);
+    if (existing) existing.push(p);
+    else dirFiles.set(dir, [p]);
+  }
+  const importParts = spec.raw.split("/");
+  const pkgName = importParts[importParts.length - 1];
+  let goModModule = "";
+  for (const p of allPaths) {
+    if (p === "go.mod" || p.endsWith("/go.mod")) {
+      try {
+        const goModContent = safeReadFile(join(projectPath, p));
+        if (goModContent) {
+          const modMatch = goModContent.match(/^module\s+(\S+)/m);
+          if (modMatch) goModModule = modMatch[1];
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  if (goModModule && spec.raw.startsWith(goModModule + "/")) {
+    const localPath = spec.raw.slice(goModModule.length + 1);
+    const files = dirFiles.get(localPath);
+    if (files && files.length > 0) return files.sort()[0];
+    for (const prefix of ["", "cmd/", "pkg/", "internal/"]) {
+      const tryPath = prefix + localPath;
+      const tryFiles = dirFiles.get(tryPath);
+      if (tryFiles && tryFiles.length > 0) return tryFiles.sort()[0];
+    }
+  }
+  for (const [dir, files] of dirFiles) {
+    const dirName = dir.split("/").pop();
+    if (dirName === pkgName) return files.sort()[0];
+  }
+  for (let depth = 2; depth <= Math.min(importParts.length, 4); depth++) {
+    const suffix = importParts.slice(-depth).join("/");
+    for (const [dir, files] of dirFiles) {
+      if (dir === suffix || dir.endsWith("/" + suffix)) {
+        return files.sort()[0];
+      }
+    }
+  }
+  return null;
+}
+function resolveJavaImport(spec, allPaths) {
+  const parts = spec.raw.split(".");
+  if (parts[parts.length - 1] === "*") {
+    const packagePath2 = parts.slice(0, -1).join("/");
+    for (const prefix of ["src/main/java/", "src/", ""]) {
+      for (const path of allPaths) {
+        if (path.startsWith(prefix + packagePath2 + "/") && path.endsWith(".java")) {
+          return path;
+        }
+      }
+    }
+    for (const path of allPaths) {
+      if (path.includes(packagePath2 + "/") && path.endsWith(".java")) {
+        return path;
+      }
+    }
+    return null;
+  }
+  let className = parts[parts.length - 1];
+  let packageParts = parts.slice(0, -1);
+  if (className[0] && className[0] === className[0].toLowerCase() && packageParts.length > 0) {
+    className = packageParts[packageParts.length - 1];
+    packageParts = packageParts.slice(0, -1);
+  }
+  if (packageParts.length > 0) {
+    const maybeOuter = packageParts[packageParts.length - 1];
+    if (maybeOuter[0] && maybeOuter[0] === maybeOuter[0].toUpperCase() && className[0] && className[0] === className[0].toUpperCase()) {
+      className = maybeOuter;
+      packageParts = packageParts.slice(0, -1);
+    }
+  }
+  const packagePath = packageParts.join("/");
+  const javaFile = `${className}.java`;
+  const fullPath = packagePath ? `${packagePath}/${javaFile}` : javaFile;
+  const prefixes = ["src/main/java/", "src/main/kotlin/", "src/", "app/src/main/java/", ""];
+  for (const prefix of prefixes) {
+    const candidate = prefix + fullPath;
+    if (allPaths.has(candidate)) return candidate;
+  }
+  for (const path of allPaths) {
+    if (path.endsWith(fullPath)) return path;
+  }
+  if (packageParts.length >= 2) {
+    const lastTwoPkg = packageParts.slice(-2).join("/");
+    for (const path of allPaths) {
+      if (path.endsWith(javaFile) && path.includes(lastTwoPkg)) return path;
+    }
+  }
+  return null;
+}
+function resolveRustImport(spec, fromRelativePath, allPaths) {
+  if (spec.raw.startsWith("mod::")) {
+    const modName = spec.raw.slice(5);
+    const dir = dirname(fromRelativePath);
+    const candidates = [
+      join(dir, `${modName}.rs`),
+      join(dir, modName, "mod.rs")
+    ];
+    for (const c of candidates) {
+      if (allPaths.has(c)) return c;
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("crate::")) {
+    const parts = spec.raw.replace("crate::", "").split("::");
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        `src/${modulePath}.rs`,
+        `src/${modulePath}/mod.rs`,
+        `${modulePath}.rs`,
+        `${modulePath}/mod.rs`
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("super::")) {
+    const parts = spec.raw.replace("super::", "").split("::");
+    const parentDir = dirname(dirname(fromRelativePath));
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        join(parentDir, `${modulePath}.rs`),
+        join(parentDir, modulePath, "mod.rs")
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  if (spec.raw.startsWith("self::")) {
+    const parts = spec.raw.replace("self::", "").split("::");
+    const dir = dirname(fromRelativePath);
+    for (let i = parts.length; i >= 1; i--) {
+      const modulePath = parts.slice(0, i).join("/");
+      const candidates = [
+        join(dir, `${modulePath}.rs`),
+        join(dir, modulePath, "mod.rs")
+      ];
+      for (const c of candidates) {
+        if (allPaths.has(c)) return c;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function safeReadFile(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// src/engine/graph.ts
 var TS_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
 function createProject(projectPath, filePaths) {
-  const tsConfigPath = join(projectPath, "tsconfig.json");
-  const hasTsConfig = existsSync(tsConfigPath);
+  const tsConfigPath = join2(projectPath, "tsconfig.json");
+  const hasTsConfig = existsSync2(tsConfigPath);
   const project = new Project({
     tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
     skipAddingFilesFromTsConfig: true,
@@ -131,9 +1370,11 @@ function createProject(projectPath, filePaths) {
   return project;
 }
 function buildProjectGraph(projectPath, files) {
-  const absPath = resolve(projectPath);
+  const absPath = resolve2(projectPath);
   const tsFiles = files.filter((f) => TS_EXTENSIONS.has(f.extension)).map((f) => f.path);
-  if (tsFiles.length === 0) {
+  const polyglotFiles = files.filter((f) => !TS_EXTENSIONS.has(f.extension)).map((f) => ({ relativePath: f.relativePath, absolutePath: f.path }));
+  const polyglotEdges = parseAllPolyglotImports(polyglotFiles, absPath);
+  if (tsFiles.length === 0 && polyglotEdges.length === 0) {
     return emptyGraph(files);
   }
   let project;
@@ -145,7 +1386,7 @@ function buildProjectGraph(projectPath, files) {
   const edges = [];
   const nodeSet = /* @__PURE__ */ new Set();
   for (const sourceFile of project.getSourceFiles()) {
-    const fromRel = relative(absPath, sourceFile.getFilePath());
+    const fromRel = relative2(absPath, sourceFile.getFilePath());
     if (fromRel.startsWith("..") || fromRel.includes("node_modules")) continue;
     nodeSet.add(fromRel);
     for (const imp of sourceFile.getImportDeclarations()) {
@@ -167,6 +1408,11 @@ function buildProjectGraph(projectPath, files) {
       }
     }
   }
+  for (const edge of polyglotEdges) {
+    nodeSet.add(edge.from);
+    nodeSet.add(edge.to);
+    edges.push(edge);
+  }
   const nodes = Array.from(nodeSet);
   const importedByCount = /* @__PURE__ */ new Map();
   const importCount = /* @__PURE__ */ new Map();
@@ -199,6 +1445,7 @@ function buildProjectGraph(projectPath, files) {
   const orphans = Array.from(allFileNodes).filter((n) => !connectedNodes.has(n));
   const clusters = detectClusters(nodes, edges, files);
   enrichComplexity(project, absPath, files);
+  enrichPolyglotComplexity(files);
   return { nodes, edges, hubs, leaves, orphans, clusters };
 }
 var UnionFind = class {
@@ -291,7 +1538,7 @@ function commonPrefix(paths) {
 function enrichComplexity(project, absPath, files) {
   const fileMap = new Map(files.map((f) => [f.relativePath, f]));
   for (const sourceFile of project.getSourceFiles()) {
-    const relPath = relative(absPath, sourceFile.getFilePath());
+    const relPath = relative2(absPath, sourceFile.getFilePath());
     if (relPath.startsWith("..") || relPath.includes("node_modules")) continue;
     const file = fileMap.get(relPath);
     if (!file) continue;
@@ -342,22 +1589,34 @@ function calculateCyclomaticComplexity(node) {
   });
   return complexity;
 }
+function enrichPolyglotComplexity(files) {
+  for (const file of files) {
+    if (TS_EXTENSIONS.has(file.extension)) continue;
+    const lang = detectLanguage(file.relativePath);
+    if (!lang) continue;
+    try {
+      const content = readFileSync2(file.path, "utf-8");
+      file.complexity = Math.max(1, estimateComplexity(content, lang));
+    } catch {
+    }
+  }
+}
 function resolveImport(sourceFile, moduleSpecifier, projectRoot) {
   if (!moduleSpecifier.startsWith(".")) return null;
-  const sourceDir = dirname(sourceFile.getFilePath());
-  const basePath = resolve(sourceDir, moduleSpecifier);
+  const sourceDir = dirname2(sourceFile.getFilePath());
+  const basePath = resolve2(sourceDir, moduleSpecifier);
   const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
   for (const ext of extensions) {
     const candidate = basePath.endsWith(ext) ? basePath : basePath + ext;
-    if (existsSync(candidate)) {
-      const rel = relative(projectRoot, candidate);
+    if (existsSync2(candidate)) {
+      const rel = relative2(projectRoot, candidate);
       if (!rel.startsWith("..")) return rel;
     }
   }
   if (moduleSpecifier.endsWith(".js")) {
     const tsPath = basePath.replace(/\.js$/, ".ts");
-    if (existsSync(tsPath)) {
-      const rel = relative(projectRoot, tsPath);
+    if (existsSync2(tsPath)) {
+      const rel = relative2(projectRoot, tsPath);
       if (!rel.startsWith("..")) return rel;
     }
   }
@@ -525,7 +1784,7 @@ async function walkProject(rootPath, options) {
     }
     const promises = [];
     for (const entry of entries) {
-      const fullPath = join2(dir, entry.name);
+      const fullPath = join3(dir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirSet.has(entry.name) && !entry.name.startsWith(".")) {
           promises.push(walk(fullPath, depth + 1));
@@ -546,7 +1805,7 @@ async function walkProject(rootPath, options) {
               }
               results.push({
                 path: fullPath,
-                relativePath: relative2(rootPath, fullPath),
+                relativePath: relative3(rootPath, fullPath),
                 extension: ext,
                 size: fileStat.size,
                 lastModified: fileStat.mtime,
@@ -595,7 +1854,7 @@ function detectStack(files) {
   return stack;
 }
 async function analyzeProject(projectPath, config) {
-  const absPath = resolve2(projectPath);
+  const absPath = resolve3(projectPath);
   const projectName = basename2(absPath);
   const mergedConfig = mergeConfig(DEFAULT_CONFIG, config);
   const allExtensions = [
@@ -787,8 +2046,8 @@ import { createHash as createHash3 } from "crypto";
 
 // src/govern/secrets.ts
 import { readFile as readFile3 } from "fs/promises";
-import { readFileSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
-import { resolve as resolve3, relative as relative3, join as join3, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { resolve as resolve4, relative as relative4, join as join4, dirname as dirname3 } from "path";
 import { createHash as createHash2 } from "crypto";
 var BUILTIN_PATTERNS = [
   // API Keys
@@ -916,7 +2175,7 @@ function scanContentForSecrets(content, filePath, customPatterns = [], extraPiiS
 async function scanFileForSecrets(filePath, projectPath, customPatterns = []) {
   try {
     const content = await readFile3(filePath, "utf-8");
-    const relPath = relative3(resolve3(projectPath), resolve3(filePath));
+    const relPath = relative4(resolve4(projectPath), resolve4(filePath));
     return scanContentForSecrets(content, relPath, customPatterns);
   } catch {
     return [];
@@ -1012,13 +2271,13 @@ function fingerprintFinding(f) {
   return createHash2("sha256").update(`${f.file}:${f.type}:${f.match}`).digest("hex").slice(0, 32);
 }
 function getAllowlistPath(projectPath) {
-  return join3(projectPath, ".cto", "audit", "allowlist.json");
+  return join4(projectPath, ".cto", "audit", "allowlist.json");
 }
 function loadAllowlist(projectPath) {
   const filePath = getAllowlistPath(projectPath);
-  if (!existsSync2(filePath)) return [];
+  if (!existsSync3(filePath)) return [];
   try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
   } catch {
     return [];
   }
@@ -1039,20 +2298,20 @@ function filterByAllowlist(findings, projectPath) {
   return { filtered, allowed };
 }
 function getHashCachePath(projectPath) {
-  return join3(projectPath, ".cto", "audit", ".hashcache.json");
+  return join4(projectPath, ".cto", "audit", ".hashcache.json");
 }
 function loadHashCache(projectPath) {
   const filePath = getHashCachePath(projectPath);
-  if (!existsSync2(filePath)) return {};
+  if (!existsSync3(filePath)) return {};
   try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveHashCache(projectPath, cache) {
   const filePath = getHashCachePath(projectPath);
-  mkdirSync(dirname2(filePath), { recursive: true });
+  mkdirSync(dirname3(filePath), { recursive: true });
   writeFileSync(filePath, JSON.stringify(cache));
 }
 function hashContent(content) {
@@ -1065,8 +2324,8 @@ function getChangedFiles(projectPath, filePaths) {
   const unchanged = [];
   for (const fp of filePaths) {
     try {
-      const content = readFileSync(fp, "utf-8");
-      const relPath = relative3(resolve3(projectPath), resolve3(fp));
+      const content = readFileSync3(fp, "utf-8");
+      const relPath = relative4(resolve4(projectPath), resolve4(fp));
       const hash = hashContent(content);
       newCache[relPath] = hash;
       if (oldCache[relPath] === hash) {
@@ -1089,13 +2348,13 @@ var DEFAULT_AUDIT_CONFIG = {
   incrementalScan: true
 };
 function getAuditConfigPath(projectPath) {
-  return join3(projectPath, ".cto", "audit", "config.json");
+  return join4(projectPath, ".cto", "audit", "config.json");
 }
 function loadAuditConfig(projectPath) {
   const filePath = getAuditConfigPath(projectPath);
-  if (!existsSync2(filePath)) return { ...DEFAULT_AUDIT_CONFIG };
+  if (!existsSync3(filePath)) return { ...DEFAULT_AUDIT_CONFIG };
   try {
-    const loaded = JSON.parse(readFileSync(filePath, "utf-8"));
+    const loaded = JSON.parse(readFileSync3(filePath, "utf-8"));
     return { ...DEFAULT_AUDIT_CONFIG, ...loaded };
   } catch {
     return { ...DEFAULT_AUDIT_CONFIG };
@@ -1193,7 +2452,7 @@ async function auditProject(projectPath, filePaths, options = {}) {
   for (const fp of filesToScan) {
     try {
       const content = await readFile3(fp, "utf-8");
-      const relPath = relative3(resolve3(projectPath), resolve3(fp));
+      const relPath = relative4(resolve4(projectPath), resolve4(fp));
       const isTestFile = /\.(test|spec|mock)\.[jt]sx?$/.test(relPath) || relPath.includes("__tests__");
       const isDtsFile = relPath.endsWith(".d.ts");
       let findings = scanContentForSecrets(content, relPath, customPatterns, extraPiiDomains);
@@ -1800,19 +3059,8 @@ async function selectContext(input) {
   for (const s of input.semanticScores ?? []) semanticMap.set(s.filePath, s.score);
   const learnerMap = /* @__PURE__ */ new Map();
   for (const b of input.learnerBoosts ?? []) learnerMap.set(b.filePath, b.boost);
-  let targetPaths = identifyTargetFiles(task, analysis.files);
-  if (targetPaths.length === 0 && semanticMap.size > 0) {
-    const sorted = [...semanticMap.entries()].sort((a, b) => b[1] - a[1]);
-    const threshold = 0.5;
-    targetPaths = sorted.filter(([, score]) => score >= threshold).slice(0, 10).map(([path]) => path);
-    if (targetPaths.length > 0) {
-      decisions.push({
-        file: targetPaths.join(", "),
-        action: "include-full",
-        reason: `Top ${targetPaths.length} file(s) identified via semantic matching (score \u2265 ${threshold})`
-      });
-    }
-  } else if (targetPaths.length > 0) {
+  const targetPaths = identifyTargetFiles(task, analysis.files);
+  if (targetPaths.length > 0) {
     decisions.push({
       file: targetPaths.join(", "),
       action: "include-full",
@@ -1844,7 +3092,7 @@ async function selectContext(input) {
   }
   const { mustInclude, mustExclude } = applyPolicies(analysis.files, policies);
   const candidateSet = /* @__PURE__ */ new Set([...expandedPaths, ...mustInclude]);
-  if (targetPaths.length === 0) {
+  if (semanticMap.size > 0 || targetPaths.length === 0) {
     for (const f of analysis.files) {
       candidateSet.add(f.relativePath);
     }
@@ -1883,22 +3131,32 @@ async function selectContext(input) {
     const riskNorm = file.riskScore / maxRisk;
     const semantic = semanticMap.get(file.relativePath) ?? 0;
     const learner = ((learnerMap.get(file.relativePath) ?? 0) + 1) / 2;
-    return riskNorm * 0.4 + semantic * 0.4 + learner * 0.2;
+    return semantic * 0.55 + riskNorm * 0.25 + learner * 0.2;
   }
+  const targetSet = new Set(targetPaths);
   const candidates = Array.from(candidateSet).map((p) => allFileMap.get(p)).filter((f) => f !== void 0).sort((a, b) => {
-    const aIsTarget = targetPaths.includes(a.relativePath) ? 0 : 1;
-    const bIsTarget = targetPaths.includes(b.relativePath) ? 0 : 1;
-    if (aIsTarget !== bIsTarget) return aIsTarget - bIsTarget;
-    const aIsMust = mustInclude.has(a.relativePath) ? 0 : 1;
-    const bIsMust = mustInclude.has(b.relativePath) ? 0 : 1;
-    if (aIsMust !== bIsMust) return aIsMust - bIsMust;
-    return compositeScore(b) - compositeScore(a);
+    const aBonus = (targetSet.has(a.relativePath) ? 0.3 : 0) + (mustInclude.has(a.relativePath) ? 0.15 : 0);
+    const bBonus = (targetSet.has(b.relativePath) ? 0.3 : 0) + (mustInclude.has(b.relativePath) ? 0.15 : 0);
+    return compositeScore(b) + bBonus - (compositeScore(a) + aBonus);
   });
   const selectedFiles = [];
   let usedTokens = 0;
+  const hasSemanticSignal = semanticMap.size > 0;
   for (const file of candidates) {
-    const isTarget = targetPaths.includes(file.relativePath);
+    const isTarget = targetSet.has(file.relativePath);
     const isMustInclude = mustInclude.has(file.relativePath);
+    if (hasSemanticSignal && !isTarget && !isMustInclude) {
+      const semScore = semanticMap.get(file.relativePath) ?? 0;
+      const lrnBoost = learnerMap.get(file.relativePath) ?? 0;
+      if (semScore === 0 && lrnBoost === 0) {
+        decisions.push({
+          file: file.relativePath,
+          action: "exclude",
+          reason: "Skipped: no semantic relevance to task"
+        });
+        continue;
+      }
+    }
     const defaultLevel = isTarget ? "full" : getPruneLevelForRisk(file.riskScore);
     const levels = getCascadeLevels2(defaultLevel);
     let included = false;
@@ -2022,281 +3280,394 @@ function buildReason(file, level, isTarget, isMustInclude) {
   return `Low relevance (risk ${file.riskScore}) \u2014 ${levelStr}`;
 }
 
-// src/engine/tfidf.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  // Language keywords
-  "import",
-  "export",
-  "from",
-  "const",
-  "let",
-  "var",
-  "function",
-  "class",
-  "interface",
-  "type",
-  "return",
-  "async",
-  "await",
-  "new",
-  "this",
-  "that",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "void",
-  "string",
-  "number",
-  "boolean",
-  "any",
-  "unknown",
-  "never",
-  "object",
-  "array",
-  "promise",
-  "if",
-  "else",
-  "for",
-  "while",
-  "do",
-  "switch",
-  "case",
-  "break",
-  "continue",
-  "try",
-  "catch",
-  "throw",
-  "finally",
-  "default",
-  "extends",
-  "implements",
-  "static",
-  "private",
-  "public",
-  "protected",
-  "readonly",
-  "abstract",
-  "override",
-  "super",
-  "typeof",
-  "instanceof",
-  "in",
-  "of",
-  "as",
-  "is",
-  "keyof",
-  "enum",
-  "namespace",
-  "module",
-  "declare",
-  // Python
-  "def",
-  "self",
-  "cls",
-  "none",
-  "pass",
-  "yield",
-  "lambda",
-  "with",
-  "elif",
-  "except",
-  "raise",
-  "assert",
-  "global",
-  "nonlocal",
-  // Natural language stop words only — NOT domain terms that carry signal
-  "the",
-  "and",
-  "for",
-  "with",
-  "not",
-  "but",
-  "are",
-  "was",
-  "were",
-  "has",
-  "have",
-  "had",
-  "will",
-  "would",
-  "could",
-  "should",
-  "may",
-  "can",
-  "its",
-  "also",
-  "than",
-  "then",
-  "into",
-  "only",
-  "very",
-  "just",
-  "about",
-  "being",
-  "been",
-  "does",
-  "did",
-  "doing",
-  "todo",
-  "fixme",
-  "hack",
-  "note",
-  "xxx"
-]);
-function buildIndex(files) {
+// src/engine/context-pipeline.ts
+import { readFileSync as readFileSync6 } from "fs";
+init_tfidf();
+
+// src/engine/index-cache.ts
+init_tfidf();
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, statSync } from "fs";
+import { join as join5 } from "path";
+var CACHE_VERSION = 2;
+var CACHE_DIR = ".cto";
+var CACHE_FILE = "index-cache.json";
+function buildIndexCached(projectPath, files) {
+  const startTime = Date.now();
+  const cachePath = join5(projectPath, CACHE_DIR, CACHE_FILE);
+  const existing = loadCache(cachePath);
+  const cacheHit = existing !== null;
+  const cachedFiles = existing?.files ?? {};
+  const newCachedFiles = {};
+  let updatedFiles = 0;
+  let removedFiles = 0;
+  let cachedCount = 0;
+  const currentPaths = new Set(files.map((f) => f.relativePath));
+  if (existing) {
+    for (const path of Object.keys(cachedFiles)) {
+      if (!currentPaths.has(path)) {
+        removedFiles++;
+      }
+    }
+  }
+  for (const file of files) {
+    const cached = cachedFiles[file.relativePath];
+    let currentMtime = 0;
+    try {
+      const st = statSync(file.absolutePath);
+      currentMtime = st.mtimeMs;
+    } catch {
+      continue;
+    }
+    if (cached && cached.mtime === currentMtime) {
+      newCachedFiles[file.relativePath] = cached;
+      cachedCount++;
+    } else {
+      let content = file.content;
+      if (content === void 0) {
+        try {
+          content = readFileSync4(file.absolutePath, "utf-8");
+        } catch {
+          continue;
+        }
+      }
+      const terms = tokenize(content);
+      const termCounts = {};
+      for (const term of terms) {
+        termCounts[term] = (termCounts[term] ?? 0) + 1;
+      }
+      newCachedFiles[file.relativePath] = {
+        mtime: currentMtime,
+        terms: termCounts,
+        length: terms.length
+      };
+      updatedFiles++;
+    }
+  }
+  const index = rebuildIndex(newCachedFiles);
+  saveCache(cachePath, newCachedFiles);
+  const stats = {
+    totalFiles: Object.keys(newCachedFiles).length,
+    updatedFiles,
+    removedFiles,
+    cachedFiles: cachedCount,
+    cacheHit,
+    buildTimeMs: Date.now() - startTime
+  };
+  return { index, stats };
+}
+function invalidateCache(projectPath) {
+  const cachePath = join5(projectPath, CACHE_DIR, CACHE_FILE);
+  try {
+    if (existsSync4(cachePath)) {
+      writeFileSync2(cachePath, "{}");
+    }
+  } catch {
+  }
+}
+function getCacheInfo(projectPath) {
+  const cachePath = join5(projectPath, CACHE_DIR, CACHE_FILE);
+  const data = loadCache(cachePath);
+  if (!data) return { exists: false, fileCount: 0, builtAt: null };
+  return {
+    exists: true,
+    fileCount: Object.keys(data.files).length,
+    builtAt: data.builtAt
+  };
+}
+function loadCache(cachePath) {
+  try {
+    if (!existsSync4(cachePath)) return null;
+    const raw = readFileSync4(cachePath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version !== CACHE_VERSION) return null;
+    if (!data.files || typeof data.files !== "object") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCache(cachePath, files) {
+  try {
+    const dir = cachePath.substring(0, cachePath.lastIndexOf("/"));
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const data = {
+      version: CACHE_VERSION,
+      builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files
+    };
+    writeFileSync2(cachePath, JSON.stringify(data));
+  } catch {
+  }
+}
+function rebuildIndex(cachedFiles) {
   const documents = /* @__PURE__ */ new Map();
   const docFreq = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const terms = tokenize(file.content);
-    const termCounts = /* @__PURE__ */ new Map();
-    for (const term of terms) {
-      termCounts.set(term, (termCounts.get(term) ?? 0) + 1);
+  let totalLength = 0;
+  for (const [path, cached] of Object.entries(cachedFiles)) {
+    const termMap = /* @__PURE__ */ new Map();
+    for (const [term, count] of Object.entries(cached.terms)) {
+      termMap.set(term, count);
     }
-    documents.set(file.relativePath, { terms: termCounts, length: terms.length });
-    for (const term of termCounts.keys()) {
+    documents.set(path, { terms: termMap, length: cached.length });
+    totalLength += cached.length;
+    for (const term of termMap.keys()) {
       docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
     }
   }
-  const totalDocs = files.length;
+  const totalDocs = documents.size;
+  const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
   const idf = /* @__PURE__ */ new Map();
   for (const [term, df] of docFreq) {
     idf.set(term, Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1));
   }
-  let totalLength = 0;
-  for (const doc of documents.values()) totalLength += doc.length;
-  const avgDocLength = totalDocs > 0 ? totalLength / totalDocs : 1;
   return { documents, idf, avgDocLength, totalDocs };
 }
-function query(index, taskDescription, maxResults = 50) {
-  const queryTerms = tokenize(taskDescription);
-  if (queryTerms.length === 0) return [];
-  const querySet = /* @__PURE__ */ new Map();
-  for (const term of queryTerms) {
-    querySet.set(term, (querySet.get(term) ?? 0) + 1);
+
+// src/engine/reranker.ts
+init_tfidf();
+var WEIGHTS = {
+  termCoverage: 0.35,
+  // What fraction of query terms does the file match?
+  termSpecificity: 0.25,
+  // Are matched terms rare or common?
+  bigramProximity: 0.15,
+  // Do query terms appear near each other?
+  dependencySignal: 0.1,
+  // Is this file connected to a top match?
+  pathRelevance: 0.15
+  // Does the file path match query terms?
+};
+var ABSOLUTE_FLOOR = 0.18;
+var ELBOW_DROP_RATIO = 0.35;
+var MIN_TERM_COVERAGE = 0.3;
+function rerank(input) {
+  const startTime = Date.now();
+  const { task, candidates, index, fileContents, dependencies, allFilePaths } = input;
+  const emptyTelemetry = {
+    candidatesIn: candidates.length,
+    candidatesOut: 0,
+    candidatesFiltered: 0,
+    durationMs: 0,
+    weights: { ...WEIGHTS },
+    gateConfig: { absoluteFloor: ABSOLUTE_FLOOR, elbowDropRatio: ELBOW_DROP_RATIO, minTermCoverage: MIN_TERM_COVERAGE },
+    signalStats: {
+      termCoverage: { min: 0, max: 0, mean: 0, median: 0 },
+      termSpecificity: { min: 0, max: 0, mean: 0, median: 0 },
+      bigramProximity: { min: 0, max: 0, mean: 0, median: 0 },
+      dependencySignal: { min: 0, max: 0, mean: 0, median: 0 },
+      pathRelevance: { min: 0, max: 0, mean: 0, median: 0 }
+    },
+    filterReasons: {},
+    scoreDistribution: [0, 0, 0, 0, 0],
+    queryTermCount: 0,
+    relevanceConeSize: 0
+  };
+  if (candidates.length === 0) {
+    return { files: [], filtered: [], qualityThreshold: 0, telemetry: { ...emptyTelemetry, durationMs: Date.now() - startTime } };
   }
-  const results = [];
-  const k1 = 1.5;
-  const b = 0.75;
-  for (const [filePath, doc] of index.documents) {
-    let score = 0;
-    const matchedTerms = [];
-    for (const [qTerm, qCount] of querySet) {
-      const tf = doc.terms.get(qTerm) ?? 0;
-      if (tf === 0) continue;
-      const termIdf = index.idf.get(qTerm) ?? 0;
-      if (termIdf <= 0) continue;
-      const tfNorm = tf * (k1 + 1) / (tf + k1 * (1 - b + b * doc.length / index.avgDocLength));
-      score += termIdf * tfNorm * qCount;
-      matchedTerms.push(qTerm);
+  const queryTerms = tokenize(task);
+  const uniqueQueryTerms = [...new Set(queryTerms)];
+  if (uniqueQueryTerms.length === 0) {
+    return { files: [], filtered: [], qualityThreshold: 0, telemetry: { ...emptyTelemetry, durationMs: Date.now() - startTime } };
+  }
+  const queryTermIdfs = /* @__PURE__ */ new Map();
+  for (const term of uniqueQueryTerms) {
+    queryTermIdfs.set(term, index.idf.get(term) ?? 0);
+  }
+  const maxIdf = Math.max(1, ...queryTermIdfs.values());
+  const pathTermsCache = /* @__PURE__ */ new Map();
+  for (const fp of allFilePaths) {
+    pathTermsCache.set(fp, new Set(tokenize(fp.replace(/[/\\.]/g, " "))));
+  }
+  const scored = [];
+  for (const candidate of candidates) {
+    const doc = index.documents.get(candidate.filePath);
+    if (!doc) continue;
+    const matchedQueryTerms = /* @__PURE__ */ new Set();
+    for (const term of uniqueQueryTerms) {
+      if ((doc.terms.get(term) ?? 0) > 0) {
+        matchedQueryTerms.add(term);
+      }
     }
-    if (score > 0) {
-      results.push({ filePath, score, matchedTerms });
+    const termCoverage = matchedQueryTerms.size / uniqueQueryTerms.length;
+    let specificitySum = 0;
+    let specificityMax = 0;
+    for (const term of matchedQueryTerms) {
+      const idf = queryTermIdfs.get(term) ?? 0;
+      specificitySum += idf;
+      specificityMax += maxIdf;
     }
+    const termSpecificity = specificityMax > 0 ? specificitySum / specificityMax : 0;
+    const content = fileContents.get(candidate.filePath) ?? "";
+    const bigramProximity = computeBigramProximity(content, uniqueQueryTerms);
+    const dependencySignal = 0;
+    const pathTerms = pathTermsCache.get(candidate.filePath) ?? /* @__PURE__ */ new Set();
+    const queryTermSet = new Set(uniqueQueryTerms);
+    let pathHits = 0;
+    for (const pt of pathTerms) {
+      if (queryTermSet.has(pt)) pathHits++;
+    }
+    const pathRelevance = Math.min(1, pathHits / Math.max(1, uniqueQueryTerms.length) * 2);
+    const score = termCoverage * WEIGHTS.termCoverage + termSpecificity * WEIGHTS.termSpecificity + bigramProximity * WEIGHTS.bigramProximity + dependencySignal * WEIGHTS.dependencySignal + pathRelevance * WEIGHTS.pathRelevance;
+    scored.push({
+      filePath: candidate.filePath,
+      score,
+      bm25Score: candidate.score,
+      signals: {
+        termCoverage,
+        termSpecificity,
+        bigramProximity,
+        dependencySignal,
+        pathRelevance
+      }
+    });
   }
-  const maxScore = results.reduce((max, r) => Math.max(max, r.score), 0);
-  if (maxScore > 0) {
-    for (const r of results) r.score = r.score / maxScore;
+  const topByScore = [...scored].sort((a, b) => b.score - a.score).slice(0, 5);
+  const relevanceCone = /* @__PURE__ */ new Set();
+  for (const top of topByScore) {
+    relevanceCone.add(top.filePath);
+    const deps = dependencies.get(top.filePath) ?? [];
+    for (const dep of deps) relevanceCone.add(dep);
+    for (const [from, tos] of dependencies) {
+      if (tos.includes(top.filePath)) relevanceCone.add(from);
+    }
   }
-  return results.sort((a, b2) => b2.score - a.score).slice(0, maxResults);
-}
-function similarity(index, pathA, pathB) {
-  const docA = index.documents.get(pathA);
-  const docB = index.documents.get(pathB);
-  if (!docA || !docB) return 0;
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  const allTerms = /* @__PURE__ */ new Set([...docA.terms.keys(), ...docB.terms.keys()]);
-  for (const term of allTerms) {
-    const idf = index.idf.get(term) ?? 0;
-    const wA = (docA.terms.get(term) ?? 0) * idf;
-    const wB = (docB.terms.get(term) ?? 0) * idf;
-    dotProduct += wA * wB;
-    normA += wA * wA;
-    normB += wB * wB;
+  for (const item of scored) {
+    const inCone = relevanceCone.has(item.filePath) ? 1 : 0;
+    item.signals.dependencySignal = inCone;
+    item.score = item.signals.termCoverage * WEIGHTS.termCoverage + item.signals.termSpecificity * WEIGHTS.termSpecificity + item.signals.bigramProximity * WEIGHTS.bigramProximity + item.signals.dependencySignal * WEIGHTS.dependencySignal + item.signals.pathRelevance * WEIGHTS.pathRelevance;
   }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom > 0 ? dotProduct / denom : 0;
+  scored.sort((a, b) => b.score - a.score);
+  const { passed, filtered, threshold } = applyQualityGate(scored);
+  const filterReasons = {};
+  for (const f of filtered) {
+    const reason = f.reason.replace(/\([^)]+\)/g, "").trim();
+    filterReasons[reason] = (filterReasons[reason] ?? 0) + 1;
+  }
+  const allScores = scored.map((s) => s.score).sort((a, b) => a - b);
+  const signalNames = ["termCoverage", "termSpecificity", "bigramProximity", "dependencySignal", "pathRelevance"];
+  const signalStats = {};
+  for (const name of signalNames) {
+    const vals = scored.map((s) => s.signals[name]).sort((a, b) => a - b);
+    signalStats[name] = {
+      min: vals[0] ?? 0,
+      max: vals[vals.length - 1] ?? 0,
+      mean: vals.length > 0 ? vals.reduce((a, b) => a + b, 0) / vals.length : 0,
+      median: vals.length > 0 ? vals[Math.floor(vals.length / 2)] : 0
+    };
+  }
+  const telemetry = {
+    candidatesIn: candidates.length,
+    candidatesOut: passed.length,
+    candidatesFiltered: filtered.length,
+    durationMs: Date.now() - startTime,
+    weights: { ...WEIGHTS },
+    gateConfig: { absoluteFloor: ABSOLUTE_FLOOR, elbowDropRatio: ELBOW_DROP_RATIO, minTermCoverage: MIN_TERM_COVERAGE },
+    signalStats,
+    filterReasons,
+    scoreDistribution: [
+      allScores[0] ?? 0,
+      allScores[Math.floor(allScores.length * 0.25)] ?? 0,
+      allScores[Math.floor(allScores.length * 0.5)] ?? 0,
+      allScores[Math.floor(allScores.length * 0.75)] ?? 0,
+      allScores[allScores.length - 1] ?? 0
+    ],
+    queryTermCount: uniqueQueryTerms.length,
+    relevanceConeSize: relevanceCone.size
+  };
+  return {
+    files: passed,
+    filtered,
+    qualityThreshold: threshold,
+    telemetry
+  };
 }
-function tokenize(text) {
-  const tokens = [];
-  const rawTokens = text.match(/[a-zA-Z][a-zA-Z0-9]*|[0-9]+/g) ?? [];
-  for (const raw of rawTokens) {
-    const parts = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
-    for (const part of parts) {
-      if (part.length < 2) continue;
-      const stemmed = stem(part);
-      if (stemmed.length < 2) continue;
-      if (STOP_WORDS.has(stemmed)) continue;
-      tokens.push(stemmed);
+function computeBigramProximity(content, queryTerms) {
+  if (queryTerms.length < 2 || !content) return 0;
+  const contentTokens = tokenize(content);
+  const termPositions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < contentTokens.length; i++) {
+    const token = contentTokens[i];
+    if (queryTerms.includes(token)) {
+      const positions = termPositions.get(token) ?? [];
+      positions.push(i);
+      termPositions.set(token, positions);
     }
   }
-  return tokens;
-}
-function stem(word) {
-  let w = word.toLowerCase();
-  if (w.endsWith("tion")) return w.slice(0, -4);
-  if (w.endsWith("sion")) return w.slice(0, -4);
-  if (w.endsWith("ment")) return w.slice(0, -4);
-  if (w.endsWith("ness")) return w.slice(0, -4);
-  if (w.endsWith("able")) return w.slice(0, -4);
-  if (w.endsWith("ible")) return w.slice(0, -4);
-  if (w.endsWith("ator")) return w.slice(0, -4);
-  if (w.endsWith("izer")) return w.slice(0, -4);
-  if (w.endsWith("ling")) return w.slice(0, -4);
-  if (w.endsWith("ing") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ies") && w.length > 4) return w.slice(0, -3) + "y";
-  if (w.endsWith("ous") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ful") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ess") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ity") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ive") && w.length > 5) return w.slice(0, -3);
-  if (w.endsWith("ed") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("er") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("ly") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("al") && w.length > 4) return w.slice(0, -2);
-  if (w.endsWith("s") && !w.endsWith("ss") && w.length > 3) return w.slice(0, -1);
-  return w;
+  let totalScore = 0;
+  let pairCount = 0;
+  for (let i = 0; i < queryTerms.length; i++) {
+    for (let j = i + 1; j < queryTerms.length; j++) {
+      const posA = termPositions.get(queryTerms[i]);
+      const posB = termPositions.get(queryTerms[j]);
+      if (!posA || !posB) continue;
+      let minDist = Infinity;
+      for (const a of posA) {
+        for (const b of posB) {
+          minDist = Math.min(minDist, Math.abs(a - b));
+        }
+      }
+      if (minDist < Infinity) {
+        totalScore += Math.max(0, 1 - minDist / 20);
+        pairCount++;
+      }
+    }
+  }
+  return pairCount > 0 ? totalScore / pairCount : 0;
 }
-function boostByPath(matches, allFiles, taskDescription) {
-  const queryTerms = new Set(tokenize(taskDescription));
-  const boosted = /* @__PURE__ */ new Map();
-  for (const m of matches) {
-    boosted.set(m.filePath, { ...m, matchedTerms: [...m.matchedTerms] });
+function applyQualityGate(scored) {
+  const passed = [];
+  const filtered = [];
+  if (scored.length === 0) {
+    return { passed, filtered, threshold: 0 };
   }
-  for (const filePath of allFiles) {
-    const pathTerms = tokenize(filePath.replace(/[/\\.]/g, " "));
-    const pathMatches = pathTerms.filter((t) => queryTerms.has(t));
-    if (pathMatches.length > 0) {
-      const existing = boosted.get(filePath);
-      const pathBoost = pathMatches.length * 0.3;
-      if (existing) {
-        existing.score = Math.min(1, existing.score + pathBoost);
-        for (const t of pathMatches) {
-          if (!existing.matchedTerms.includes(t)) existing.matchedTerms.push(t);
+  let elbowIndex = scored.length;
+  if (scored.length >= 3) {
+    let maxDrop = 0;
+    for (let i = 1; i < scored.length; i++) {
+      if (scored[i - 1].score > 0) {
+        const drop = (scored[i - 1].score - scored[i].score) / scored[i - 1].score;
+        if (drop > maxDrop && drop >= ELBOW_DROP_RATIO) {
+          maxDrop = drop;
+          elbowIndex = i;
         }
-      } else {
-        boosted.set(filePath, {
-          filePath,
-          score: Math.min(1, pathBoost),
-          matchedTerms: pathMatches
-        });
       }
     }
   }
-  return [...boosted.values()].sort((a, b) => b.score - a.score);
+  const threshold = Math.max(
+    ABSOLUTE_FLOOR,
+    elbowIndex < scored.length ? scored[elbowIndex].score : 0
+  );
+  for (let i = 0; i < scored.length; i++) {
+    const item = scored[i];
+    if (item.score < ABSOLUTE_FLOOR) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Below absolute floor (${item.score.toFixed(3)} < ${ABSOLUTE_FLOOR})` });
+      continue;
+    }
+    if (item.signals.termCoverage < MIN_TERM_COVERAGE) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Low term coverage (${(item.signals.termCoverage * 100).toFixed(0)}% < ${MIN_TERM_COVERAGE * 100}%)` });
+      continue;
+    }
+    if (i >= elbowIndex && item.score < scored[0].score * 0.5) {
+      filtered.push({ filePath: item.filePath, score: item.score, reason: `Below elbow cutoff (rank ${i + 1}, score ${item.score.toFixed(3)})` });
+      continue;
+    }
+    passed.push(item);
+  }
+  return { passed, filtered, threshold };
 }
 
 // src/engine/learner.ts
 import { readFile as readFile5, writeFile as writeFile2, mkdir } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var DECAY_FACTOR = 0.95;
 var MODEL_DIR = ".cto";
 var MODEL_FILE = "learner.json";
 var MIN_OBSERVATIONS = 3;
 async function loadLearner(projectPath) {
-  const modelPath = join4(projectPath, MODEL_DIR, MODEL_FILE);
+  const modelPath = join6(projectPath, MODEL_DIR, MODEL_FILE);
   try {
     const raw = await readFile5(modelPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2306,10 +3677,10 @@ async function loadLearner(projectPath) {
   return createEmptyModel();
 }
 async function saveLearner(projectPath, model) {
-  const dir = join4(projectPath, MODEL_DIR);
+  const dir = join6(projectPath, MODEL_DIR);
   await mkdir(dir, { recursive: true });
   model.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile2(join4(dir, MODEL_FILE), JSON.stringify(model, null, 2));
+  await writeFile2(join6(dir, MODEL_FILE), JSON.stringify(model, null, 2));
 }
 function recordSelection(model, taskType, selectedFiles, excludedFiles) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2426,6 +3797,289 @@ function extractPattern(filePath) {
   return `*${ext}`;
 }
 
+// src/interact/router.ts
+var TASK_KEYWORDS = {
+  debug: ["debug", "fix", "bug", "error", "issue", "broken", "crash", "failing", "wrong"],
+  review: ["review", "check", "assess", "evaluate", "audit", "inspect", "critique"],
+  refactor: ["refactor", "restructure", "reorganize", "clean up", "simplify", "extract", "move"],
+  test: ["test", "spec", "coverage", "unit test", "integration test", "e2e"],
+  docs: ["document", "docs", "readme", "jsdoc", "comment", "explain"],
+  feature: ["add", "implement", "create", "build", "new", "feature", "endpoint"],
+  architecture: ["architecture", "design", "system", "structure", "migrate", "pattern"],
+  "simple-edit": ["rename", "typo", "update", "change", "modify", "tweak", "adjust"]
+};
+function classifyTask(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  let bestType = "simple-edit";
+  let bestScore = 0;
+  for (const [type, keywords] of Object.entries(TASK_KEYWORDS)) {
+    let score = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+  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);
+  }
+  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 { selection, taskType, fileContentMap, semanticMap, learnerMap, multiRepo, indexCacheStats };
+}
+
+// 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 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;
+  const hash = createHash4("sha256").update(`${experiment.id}:${task}`).digest();
+  const value = hash.readUInt32BE(0) / 4294967295;
+  const group = value < experiment.trafficSplit ? "control" : "variant";
+  return {
+    group,
+    params: group === "control" ? experiment.control.params : experiment.variant.params,
+    experimentId: experiment.id
+  };
+}
+function recordOutcome(experiment, group, outcome) {
+  if (experiment.status !== "running") return experiment;
+  const metrics = group === "control" ? experiment.control.metrics : experiment.variant.metrics;
+  metrics.total++;
+  if (outcome.accepted) metrics.successes++;
+  metrics.acceptRate = metrics.total > 0 ? metrics.successes / metrics.total : 0;
+  if (outcome.timeToAcceptMs !== void 0) {
+    metrics.timeSum += outcome.timeToAcceptMs;
+    metrics.avgTimeToAccept = metrics.timeSum / metrics.total;
+  }
+  if (outcome.compilable !== void 0) {
+    if (outcome.compilable) metrics.compilableCount++;
+    metrics.compilableRate = metrics.total > 0 ? metrics.compilableCount / metrics.total : 0;
+  }
+  if (experiment.control.metrics.total >= experiment.minObservations && experiment.variant.metrics.total >= experiment.minObservations) {
+    const sig = testSignificance(experiment);
+    if (sig.pValue < experiment.significanceThreshold) {
+      return concludeExperiment(experiment, sig);
+    }
+  }
+  return experiment;
+}
+function testSignificance(experiment) {
+  const c = experiment.control.metrics;
+  const v = experiment.variant.metrics;
+  const n1 = c.total;
+  const n2 = v.total;
+  const p1 = c.acceptRate;
+  const p2 = v.acceptRate;
+  if (n1 === 0 || n2 === 0) {
+    return {
+      pValue: 1,
+      zScore: 0,
+      effectSize: 0,
+      confidenceInterval: [0, 0],
+      significant: false
+    };
+  }
+  const pooled = (c.successes + v.successes) / (n1 + n2);
+  const se = Math.sqrt(pooled * (1 - pooled) * (1 / n1 + 1 / n2));
+  const z = se > 0 ? (p2 - p1) / se : 0;
+  const pValue = 2 * (1 - normalCDF(Math.abs(z)));
+  const effectSize = p2 - p1;
+  const seDiff = Math.sqrt(p1 * (1 - p1) / n1 + p2 * (1 - p2) / n2);
+  const ci95 = [effectSize - 1.96 * seDiff, effectSize + 1.96 * seDiff];
+  return {
+    pValue,
+    zScore: z,
+    effectSize,
+    confidenceInterval: ci95,
+    significant: pValue < experiment.significanceThreshold
+  };
+}
+function normalCDF(x) {
+  if (x < -8) return 0;
+  if (x > 8) return 1;
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+  return 0.5 * (1 + sign * y);
+}
+function concludeExperiment(experiment, sig) {
+  const winner = sig.effectSize > 0 ? "variant" : sig.effectSize < 0 ? "control" : "no_difference";
+  const winnerName = winner === "control" ? experiment.control.name : winner === "variant" ? experiment.variant.name : "neither";
+  const conclusion = {
+    winner,
+    pValue: sig.pValue,
+    effectSize: sig.effectSize,
+    confidenceInterval: sig.confidenceInterval,
+    summary: `Experiment "${experiment.name}" concluded: ${winnerName} wins with ${(Math.abs(sig.effectSize) * 100).toFixed(1)}% improvement (p=${sig.pValue.toFixed(4)}, CI=[${sig.confidenceInterval[0].toFixed(3)}, ${sig.confidenceInterval[1].toFixed(3)}])`
+  };
+  return {
+    ...experiment,
+    status: "concluded",
+    concludedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    conclusion
+  };
+}
+function getActiveExperiment(experiments) {
+  return experiments.find((e) => e.status === "running") ?? null;
+}
+function getConcludedExperiments(experiments) {
+  return experiments.filter((e) => e.status === "concluded");
+}
+function renderExperimentSummary(experiment) {
+  const lines = [];
+  lines.push(`Experiment: ${experiment.name} (${experiment.status})`);
+  lines.push(`  ${experiment.description}`);
+  lines.push("");
+  lines.push(`  Control (${experiment.control.name}):`);
+  lines.push(`    Observations: ${experiment.control.metrics.total}`);
+  lines.push(`    Accept rate: ${(experiment.control.metrics.acceptRate * 100).toFixed(1)}%`);
+  lines.push(`  Variant (${experiment.variant.name}):`);
+  lines.push(`    Observations: ${experiment.variant.metrics.total}`);
+  lines.push(`    Accept rate: ${(experiment.variant.metrics.acceptRate * 100).toFixed(1)}%`);
+  if (experiment.status === "running") {
+    const sig = testSignificance(experiment);
+    lines.push("");
+    lines.push(`  Current p-value: ${sig.pValue.toFixed(4)}`);
+    lines.push(`  Effect size: ${(sig.effectSize * 100).toFixed(1)}%`);
+    lines.push(`  Significant: ${sig.significant ? "YES" : "not yet"}`);
+  }
+  if (experiment.conclusion) {
+    lines.push("");
+    lines.push(`  CONCLUSION: ${experiment.conclusion.summary}`);
+  }
+  return lines.join("\n");
+}
+
+// src/engine/index.ts
+init_multi_repo();
+
 // src/engine/logger.ts
 var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
 var currentLevel = process.env.CTO_LOG_LEVEL ?? "warn";
@@ -2505,34 +4159,55 @@ function wrapError(err, code, module, context) {
 export {
   CtoError,
   analyzeProject,
+  assignGroup,
   auditProject,
   bfsBidirectional,
   boostByPath,
   buildAdjacencyList,
   buildIndex,
+  buildIndexCached,
   buildProjectGraph,
   calculateCoverage,
   classifyFileKind,
   countTokensChars4,
   countTokensTiktoken,
+  createExperiment,
   createLogger,
   createProject,
+  detectLanguage,
   detectStack,
+  discoverSiblingRepos,
+  estimateComplexity,
   estimateFileTokens,
   estimateTokens,
   extractPattern,
   freeEncoder,
+  getActiveExperiment,
+  getCacheInfo,
+  getConcludedExperiments,
   getLearnerBoosts,
   getLearnerStats,
   getPruneLevelForRisk,
+  invalidateCache,
   isCtoError,
+  loadExperiments,
   loadLearner,
   optimizeBudget,
+  parseAllPolyglotImports,
+  parseImports,
+  parseSiblingPaths,
   pruneFile,
   pruneFiles,
   query,
+  querySiblingRepos,
+  recordOutcome,
   recordSelection,
+  renderExperimentSummary,
+  renderMultiRepoSummary,
+  rerank,
+  runContextPipeline,
   sanitizeContent,
+  saveExperiments,
   saveLearner,
   scanContentForSecrets,
   scanFileForSecrets,
@@ -2543,6 +4218,7 @@ export {
   setJsonLogging,
   setLogLevel,
   similarity,
+  testSignificance,
   tokenize,
   walkProject,
   wrapError