cto-ai-cli 1.3.0 → 3.0.0

package/dist/cli/score.js

@@ -0,0 +1,1971 @@
+#!/usr/bin/env node
+
+// src/cli/score.ts
+import { resolve as resolve4 } from "path";
+
+// src/engine/analyzer.ts
+import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
+import { join as join2, extname, relative as relative2, resolve as resolve2, basename as basename2 } from "path";
+import { createHash } from "crypto";
+
+// src/types/engine.ts
+var DEFAULT_RISK_WEIGHTS = {
+  hub: 30,
+  typeProvider: 25,
+  complexity: 15,
+  recency: 15,
+  config: 10,
+  churn: 5
+};
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  version: "2.0",
+  analysis: {
+    extensions: {
+      code: ["ts", "tsx", "js", "jsx", "py", "go", "rs", "java", "kt", "rb", "php", "c", "cpp", "h", "hpp", "cs"],
+      config: ["json", "yml", "yaml", "toml"],
+      docs: ["md", "txt", "rst"]
+    },
+    ignore: {
+      dirs: ["node_modules", "dist", "build", ".git", "coverage", "__pycache__", ".next", "vendor", ".cto"],
+      patterns: ["*.min.js", "*.map", "*.lock", "*.generated.*"]
+    },
+    maxDepth: 20
+  },
+  risk: {
+    weights: {
+      hub: 30,
+      typeProvider: 25,
+      complexity: 15,
+      recency: 15,
+      config: 10,
+      churn: 5
+    }
+  },
+  interaction: {
+    defaultBudget: 5e4,
+    defaultModel: "claude-sonnet-4"
+  },
+  tokens: {
+    method: "chars4"
+  },
+  governance: {
+    auditEnabled: true,
+    secretDetection: true,
+    retentionDays: 90
+  }
+};
+
+// src/engine/tokenizer.ts
+import { encodingForModel } from "js-tiktoken";
+import { readFile, stat } from "fs/promises";
+var CHARS_PER_TOKEN = 4;
+var encoder = null;
+function getEncoder() {
+  if (!encoder) {
+    encoder = encodingForModel("claude-3-5-sonnet-20241022");
+  }
+  return encoder;
+}
+function countTokensTiktoken(text) {
+  try {
+    const enc = getEncoder();
+    const tokens = enc.encode(text);
+    return tokens.length;
+  } catch {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+  }
+}
+function countTokensChars4(sizeInBytes) {
+  return Math.ceil(sizeInBytes / CHARS_PER_TOKEN);
+}
+function estimateTokens(content, sizeInBytes, method = "chars4") {
+  if (method === "tiktoken") {
+    return countTokensTiktoken(content);
+  }
+  return countTokensChars4(sizeInBytes);
+}
+
+// src/engine/graph.ts
+import { Project, SyntaxKind } from "ts-morph";
+import { resolve, relative, dirname, join } from "path";
+import { existsSync } from "fs";
+var TS_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
+function createProject(projectPath, filePaths) {
+  const tsConfigPath = join(projectPath, "tsconfig.json");
+  const hasTsConfig = existsSync(tsConfigPath);
+  const project = new Project({
+    tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: hasTsConfig ? void 0 : {
+      allowJs: true,
+      jsx: 4,
+      // JsxEmit.ReactJSX
+      esModuleInterop: true,
+      moduleResolution: 100
+      // Bundler
+    }
+  });
+  const tsFiles = filePaths.filter((f) => {
+    const ext = f.split(".").pop()?.toLowerCase() ?? "";
+    return TS_EXTENSIONS.has(ext);
+  });
+  for (const filePath of tsFiles) {
+    try {
+      project.addSourceFileAtPath(filePath);
+    } catch {
+    }
+  }
+  return project;
+}
+function buildProjectGraph(projectPath, files) {
+  const absPath = resolve(projectPath);
+  const tsFiles = files.filter((f) => TS_EXTENSIONS.has(f.extension)).map((f) => f.path);
+  if (tsFiles.length === 0) {
+    return emptyGraph(files);
+  }
+  let project;
+  try {
+    project = createProject(projectPath, tsFiles);
+  } catch {
+    return emptyGraph(files);
+  }
+  const edges = [];
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const sourceFile of project.getSourceFiles()) {
+    const fromRel = relative(absPath, sourceFile.getFilePath());
+    if (fromRel.startsWith("..") || fromRel.includes("node_modules")) continue;
+    nodeSet.add(fromRel);
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      const resolved = resolveImport(sourceFile, moduleSpecifier, absPath);
+      if (resolved) {
+        nodeSet.add(resolved);
+        edges.push({ from: fromRel, to: resolved, type: "import" });
+      }
+    }
+    for (const exp of sourceFile.getExportDeclarations()) {
+      const moduleSpecifier = exp.getModuleSpecifierValue();
+      if (moduleSpecifier) {
+        const resolved = resolveImport(sourceFile, moduleSpecifier, absPath);
+        if (resolved) {
+          nodeSet.add(resolved);
+          edges.push({ from: fromRel, to: resolved, type: "re-export" });
+        }
+      }
+    }
+  }
+  const nodes = Array.from(nodeSet);
+  const importedByCount = /* @__PURE__ */ new Map();
+  const importCount = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    importedByCount.set(edge.to, (importedByCount.get(edge.to) ?? 0) + 1);
+    importCount.set(edge.from, (importCount.get(edge.from) ?? 0) + 1);
+  }
+  const N = Math.max(nodes.length, 1);
+  const hubs = nodes.map((node) => {
+    const inDeg = importedByCount.get(node) ?? 0;
+    const outDeg = importCount.get(node) ?? 0;
+    const centrality = N > 1 ? inDeg / (N - 1) * 100 : 0;
+    const score = Math.round(centrality + outDeg * (100 / (2 * N)));
+    return {
+      relativePath: node,
+      dependents: inDeg,
+      dependencies: outDeg,
+      score: Math.min(100, score)
+    };
+  }).filter((h) => h.dependents >= 3 || h.score >= 15).sort((a, b) => b.score - a.score);
+  const leaves = nodes.filter(
+    (node) => (importedByCount.get(node) ?? 0) === 0 && (importCount.get(node) ?? 0) > 0
+  );
+  const connectedNodes = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    connectedNodes.add(edge.from);
+    connectedNodes.add(edge.to);
+  }
+  const allFileNodes = new Set(files.map((f) => f.relativePath));
+  const orphans = Array.from(allFileNodes).filter((n) => !connectedNodes.has(n));
+  const clusters = detectClusters(nodes, edges, files);
+  enrichComplexity(project, absPath, files);
+  return { nodes, edges, hubs, leaves, orphans, clusters };
+}
+var UnionFind = class {
+  parent;
+  rank;
+  constructor(nodes) {
+    this.parent = /* @__PURE__ */ new Map();
+    this.rank = /* @__PURE__ */ new Map();
+    for (const n of nodes) {
+      this.parent.set(n, n);
+      this.rank.set(n, 0);
+    }
+  }
+  find(x) {
+    const p = this.parent.get(x);
+    if (p === void 0) return x;
+    if (p !== x) {
+      this.parent.set(x, this.find(p));
+    }
+    return this.parent.get(x);
+  }
+  union(a, b) {
+    const ra = this.find(a);
+    const rb = this.find(b);
+    if (ra === rb) return;
+    const rankA = this.rank.get(ra) ?? 0;
+    const rankB = this.rank.get(rb) ?? 0;
+    if (rankA < rankB) {
+      this.parent.set(ra, rb);
+    } else if (rankA > rankB) {
+      this.parent.set(rb, ra);
+    } else {
+      this.parent.set(rb, ra);
+      this.rank.set(ra, rankA + 1);
+    }
+  }
+};
+function detectClusters(nodes, edges, files) {
+  const uf = new UnionFind(nodes);
+  for (const edge of edges) {
+    uf.union(edge.from, edge.to);
+  }
+  const components = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const root = uf.find(node);
+    if (!components.has(root)) components.set(root, []);
+    components.get(root).push(node);
+  }
+  const tokenMap = new Map(files.map((f) => [f.relativePath, f.tokens]));
+  const clusters = [];
+  for (const [, groupFiles] of components) {
+    if (groupFiles.length < 2) continue;
+    const name = commonPrefix(groupFiles);
+    const fileSet = new Set(groupFiles);
+    let internalEdges = 0;
+    let externalEdges = 0;
+    for (const edge of edges) {
+      const fromIn = fileSet.has(edge.from);
+      const toIn = fileSet.has(edge.to);
+      if (fromIn && toIn) internalEdges++;
+      else if (fromIn || toIn) externalEdges++;
+    }
+    const totalEdges = internalEdges + externalEdges;
+    const cohesion = totalEdges > 0 ? internalEdges / totalEdges : 0;
+    const totalTokens = groupFiles.reduce((s, f) => s + (tokenMap.get(f) ?? 0), 0);
+    clusters.push({
+      id: name.replace(/[^a-zA-Z0-9]/g, "-") || `cluster-${clusters.length}`,
+      name: name || `cluster-${clusters.length}`,
+      files: groupFiles,
+      totalTokens,
+      internalEdges,
+      externalEdges,
+      cohesion: Math.round(cohesion * 100) / 100
+    });
+  }
+  return clusters.sort((a, b) => b.files.length - a.files.length);
+}
+function commonPrefix(paths) {
+  if (paths.length === 0) return "";
+  const parts = paths.map((p) => p.split("/"));
+  const prefix = [];
+  for (let i = 0; i < parts[0].length - 1; i++) {
+    const segment = parts[0][i];
+    if (parts.every((p) => p[i] === segment)) {
+      prefix.push(segment);
+    } else break;
+  }
+  return prefix.join("/") || parts[0][0];
+}
+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());
+    if (relPath.startsWith("..") || relPath.includes("node_modules")) continue;
+    const file = fileMap.get(relPath);
+    if (!file) continue;
+    let totalComplexity = 0;
+    for (const func of sourceFile.getFunctions()) {
+      totalComplexity += calculateCyclomaticComplexity(func);
+    }
+    for (const cls of sourceFile.getClasses()) {
+      for (const method of cls.getMethods()) {
+        totalComplexity += calculateCyclomaticComplexity(method);
+      }
+    }
+    for (const varDecl of sourceFile.getVariableDeclarations()) {
+      const init = varDecl.getInitializer();
+      if (init && (init.getKind() === SyntaxKind.ArrowFunction || init.getKind() === SyntaxKind.FunctionExpression)) {
+        totalComplexity += calculateCyclomaticComplexity(init);
+      }
+    }
+    file.complexity = Math.max(1, totalComplexity);
+  }
+}
+function calculateCyclomaticComplexity(node) {
+  let complexity = 1;
+  node.forEachDescendant((descendant) => {
+    switch (descendant.getKind()) {
+      case SyntaxKind.IfStatement:
+      case SyntaxKind.ConditionalExpression:
+      case SyntaxKind.ForStatement:
+      case SyntaxKind.ForInStatement:
+      case SyntaxKind.ForOfStatement:
+      case SyntaxKind.WhileStatement:
+      case SyntaxKind.DoStatement:
+      case SyntaxKind.CaseClause:
+      case SyntaxKind.CatchClause:
+        complexity++;
+        break;
+      case SyntaxKind.BinaryExpression: {
+        const opToken = descendant.getOperatorToken?.();
+        if (opToken) {
+          const kind = opToken.getKind();
+          if (kind === SyntaxKind.AmpersandAmpersandToken || kind === SyntaxKind.BarBarToken || kind === SyntaxKind.QuestionQuestionToken) {
+            complexity++;
+          }
+        }
+        break;
+      }
+    }
+  });
+  return complexity;
+}
+function resolveImport(sourceFile, moduleSpecifier, projectRoot) {
+  if (!moduleSpecifier.startsWith(".")) return null;
+  const sourceDir = dirname(sourceFile.getFilePath());
+  const basePath = resolve(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 (!rel.startsWith("..")) return rel;
+    }
+  }
+  if (moduleSpecifier.endsWith(".js")) {
+    const tsPath = basePath.replace(/\.js$/, ".ts");
+    if (existsSync(tsPath)) {
+      const rel = relative(projectRoot, tsPath);
+      if (!rel.startsWith("..")) return rel;
+    }
+  }
+  return null;
+}
+function emptyGraph(files) {
+  return {
+    nodes: files.map((f) => f.relativePath),
+    edges: [],
+    hubs: [],
+    leaves: [],
+    orphans: files.map((f) => f.relativePath),
+    clusters: []
+  };
+}
+
+// src/engine/risk.ts
+function scoreAllFiles(files, graph, weights = DEFAULT_RISK_WEIGHTS) {
+  const typeProviderUsage = computeTypeProviderUsage(files, graph);
+  for (const file of files) {
+    const factors = computeRiskFactors(file, graph, typeProviderUsage, weights);
+    file.riskFactors = factors;
+    file.riskScore = computeWeightedScore(factors);
+    file.exclusionImpact = scoreToImpact(file.riskScore);
+  }
+}
+function computeRiskFactors(file, graph, typeProviderUsage, weights) {
+  const factors = [];
+  factors.push(computeHubFactor(file, weights.hub));
+  factors.push(computeTypeProviderFactor(file, typeProviderUsage, weights.typeProvider));
+  factors.push(computeComplexityFactor(file, weights.complexity));
+  factors.push(computeRecencyFactor(file, weights.recency));
+  factors.push(computeConfigFactor(file, weights.config));
+  factors.push(computeChurnFactor(file, weights.churn));
+  return factors;
+}
+function computeHubFactor(file, weight) {
+  const dependents = file.importedBy.length;
+  const K = 12;
+  const score = dependents === 0 ? 0 : Math.min(100, Math.round(100 * Math.log2(1 + dependents) / Math.log2(1 + K)));
+  const detail = dependents === 0 ? "No dependents" : `Hub: ${dependents} file(s) depend on this (score ${score}/100)`;
+  return { type: "hub", score, weight, detail };
+}
+function computeTypeProviderFactor(file, usage, weight) {
+  const isTypeFile = file.kind === "type";
+  const consumers = usage.get(file.relativePath) ?? 0;
+  let score;
+  let detail;
+  if (isTypeFile && consumers >= 4) {
+    score = 100;
+    detail = `Type provider: used by ${consumers} files (critical type source)`;
+  } else if (isTypeFile && consumers >= 1) {
+    score = 50;
+    detail = `Type provider: used by ${consumers} files`;
+  } else if (isTypeFile) {
+    score = 30;
+    detail = "Type file (no detected consumers)";
+  } else {
+    score = 0;
+    detail = "Not a type provider";
+  }
+  return { type: "type-provider", score, weight, detail };
+}
+function computeComplexityFactor(file, weight) {
+  const c = file.complexity;
+  const K = 30;
+  const score = Math.min(100, Math.round(100 * Math.log(1 + c) / Math.log(1 + K)));
+  const detail = c >= 30 ? `Very high complexity: ${c} (AI needs full context)` : c >= 10 ? `High complexity: ${c}` : `Complexity: ${c}`;
+  return { type: "complexity", score, weight, detail };
+}
+function computeRecencyFactor(file, weight) {
+  const now = Date.now();
+  const modified = new Date(file.lastModified).getTime();
+  const daysAgo = (now - modified) / (1e3 * 60 * 60 * 24);
+  const HALF_LIFE = 7;
+  const score = Math.round(100 * Math.pow(2, -daysAgo / HALF_LIFE));
+  const detail = daysAgo <= 1 ? "Modified today" : `Modified ${Math.round(daysAgo)} days ago (decay score ${score})`;
+  return { type: "recency", score, weight, detail };
+}
+function computeConfigFactor(file, weight) {
+  let score;
+  let detail;
+  if (file.kind === "entry") {
+    score = 90;
+    detail = "Entry point \u2014 critical for understanding app structure";
+  } else if (file.kind === "config") {
+    score = 80;
+    detail = "Configuration file \u2014 affects runtime behavior";
+  } else {
+    score = 0;
+    detail = "Regular source file";
+  }
+  return { type: "config", score, weight, detail };
+}
+function computeChurnFactor(file, weight) {
+  const complexitySignal = Math.min(file.complexity / 20, 1);
+  const now = Date.now();
+  const daysAgo = (now - new Date(file.lastModified).getTime()) / (1e3 * 60 * 60 * 24);
+  const recencySignal = Math.pow(2, -daysAgo / 7);
+  const score = Math.round(Math.sqrt(complexitySignal * recencySignal) * 100);
+  const detail = score >= 50 ? "Likely under active development (complex + recent)" : score >= 20 ? "Some recent activity" : "Stable \u2014 low churn (proxy estimate)";
+  return { type: "churn", score, weight, detail };
+}
+function computeWeightedScore(factors) {
+  let totalWeightedScore = 0;
+  let totalWeight = 0;
+  for (const factor of factors) {
+    totalWeightedScore += factor.score * factor.weight;
+    totalWeight += factor.weight;
+  }
+  if (totalWeight === 0) return 0;
+  return Math.round(totalWeightedScore / totalWeight);
+}
+function scoreToImpact(score) {
+  if (score >= 80) return "critical";
+  if (score >= 60) return "high";
+  if (score >= 30) return "medium";
+  if (score > 0) return "low";
+  return "none";
+}
+function computeTypeProviderUsage(files, graph) {
+  const usage = /* @__PURE__ */ new Map();
+  const typeFiles = new Set(
+    files.filter((f) => f.kind === "type").map((f) => f.relativePath)
+  );
+  for (const edge of graph.edges) {
+    if (typeFiles.has(edge.to)) {
+      usage.set(edge.to, (usage.get(edge.to) ?? 0) + 1);
+    }
+  }
+  return usage;
+}
+
+// src/engine/analyzer.ts
+function matchesPattern(filename, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      if (filename.endsWith(ext)) return true;
+    } else if (filename === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+async function walkProject(rootPath, options) {
+  const results = [];
+  const { ignoreDirs, ignorePatterns, extensions, maxDepth = 20 } = options;
+  const ignoreDirSet = new Set(ignoreDirs);
+  async function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const promises = [];
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignoreDirSet.has(entry.name) && !entry.name.startsWith(".")) {
+          promises.push(walk(fullPath, depth + 1));
+        }
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name).slice(1).toLowerCase();
+        if (ext && extensions.includes(ext) && !matchesPattern(entry.name, ignorePatterns)) {
+          promises.push(
+            (async () => {
+              const fileStat = await stat2(fullPath).catch(() => null);
+              if (!fileStat) return;
+              let lines = 0;
+              try {
+                const content = await readFile2(fullPath, "utf-8");
+                lines = content.split("\n").length;
+              } catch {
+                lines = 0;
+              }
+              results.push({
+                path: fullPath,
+                relativePath: relative2(rootPath, fullPath),
+                extension: ext,
+                size: fileStat.size,
+                lastModified: fileStat.mtime,
+                lines
+              });
+            })()
+          );
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  await walk(rootPath, 0);
+  return results;
+}
+var TYPE_PATTERNS = [/types?\//i, /\.d\.ts$/, /interfaces?\//i];
+var TEST_PATTERNS = [/\.test\.[jt]sx?$/, /\.spec\.[jt]sx?$/, /\/__tests__\//, /\/tests?\//];
+var CONFIG_PATTERNS = [/\.config\.[jt]s$/, /rc\.[jt]s$/, /\.env/, /tsconfig/, /package\.json$/, /\.yml$/, /\.yaml$/, /\.toml$/];
+var ENTRY_PATTERNS = [/^index\.[jt]sx?$/, /^main\.[jt]sx?$/, /^app\.[jt]sx?$/, /^server\.[jt]sx?$/];
+function classifyFileKind(relativePath) {
+  const filename = basename2(relativePath);
+  if (TYPE_PATTERNS.some((p) => p.test(relativePath))) return "type";
+  if (TEST_PATTERNS.some((p) => p.test(relativePath))) return "test";
+  if (CONFIG_PATTERNS.some((p) => p.test(relativePath) || p.test(filename))) return "config";
+  if (ENTRY_PATTERNS.some((p) => p.test(filename))) return "entry";
+  return "source";
+}
+function detectStack(files) {
+  const stack = [];
+  const extensions = new Set(files.map((f) => f.extension));
+  const paths = files.map((f) => f.relativePath.toLowerCase());
+  if (extensions.has("ts") || extensions.has("tsx")) stack.push("TypeScript");
+  else if (extensions.has("js") || extensions.has("jsx")) stack.push("JavaScript");
+  if (extensions.has("py")) stack.push("Python");
+  if (extensions.has("go")) stack.push("Go");
+  if (extensions.has("rs")) stack.push("Rust");
+  if (extensions.has("java")) stack.push("Java");
+  if (extensions.has("kt")) stack.push("Kotlin");
+  if (extensions.has("rb")) stack.push("Ruby");
+  if (extensions.has("php")) stack.push("PHP");
+  if (extensions.has("cs")) stack.push("C#");
+  if (extensions.has("c") || extensions.has("cpp")) stack.push("C/C++");
+  if (paths.some((p) => p.includes("next.config"))) stack.push("Next.js");
+  if (paths.some((p) => p.includes("nuxt.config"))) stack.push("Nuxt");
+  if (paths.some((p) => p.includes("angular.json"))) stack.push("Angular");
+  return stack;
+}
+async function analyzeProject(projectPath, config) {
+  const absPath = resolve2(projectPath);
+  const projectName = basename2(absPath);
+  const mergedConfig = mergeConfig(DEFAULT_CONFIG, config);
+  const allExtensions = [
+    ...mergedConfig.analysis.extensions.code,
+    ...mergedConfig.analysis.extensions.config,
+    ...mergedConfig.analysis.extensions.docs
+  ];
+  const walkEntries = await walkProject(absPath, {
+    ignoreDirs: mergedConfig.analysis.ignore.dirs,
+    ignorePatterns: mergedConfig.analysis.ignore.patterns,
+    extensions: allExtensions,
+    maxDepth: mergedConfig.analysis.maxDepth
+  });
+  const tokenMethod = mergedConfig.tokens.method;
+  const files = [];
+  for (const entry of walkEntries) {
+    let tokens;
+    if (tokenMethod === "tiktoken") {
+      try {
+        const content = await readFile2(entry.path, "utf-8");
+        tokens = estimateTokens(content, entry.size, "tiktoken");
+      } catch {
+        tokens = countTokensChars4(entry.size);
+      }
+    } else {
+      tokens = countTokensChars4(entry.size);
+    }
+    files.push({
+      path: entry.path,
+      relativePath: entry.relativePath,
+      extension: entry.extension,
+      size: entry.size,
+      tokens,
+      lines: entry.lines,
+      lastModified: entry.lastModified,
+      kind: classifyFileKind(entry.relativePath),
+      // Graph data — populated by graph analysis
+      imports: [],
+      importedBy: [],
+      isHub: false,
+      complexity: 0,
+      // Risk data — populated by risk analysis
+      riskScore: 0,
+      riskFactors: [],
+      exclusionImpact: "none"
+    });
+  }
+  const graph = buildProjectGraph(absPath, files);
+  for (const file of files) {
+    const nodeImports = [];
+    const nodeImportedBy = [];
+    for (const edge of graph.edges) {
+      if (edge.from === file.relativePath) nodeImports.push(edge.to);
+      if (edge.to === file.relativePath) nodeImportedBy.push(edge.from);
+    }
+    file.imports = nodeImports;
+    file.importedBy = nodeImportedBy;
+    file.isHub = graph.hubs.some((h) => h.relativePath === file.relativePath);
+  }
+  const riskWeights = mergedConfig.risk.weights;
+  scoreAllFiles(files, graph, riskWeights);
+  const riskProfile = {
+    distribution: {
+      critical: files.filter((f) => f.riskScore >= 80).length,
+      high: files.filter((f) => f.riskScore >= 60 && f.riskScore < 80).length,
+      medium: files.filter((f) => f.riskScore >= 30 && f.riskScore < 60).length,
+      low: files.filter((f) => f.riskScore < 30).length
+    },
+    topRiskFiles: [...files].sort((a, b) => b.riskScore - a.riskScore).slice(0, 10),
+    overallComplexity: files.length > 0 ? files.reduce((s, f) => s + f.complexity, 0) / files.length : 0
+  };
+  const totalTokens = files.reduce((s, f) => s + f.tokens, 0);
+  const hashInput = files.map((f) => `${f.relativePath}:${f.tokens}:${f.riskScore}`).sort().join("|");
+  const hash = createHash("sha256").update(hashInput).digest("hex").substring(0, 16);
+  const stack = detectStack(walkEntries);
+  return {
+    projectPath: absPath,
+    projectName,
+    analyzedAt: /* @__PURE__ */ new Date(),
+    hash,
+    files,
+    totalFiles: files.length,
+    totalTokens,
+    graph,
+    riskProfile,
+    stack,
+    tokenMethod
+  };
+}
+function mergeConfig(base, overrides) {
+  if (!overrides) return base;
+  return {
+    ...base,
+    ...overrides,
+    analysis: {
+      ...base.analysis,
+      ...overrides.analysis,
+      extensions: {
+        ...base.analysis.extensions,
+        ...overrides.analysis?.extensions
+      },
+      ignore: {
+        ...base.analysis.ignore,
+        ...overrides.analysis?.ignore
+      }
+    },
+    risk: {
+      ...base.risk,
+      ...overrides.risk,
+      weights: {
+        ...base.risk.weights,
+        ...overrides.risk?.weights
+      }
+    },
+    interaction: {
+      ...base.interaction,
+      ...overrides.interaction
+    },
+    tokens: {
+      ...base.tokens,
+      ...overrides.tokens
+    },
+    governance: {
+      ...base.governance,
+      ...overrides.governance
+    }
+  };
+}
+
+// src/engine/selector.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/govern/secrets.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve3, relative as relative3 } from "path";
+var BUILTIN_PATTERNS = [
+  // API Keys
+  { type: "api-key", source: `(?:api[_-]?key|apikey)\\s*[:=]\\s*['"]?([a-zA-Z0-9_\\-]{20,})['"]?`, flags: "gi", severity: "critical", description: "API Key" },
+  { type: "api-key", source: "sk-[a-zA-Z0-9]{20,}", flags: "g", severity: "critical", description: "OpenAI/Anthropic API Key" },
+  { type: "api-key", source: "sk-ant-[a-zA-Z0-9\\-]{20,}", flags: "g", severity: "critical", description: "Anthropic API Key" },
+  // AWS
+  { type: "aws-key", source: "AKIA[0-9A-Z]{16}", flags: "g", severity: "critical", description: "AWS Access Key ID" },
+  { type: "aws-key", source: `(?:aws_secret_access_key|aws_secret)\\s*[:=]\\s*['"]?([a-zA-Z0-9/+=]{40})['"]?`, flags: "gi", severity: "critical", description: "AWS Secret Key" },
+  // Private Keys
+  { type: "private-key", source: "-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----", flags: "g", severity: "critical", description: "Private Key" },
+  { type: "private-key", source: "-----BEGIN OPENSSH PRIVATE KEY-----", flags: "g", severity: "critical", description: "SSH Private Key" },
+  // Passwords
+  { type: "password", source: `(?:password|passwd|pwd)\\s*[:=]\\s*['"]([^'"]{8,})['"](?!\\s*\\{)`, flags: "gi", severity: "high", description: "Hardcoded Password" },
+  { type: "password", source: `(?:DB_PASSWORD|DATABASE_PASSWORD|MYSQL_PASSWORD|POSTGRES_PASSWORD)\\s*[:=]\\s*['"]?([^'"{}\\s]{4,})['"]?`, flags: "gi", severity: "high", description: "Database Password" },
+  // Tokens
+  { type: "token", source: `(?:bearer|token|auth_token|access_token|refresh_token)\\s*[:=]\\s*['"]([a-zA-Z0-9_\\-.]{20,})['"](?!\\s*\\{)`, flags: "gi", severity: "high", description: "Auth Token" },
+  { type: "token", source: "ghp_[a-zA-Z0-9]{36}", flags: "g", severity: "critical", description: "GitHub Personal Access Token" },
+  { type: "token", source: "gho_[a-zA-Z0-9]{36}", flags: "g", severity: "critical", description: "GitHub OAuth Token" },
+  { type: "token", source: "glpat-[a-zA-Z0-9\\-]{20,}", flags: "g", severity: "critical", description: "GitLab Personal Access Token" },
+  { type: "token", source: "npm_[a-zA-Z0-9]{36}", flags: "g", severity: "high", description: "npm Token" },
+  // Connection strings
+  { type: "connection-string", source: `(?:mongodb(?:\\+srv)?|postgres(?:ql)?|mysql|redis|amqp):\\/\\/[^\\s'"]+:[^\\s'"]+@[^\\s'"]+`, flags: "gi", severity: "critical", description: "Database Connection String" },
+  { type: "connection-string", source: `(?:DATABASE_URL|REDIS_URL|MONGODB_URI)\\s*[:=]\\s*['"]?([^\\s'"]{10,})['"]?`, flags: "gi", severity: "high", description: "Database URL" },
+  // Environment variables with secrets
+  { type: "env-variable", source: `(?:SECRET|PRIVATE|ENCRYPTION)[_-]?(?:KEY|TOKEN|PASS)\\s*[:=]\\s*['"]?([^\\s'"]{8,})['"]?`, flags: "gi", severity: "high", description: "Secret Environment Variable" }
+];
+function buildPatterns(customPatterns = []) {
+  const patterns = BUILTIN_PATTERNS.map((def) => ({
+    type: def.type,
+    pattern: new RegExp(def.source, def.flags),
+    severity: def.severity,
+    description: def.description
+  }));
+  for (const custom of customPatterns) {
+    try {
+      patterns.push({
+        type: "custom",
+        pattern: new RegExp(custom, "gi"),
+        severity: "medium",
+        description: `Custom pattern: ${custom}`
+      });
+    } catch {
+    }
+  }
+  return patterns;
+}
+function scanContentForSecrets(content, filePath, customPatterns = []) {
+  const findings = [];
+  const lines = content.split("\n");
+  const allPatterns = buildPatterns(customPatterns);
+  for (const secretPattern of allPatterns) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      secretPattern.pattern.lastIndex = 0;
+      let match;
+      while ((match = secretPattern.pattern.exec(line)) !== null) {
+        const matchText = match[0];
+        if (isTemplateOrPlaceholder(matchText)) continue;
+        findings.push({
+          type: secretPattern.type,
+          file: filePath,
+          line: i + 1,
+          match: matchText,
+          redacted: redactSecret(matchText),
+          severity: secretPattern.severity
+        });
+      }
+    }
+  }
+  return deduplicateFindings(findings);
+}
+async function scanFileForSecrets(filePath, projectPath, customPatterns = []) {
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    const relPath = relative3(resolve3(projectPath), resolve3(filePath));
+    return scanContentForSecrets(content, relPath, customPatterns);
+  } catch {
+    return [];
+  }
+}
+function redactSecret(value) {
+  if (value.length <= 8) return "***REDACTED***";
+  const prefix = value.substring(0, 4);
+  const suffix = value.substring(value.length - 2);
+  return `${prefix}${"*".repeat(Math.min(value.length - 6, 20))}${suffix}`;
+}
+function isTemplateOrPlaceholder(value) {
+  const placeholders = [
+    /\$\{.*\}/,
+    /\{\{.*\}\}/,
+    /%[sd]/,
+    /<[A-Z_]+>/,
+    /YOUR_.*_HERE/i,
+    /\bCHANGE_ME\b/i,
+    /\bPLACEHOLDER\b/i,
+    /\bexample\b/i,
+    /\bTODO\b/i,
+    /xxx+/i,
+    /\breplace.?me\b/i,
+    /\bdummy\b/i,
+    /\btest_?key\b/i,
+    /\bsample\b/i
+  ];
+  return placeholders.some((p) => p.test(value));
+}
+function deduplicateFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  return findings.filter((f) => {
+    const key = `${f.file}:${f.line}:${f.type}:${f.match}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/engine/pruner.ts
+import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+var TS_EXTENSIONS2 = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs"]);
+async function pruneFile(file, level) {
+  if (level === "excluded") {
+    return emptyResult(file, "excluded");
+  }
+  if (level === "full") {
+    return fullContent(file);
+  }
+  const ext = file.extension.toLowerCase();
+  const isTS = TS_EXTENSIONS2.has(ext);
+  if (isTS) {
+    return pruneTypeScript(file, level);
+  }
+  return pruneGeneric(file, level);
+}
+async function pruneTypeScript(file, level) {
+  let content;
+  try {
+    content = await readFile4(file.path, "utf-8");
+  } catch {
+    return emptyResult(file, level);
+  }
+  let project;
+  try {
+    const tsConfigPath = findTsConfig(file.path);
+    project = new Project2({
+      tsConfigFilePath: tsConfigPath,
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: tsConfigPath ? void 0 : { allowJs: true, esModuleInterop: true }
+    });
+    project.createSourceFile(file.path, content, { overwrite: true });
+  } catch {
+    return pruneGenericFromContent(file, content, level);
+  }
+  const sourceFile = project.getSourceFiles()[0];
+  if (!sourceFile) {
+    return pruneGenericFromContent(file, content, level);
+  }
+  const prunedContent = level === "signatures" ? extractSignaturesAST(sourceFile) : extractSkeletonAST(sourceFile);
+  const prunedTokens = countTokensChars4(Buffer.byteLength(prunedContent, "utf-8"));
+  const savingsPercent = file.tokens > 0 ? (file.tokens - prunedTokens) / file.tokens * 100 : 0;
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens,
+    pruneLevel: level,
+    content: prunedContent,
+    savingsPercent: Math.max(0, savingsPercent)
+  };
+}
+function extractSignaturesAST(sf) {
+  const parts = [];
+  for (const imp of sf.getImportDeclarations()) {
+    parts.push(imp.getText());
+  }
+  if (parts.length > 0) parts.push("");
+  for (const ta of sf.getTypeAliases()) {
+    addJSDoc(ta, parts);
+    parts.push(ta.getText());
+  }
+  for (const iface of sf.getInterfaces()) {
+    addJSDoc(iface, parts);
+    parts.push(iface.getText());
+  }
+  for (const en of sf.getEnums()) {
+    addJSDoc(en, parts);
+    parts.push(en.getText());
+  }
+  for (const fn of sf.getFunctions()) {
+    addJSDoc(fn, parts);
+    const isExported = fn.isExported();
+    const isAsync = fn.isAsync();
+    const name = fn.getName() ?? "<anonymous>";
+    const params = fn.getParameters().map((p) => p.getText()).join(", ");
+    const returnType = fn.getReturnTypeNode()?.getText();
+    const returnStr = returnType ? `: ${returnType}` : "";
+    const prefix = isExported ? "export " : "";
+    const asyncStr = isAsync ? "async " : "";
+    parts.push(`${prefix}${asyncStr}function ${name}(${params})${returnStr} { /* ... */ }`);
+  }
+  for (const stmt of sf.getVariableStatements()) {
+    for (const decl of stmt.getDeclarations()) {
+      const init = decl.getInitializer();
+      if (init && (init.getKind() === SyntaxKind2.ArrowFunction || init.getKind() === SyntaxKind2.FunctionExpression)) {
+        addJSDoc(stmt, parts);
+        const isExported = stmt.isExported();
+        const prefix = isExported ? "export " : "";
+        const kind = stmt.getDeclarationKind();
+        const name = decl.getName();
+        const typeNode = decl.getTypeNode()?.getText();
+        const typeStr = typeNode ? `: ${typeNode}` : "";
+        parts.push(`${prefix}${kind} ${name}${typeStr} = /* ... */;`);
+      } else {
+        addJSDoc(stmt, parts);
+        parts.push(stmt.getText());
+      }
+    }
+  }
+  for (const cls of sf.getClasses()) {
+    addJSDoc(cls, parts);
+    const isExported = cls.isExported();
+    const prefix = isExported ? "export " : "";
+    const name = cls.getName() ?? "<anonymous>";
+    const ext = cls.getExtends()?.getText();
+    const impl = cls.getImplements().map((i) => i.getText()).join(", ");
+    let header = `${prefix}class ${name}`;
+    if (ext) header += ` extends ${ext}`;
+    if (impl) header += ` implements ${impl}`;
+    header += " {";
+    parts.push(header);
+    for (const prop of cls.getProperties()) {
+      parts.push(`  ${prop.getText()}`);
+    }
+    const ctor = cls.getConstructors()[0];
+    if (ctor) {
+      const ctorParams = ctor.getParameters().map((p) => p.getText()).join(", ");
+      parts.push(`  constructor(${ctorParams}) { /* ... */ }`);
+    }
+    for (const method of cls.getMethods()) {
+      const isStatic = method.isStatic();
+      const isAsync = method.isAsync();
+      const methodName = method.getName();
+      const methodParams = method.getParameters().map((p) => p.getText()).join(", ");
+      const returnType = method.getReturnTypeNode()?.getText();
+      const returnStr = returnType ? `: ${returnType}` : "";
+      const staticStr = isStatic ? "static " : "";
+      const asyncStr = isAsync ? "async " : "";
+      parts.push(`  ${staticStr}${asyncStr}${methodName}(${methodParams})${returnStr} { /* ... */ }`);
+    }
+    parts.push("}");
+  }
+  for (const exp of sf.getExportDeclarations()) {
+    parts.push(exp.getText());
+  }
+  for (const exp of sf.getExportAssignments()) {
+    parts.push(exp.getText());
+  }
+  return parts.join("\n");
+}
+function extractSkeletonAST(sf) {
+  const parts = [];
+  for (const imp of sf.getImportDeclarations()) {
+    parts.push(imp.getText());
+  }
+  if (parts.length > 0) parts.push("");
+  for (const ta of sf.getTypeAliases()) {
+    if (ta.isExported()) parts.push(ta.getText());
+  }
+  for (const iface of sf.getInterfaces()) {
+    if (!iface.isExported()) continue;
+    const ext = iface.getExtends().map((e) => e.getText());
+    const extStr = ext.length > 0 ? ` extends ${ext.join(", ")}` : "";
+    parts.push(`export interface ${iface.getName()}${extStr} { /* ${iface.getProperties().length} props */ }`);
+  }
+  for (const en of sf.getEnums()) {
+    if (!en.isExported()) continue;
+    const members = en.getMembers().map((m) => m.getName());
+    parts.push(`export enum ${en.getName()} { ${members.join(", ")} }`);
+  }
+  for (const fn of sf.getFunctions()) {
+    if (!fn.isExported()) continue;
+    const name = fn.getName() ?? "<anonymous>";
+    const params = fn.getParameters().map((p) => p.getText()).join(", ");
+    parts.push(`export function ${name}(${params});`);
+  }
+  for (const cls of sf.getClasses()) {
+    if (!cls.isExported()) continue;
+    const methods = cls.getMethods().map((m) => m.getName());
+    parts.push(`export class ${cls.getName()} { /* methods: ${methods.join(", ")} */ }`);
+  }
+  for (const exp of sf.getExportDeclarations()) {
+    parts.push(exp.getText());
+  }
+  return parts.join("\n");
+}
+async function pruneGeneric(file, level) {
+  let content;
+  try {
+    content = await readFile4(file.path, "utf-8");
+  } catch {
+    return emptyResult(file, level);
+  }
+  return pruneGenericFromContent(file, content, level);
+}
+function pruneGenericFromContent(file, content, level) {
+  const lines = content.split("\n");
+  let result;
+  if (level === "signatures") {
+    result = lines.filter((line) => {
+      const t = line.trim();
+      return t === "" || t.startsWith("#") || t.startsWith("//") || t.startsWith("import ") || t.startsWith("from ") || t.startsWith("export ") || t.startsWith("def ") || t.startsWith("async def ") || t.startsWith("class ") || t.startsWith("function ") || t.startsWith("const ") || t.startsWith("let ") || t.startsWith("var ") || /^(pub |fn |struct |enum |impl |mod |use )/.test(t);
+    });
+  } else {
+    result = lines.filter((line) => {
+      const t = line.trim();
+      return t.startsWith("import ") || t.startsWith("from ") || t.startsWith("export ") || t.startsWith("def ") || t.startsWith("class ") || t.startsWith("function ") || /^(pub |fn |struct |enum |mod |use )/.test(t);
+    });
+  }
+  const prunedContent = result.join("\n");
+  const prunedTokens = countTokensChars4(Buffer.byteLength(prunedContent, "utf-8"));
+  const savingsPercent = file.tokens > 0 ? (file.tokens - prunedTokens) / file.tokens * 100 : 0;
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens,
+    pruneLevel: level,
+    content: prunedContent,
+    savingsPercent: Math.max(0, savingsPercent)
+  };
+}
+async function fullContent(file) {
+  let content = "";
+  try {
+    content = await readFile4(file.path, "utf-8");
+  } catch {
+  }
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens: file.tokens,
+    pruneLevel: "full",
+    content,
+    savingsPercent: 0
+  };
+}
+function emptyResult(file, level) {
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens: 0,
+    pruneLevel: level,
+    content: "",
+    savingsPercent: 100
+  };
+}
+function addJSDoc(node, parts) {
+  if (!node.getJsDocs) return;
+  const docs = node.getJsDocs();
+  if (docs.length > 0) {
+    parts.push(docs[0].getText());
+  }
+}
+function findTsConfig(filePath) {
+  let dir = filePath;
+  for (let i = 0; i < 10; i++) {
+    dir = join3(dir, "..");
+    const candidate = join3(dir, "tsconfig.json");
+    if (existsSync2(candidate)) return candidate;
+  }
+  return void 0;
+}
+
+// src/engine/graph-utils.ts
+function buildAdjacencyList(edges) {
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!forward.has(edge.from)) forward.set(edge.from, []);
+    forward.get(edge.from).push(edge.to);
+    if (!reverse.has(edge.to)) reverse.set(edge.to, []);
+    reverse.get(edge.to).push(edge.from);
+  }
+  return { forward, reverse };
+}
+function bfsBidirectional(seeds, adj, depth) {
+  const result = new Set(seeds);
+  let frontier = [...seeds];
+  const visited = /* @__PURE__ */ new Set();
+  for (let d = 0; d < depth; d++) {
+    const nextFrontier = [];
+    for (const node of frontier) {
+      if (visited.has(node)) continue;
+      visited.add(node);
+      const fwd = adj.forward.get(node);
+      if (fwd) {
+        for (const neighbor of fwd) {
+          if (!visited.has(neighbor)) {
+            result.add(neighbor);
+            nextFrontier.push(neighbor);
+          }
+        }
+      }
+      const rev = adj.reverse.get(node);
+      if (rev) {
+        for (const neighbor of rev) {
+          if (!visited.has(neighbor)) {
+            result.add(neighbor);
+            nextFrontier.push(neighbor);
+          }
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  return result;
+}
+function matchGlob(path, pattern) {
+  const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "\xA7\xA7").replace(/\*/g, "[^/]*").replace(/§§/g, ".*").replace(/\?/g, ".");
+  try {
+    return new RegExp(`^${regexStr}$`).test(path);
+  } catch {
+    return false;
+  }
+}
+
+// src/engine/coverage.ts
+function calculateCoverage(targetPaths, includedPaths, allFiles, graph, depth = 2) {
+  const adj = buildAdjacencyList(graph.edges);
+  const relevantSet = targetPaths.length > 0 ? bfsBidirectional(targetPaths, adj, depth) : /* @__PURE__ */ new Set();
+  const includedSet = new Set(includedPaths);
+  const tempFileMap = new Map(allFiles.map((f) => [f.relativePath, f]));
+  for (const path of includedPaths) {
+    const file = tempFileMap.get(path);
+    if (!file) continue;
+    for (const imp of file.imports) {
+      const impFile = tempFileMap.get(imp);
+      if (impFile && impFile.kind === "type") {
+        relevantSet.add(imp);
+      }
+    }
+  }
+  const relevantFiles = Array.from(relevantSet);
+  const includedRelevant = relevantFiles.filter((f) => includedSet.has(f));
+  const missingRelevant = relevantFiles.filter((f) => !includedSet.has(f));
+  const missingCritical = missingRelevant.filter((f) => {
+    const file = tempFileMap.get(f);
+    return file && (file.exclusionImpact === "critical" || file.exclusionImpact === "high");
+  });
+  const fileMap = new Map(allFiles.map((f) => [f.relativePath, f]));
+  let totalRelevantRisk = 0;
+  let includedRelevantRisk = 0;
+  for (const f of relevantFiles) {
+    const risk = fileMap.get(f)?.riskScore ?? 1;
+    totalRelevantRisk += risk;
+    if (includedSet.has(f)) {
+      includedRelevantRisk += risk;
+    }
+  }
+  const score = totalRelevantRisk > 0 ? Math.round(includedRelevantRisk / totalRelevantRisk * 100) : relevantFiles.length > 0 ? Math.round(includedRelevant.length / relevantFiles.length * 100) : 100;
+  let explanation;
+  if (score >= 90) {
+    explanation = `Excellent coverage (${score}%): AI has nearly all relevant context.`;
+  } else if (score >= 70) {
+    explanation = `Good coverage (${score}%): Most relevant files included.`;
+    if (missingCritical.length > 0) {
+      explanation += ` Warning: ${missingCritical.length} critical file(s) missing.`;
+    }
+  } else if (score >= 50) {
+    explanation = `Partial coverage (${score}%): Significant context is missing.`;
+    if (missingCritical.length > 0) {
+      explanation += ` ${missingCritical.length} critical file(s) not included \u2014 AI quality will degrade.`;
+    }
+  } else {
+    explanation = `Low coverage (${score}%): Most relevant files are excluded. AI response quality will be poor.`;
+  }
+  return {
+    score,
+    relevantFiles,
+    includedRelevant,
+    missingRelevant,
+    missingCritical,
+    explanation
+  };
+}
+
+// src/engine/budget.ts
+function getPruneLevelForRisk(riskScore) {
+  if (riskScore >= 80) return "full";
+  if (riskScore >= 60) return "full";
+  if (riskScore >= 30) return "signatures";
+  return "skeleton";
+}
+
+// src/engine/selector.ts
+async function selectContext(input) {
+  const { task, analysis, budget, policies, depth = 2 } = input;
+  const decisions = [];
+  const targetPaths = identifyTargetFiles(task, analysis.files);
+  if (targetPaths.length > 0) {
+    decisions.push({
+      file: targetPaths.join(", "),
+      action: "include-full",
+      reason: `Target file(s) identified from task description`
+    });
+  }
+  const adj = buildAdjacencyList(analysis.graph.edges);
+  const expandedPaths = targetPaths.length > 0 ? Array.from(bfsBidirectional(targetPaths, adj, depth)) : [];
+  const expansionCount = expandedPaths.length - targetPaths.length;
+  if (expansionCount > 0) {
+    decisions.push({
+      file: `${expansionCount} dependencies`,
+      action: "include-full",
+      reason: `Expanded ${targetPaths.length} target(s) to ${expandedPaths.length} files via dependency graph (depth ${depth})`
+    });
+  }
+  const allFileMap = new Map(analysis.files.map((f) => [f.relativePath, f]));
+  if (targetPaths.length > 0) {
+    for (const path of expandedPaths) {
+      const file = allFileMap.get(path);
+      if (!file) continue;
+      for (const imp of file.imports) {
+        const impFile = allFileMap.get(imp);
+        if (impFile && impFile.kind === "type") {
+          expandedPaths.push(imp);
+        }
+      }
+    }
+  }
+  const { mustInclude, mustExclude } = applyPolicies(analysis.files, policies);
+  const candidateSet = /* @__PURE__ */ new Set([...expandedPaths, ...mustInclude]);
+  if (targetPaths.length === 0) {
+    for (const f of analysis.files) {
+      candidateSet.add(f.relativePath);
+    }
+  }
+  for (const ex of mustExclude) {
+    candidateSet.delete(ex);
+    decisions.push({
+      file: ex,
+      action: "exclude",
+      reason: "Excluded by policy"
+    });
+  }
+  const hasSecretBlock = policies?.rules.some(
+    (r) => r.type === "secret-block" && r.enabled
+  );
+  if (hasSecretBlock) {
+    for (const path of Array.from(candidateSet)) {
+      const file = allFileMap.get(path);
+      if (!file) continue;
+      const findings = await scanFileForSecrets(
+        file.path,
+        analysis.projectPath
+      );
+      if (findings.length > 0) {
+        candidateSet.delete(path);
+        decisions.push({
+          file: path,
+          action: "exclude",
+          reason: `Blocked: ${findings.length} secret(s) detected (${findings.map((f) => f.type).join(", ")})`
+        });
+      }
+    }
+  }
+  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 b.riskScore - a.riskScore;
+  });
+  const selectedFiles = [];
+  let usedTokens = 0;
+  for (const file of candidates) {
+    const isTarget = targetPaths.includes(file.relativePath);
+    const isMustInclude = mustInclude.has(file.relativePath);
+    const defaultLevel = isTarget ? "full" : getPruneLevelForRisk(file.riskScore);
+    const levels = getCascadeLevels(defaultLevel);
+    let included = false;
+    for (const level of levels) {
+      if (level === "excluded") break;
+      let tokens;
+      if (level === "full") {
+        tokens = file.tokens;
+      } else {
+        const pruned = await pruneFile(file, level);
+        tokens = pruned.prunedTokens;
+      }
+      if (usedTokens + tokens <= budget) {
+        usedTokens += tokens;
+        selectedFiles.push({
+          relativePath: file.relativePath,
+          tokens,
+          originalTokens: file.tokens,
+          pruneLevel: level,
+          riskScore: file.riskScore,
+          reason: buildReason(file, level, isTarget, isMustInclude)
+        });
+        if (level !== defaultLevel) {
+          decisions.push({
+            file: file.relativePath,
+            action: `include-${level}`,
+            reason: `Downgraded from ${defaultLevel} to ${level} due to budget constraint`,
+            alternatives: `Would need ${file.tokens - tokens} more tokens for ${defaultLevel}`
+          });
+        }
+        included = true;
+        break;
+      }
+    }
+    if (!included) {
+      decisions.push({
+        file: file.relativePath,
+        action: "exclude",
+        reason: `Budget exhausted (risk: ${file.riskScore}, needs ${file.tokens} tokens)`
+      });
+    }
+  }
+  const includedPaths = selectedFiles.map((f) => f.relativePath);
+  const coverage = calculateCoverage(
+    targetPaths,
+    includedPaths,
+    analysis.files,
+    analysis.graph,
+    depth
+  );
+  const includedSet = new Set(includedPaths);
+  const excludedFiles = analysis.files.filter(
+    (f) => !includedSet.has(f.relativePath)
+  );
+  const excludedRisk = excludedFiles.length > 0 ? Math.round(excludedFiles.reduce((s, f) => s + f.riskScore, 0) / excludedFiles.length) : 0;
+  const hashInput = selectedFiles.map((f) => `${f.relativePath}:${f.pruneLevel}`).sort().join("|") + `|budget:${budget}`;
+  const hash = createHash2("sha256").update(hashInput).digest("hex").substring(0, 16);
+  return {
+    files: selectedFiles,
+    totalTokens: usedTokens,
+    budget,
+    usedPercent: budget > 0 ? Math.round(usedTokens / budget * 100 * 10) / 10 : 0,
+    coverage,
+    riskScore: excludedRisk,
+    deterministic: true,
+    hash,
+    decisions
+  };
+}
+function identifyTargetFiles(task, files) {
+  const targets = [];
+  const pathPattern = /(?:^|\s|["'`])([.\w/-]+\.[a-zA-Z]{1,4})(?:\s|$|["'`]|,|:)/g;
+  let match;
+  while ((match = pathPattern.exec(task)) !== null) {
+    const candidate = match[1];
+    const found = files.find(
+      (f) => f.relativePath === candidate || f.relativePath.endsWith(candidate)
+    );
+    if (found && !targets.includes(found.relativePath)) {
+      targets.push(found.relativePath);
+    }
+  }
+  return targets;
+}
+function applyPolicies(files, policies) {
+  const mustInclude = /* @__PURE__ */ new Set();
+  const mustExclude = /* @__PURE__ */ new Set();
+  if (!policies) return { mustInclude, mustExclude };
+  for (const rule of policies.rules) {
+    if (!rule.enabled) continue;
+    if (rule.type === "include-always" && rule.pattern) {
+      for (const file of files) {
+        if (matchGlob(file.relativePath, rule.pattern)) {
+          mustInclude.add(file.relativePath);
+        }
+      }
+    }
+    if (rule.type === "exclude-always" && rule.pattern) {
+      for (const file of files) {
+        if (matchGlob(file.relativePath, rule.pattern)) {
+          mustExclude.add(file.relativePath);
+        }
+      }
+    }
+  }
+  return { mustInclude, mustExclude };
+}
+function getCascadeLevels(startLevel) {
+  const all = ["full", "signatures", "skeleton", "excluded"];
+  const startIdx = all.indexOf(startLevel);
+  return all.slice(startIdx);
+}
+function buildReason(file, level, isTarget, isMustInclude) {
+  if (isTarget) return "Target file";
+  if (isMustInclude) return "Required by policy";
+  const impact = file.exclusionImpact;
+  const levelStr = level === "full" ? "full content" : level;
+  if (impact === "critical") return `Critical dependency (risk ${file.riskScore}) \u2014 ${levelStr}`;
+  if (impact === "high") return `High-risk dependency (risk ${file.riskScore}) \u2014 ${levelStr}`;
+  if (impact === "medium") return `Medium relevance (risk ${file.riskScore}) \u2014 ${levelStr}`;
+  return `Low relevance (risk ${file.riskScore}) \u2014 ${levelStr}`;
+}
+
+// src/engine/score.ts
+async function computeContextScore(analysis, task = "general code review and refactoring", budget = 5e4) {
+  const selection = await selectContext({ task, analysis, budget });
+  const insights = [];
+  const efficiency = scoreEfficiency(analysis, selection, insights);
+  const coverage = scoreCoverage(analysis, selection, insights);
+  const riskControl = scoreRiskControl(analysis, selection, insights);
+  const structure = scoreStructure(analysis, insights);
+  const governance = scoreGovernance(analysis, insights);
+  const overall = Math.round(
+    efficiency.weighted + coverage.weighted + riskControl.weighted + structure.weighted + governance.weighted
+  );
+  const grade = scoreToGrade(overall);
+  const naiveTokens = analysis.totalTokens;
+  const optimizedTokens = selection.totalTokens;
+  const savedTokens = naiveTokens - optimizedTokens;
+  const savedPercent = naiveTokens > 0 ? Math.round(savedTokens / naiveTokens * 100) : 0;
+  const interactionsPerMonth = 40 * 20;
+  const costPerMToken = 3;
+  const naiveMonthlyCost = naiveTokens / 1e6 * costPerMToken * interactionsPerMonth;
+  const optimizedMonthlyCost = optimizedTokens / 1e6 * costPerMToken * interactionsPerMonth;
+  const monthlySavingsUSD = Math.round((naiveMonthlyCost - optimizedMonthlyCost) * 100) / 100;
+  return {
+    overall,
+    grade,
+    dimensions: {
+      efficiency,
+      coverage,
+      riskControl,
+      structure,
+      governance
+    },
+    insights: insights.sort((a, b) => {
+      const order = { high: 0, medium: 1, low: 2 };
+      return order[a.impact] - order[b.impact];
+    }),
+    comparison: {
+      naiveTokens,
+      optimizedTokens,
+      savedTokens,
+      savedPercent,
+      monthlySavingsUSD
+    },
+    meta: {
+      projectName: analysis.projectName,
+      totalFiles: analysis.totalFiles,
+      totalTokens: analysis.totalTokens,
+      analyzedAt: analysis.analyzedAt
+    }
+  };
+}
+function scoreEfficiency(analysis, selection, insights) {
+  const weight = 30;
+  const ratio = analysis.totalTokens > 0 ? 1 - selection.totalTokens / analysis.totalTokens : 0;
+  const selectivity = analysis.totalFiles > 0 ? 1 - selection.files.length / analysis.totalFiles : 0;
+  const prunedFiles = selection.files.filter(
+    (f) => f.pruneLevel === "signatures" || f.pruneLevel === "skeleton"
+  ).length;
+  const pruneRatio = selection.files.length > 0 ? prunedFiles / selection.files.length : 0;
+  const raw = (ratio * 0.5 + selectivity * 0.3 + pruneRatio * 0.2) * 100;
+  const score = Math.min(100, Math.max(0, Math.round(raw)));
+  const weighted = score / 100 * weight;
+  if (ratio > 0.7) {
+    insights.push({
+      type: "strength",
+      title: "Excellent compression",
+      detail: `${Math.round(ratio * 100)}% token reduction while maintaining context quality`,
+      impact: "high"
+    });
+  }
+  if (ratio < 0.3 && analysis.totalTokens > 2e4) {
+    insights.push({
+      type: "weakness",
+      title: "Low compression opportunity",
+      detail: "Most files are needed. Consider splitting the project into smaller modules.",
+      impact: "medium"
+    });
+  }
+  return {
+    score,
+    weight,
+    weighted,
+    detail: `${Math.round(ratio * 100)}% compression, ${prunedFiles}/${selection.files.length} files pruned`
+  };
+}
+function scoreCoverage(analysis, selection, insights) {
+  const weight = 25;
+  const coverageScore = selection.coverage.score;
+  const missingCritical = selection.coverage.missingCritical.length;
+  let penalty = 0;
+  if (missingCritical > 0) {
+    penalty = Math.min(30, missingCritical * 10);
+    insights.push({
+      type: "weakness",
+      title: `${missingCritical} critical file(s) missing from context`,
+      detail: `Missing: ${selection.coverage.missingCritical.slice(0, 3).join(", ")}${missingCritical > 3 ? ` +${missingCritical - 3} more` : ""}`,
+      impact: "high"
+    });
+  }
+  const score = Math.min(100, Math.max(0, Math.round(coverageScore - penalty)));
+  const weighted = score / 100 * weight;
+  if (coverageScore >= 90 && missingCritical === 0) {
+    insights.push({
+      type: "strength",
+      title: "Excellent context coverage",
+      detail: `${coverageScore}% of the relevant universe captured with zero critical gaps`,
+      impact: "high"
+    });
+  }
+  return {
+    score,
+    weight,
+    weighted,
+    detail: `${coverageScore}% coverage, ${missingCritical} critical gaps`
+  };
+}
+function scoreRiskControl(analysis, selection, insights) {
+  const weight = 20;
+  const dist = analysis.riskProfile.distribution;
+  const totalFiles = analysis.totalFiles;
+  const criticalFiles = analysis.files.filter((f) => f.riskScore >= 80);
+  const highFiles = analysis.files.filter((f) => f.riskScore >= 60 && f.riskScore < 80);
+  const selectedPaths = new Set(selection.files.map((f) => f.relativePath));
+  const criticalIncluded = criticalFiles.filter((f) => selectedPaths.has(f.relativePath)).length;
+  const highIncluded = highFiles.filter((f) => selectedPaths.has(f.relativePath)).length;
+  const criticalCoverage = criticalFiles.length > 0 ? criticalIncluded / criticalFiles.length : 1;
+  const highCoverage = highFiles.length > 0 ? highIncluded / highFiles.length : 1;
+  const criticalRatio = totalFiles > 0 ? dist.critical / totalFiles : 0;
+  const healthScore = Math.max(0, 1 - criticalRatio * 5);
+  const raw = (criticalCoverage * 0.5 + highCoverage * 0.3 + healthScore * 0.2) * 100;
+  const score = Math.min(100, Math.max(0, Math.round(raw)));
+  const weighted = score / 100 * weight;
+  if (criticalCoverage === 1 && criticalFiles.length > 0) {
+    insights.push({
+      type: "strength",
+      title: "All critical files included",
+      detail: `${criticalFiles.length} critical-risk files are captured in context`,
+      impact: "high"
+    });
+  }
+  if (criticalRatio > 0.2) {
+    insights.push({
+      type: "opportunity",
+      title: "High concentration of critical files",
+      detail: `${dist.critical} files (${Math.round(criticalRatio * 100)}%) are critical risk. Consider refactoring complex modules.`,
+      impact: "medium"
+    });
+  }
+  return {
+    score,
+    weight,
+    weighted,
+    detail: `${criticalIncluded}/${criticalFiles.length} critical + ${highIncluded}/${highFiles.length} high-risk files included`
+  };
+}
+function scoreStructure(analysis, insights) {
+  const weight = 15;
+  const graph = analysis.graph;
+  const totalFiles = analysis.totalFiles;
+  const avgCohesion = graph.clusters.length > 0 ? graph.clusters.reduce((s, c) => s + c.cohesion, 0) / graph.clusters.length : 0;
+  const orphanRatio = totalFiles > 0 ? graph.orphans.length / totalFiles : 0;
+  const hubRatio = totalFiles > 0 ? graph.hubs.length / totalFiles : 0;
+  const hubHealth = hubRatio > 0.02 && hubRatio < 0.15 ? 1 : Math.max(0, 1 - Math.abs(hubRatio - 0.08) * 10);
+  const typeFiles = analysis.files.filter((f) => f.kind === "type").length;
+  const typeRatio = totalFiles > 0 ? typeFiles / totalFiles : 0;
+  const typeScore = Math.min(1, typeRatio * 10);
+  const raw = (avgCohesion * 0.3 + (1 - orphanRatio) * 0.3 + hubHealth * 0.2 + typeScore * 0.2) * 100;
+  const score = Math.min(100, Math.max(0, Math.round(raw)));
+  const weighted = score / 100 * weight;
+  if (orphanRatio > 0.5) {
+    insights.push({
+      type: "weakness",
+      title: "Many orphan files",
+      detail: `${graph.orphans.length} files (${Math.round(orphanRatio * 100)}%) have no imports/exports. AI gets less context from the dependency graph.`,
+      impact: "medium"
+    });
+  }
+  if (graph.clusters.length > 0 && avgCohesion > 0.7) {
+    insights.push({
+      type: "strength",
+      title: "Well-organized module structure",
+      detail: `${graph.clusters.length} cohesive clusters (avg cohesion: ${(avgCohesion * 100).toFixed(0)}%). CTO can efficiently select relevant modules.`,
+      impact: "medium"
+    });
+  }
+  return {
+    score,
+    weight,
+    weighted,
+    detail: `${graph.clusters.length} clusters, ${graph.orphans.length} orphans, ${graph.hubs.length} hubs`
+  };
+}
+function scoreGovernance(analysis, insights) {
+  const weight = 10;
+  const hasTypes = analysis.files.some((f) => f.kind === "type");
+  const hasConfig = analysis.files.some((f) => f.kind === "config");
+  const hasTests = analysis.files.some((f) => f.kind === "test");
+  let score = 50;
+  if (hasTypes) {
+    score += 15;
+  }
+  if (hasConfig) {
+    score += 10;
+  }
+  if (hasTests) {
+    score += 15;
+  }
+  if (analysis.stack.length > 0) {
+    score += 10;
+  }
+  score = Math.min(100, score);
+  const weighted = score / 100 * weight;
+  if (!hasTests) {
+    insights.push({
+      type: "opportunity",
+      title: "No test files detected",
+      detail: "Adding tests helps CTO understand code intent and provides better context boundaries.",
+      impact: "low"
+    });
+  }
+  if (!hasTypes) {
+    insights.push({
+      type: "opportunity",
+      title: "No type definition files",
+      detail: "Type files dramatically improve AI code generation accuracy. Consider adding interfaces/types.",
+      impact: "medium"
+    });
+  }
+  return {
+    score,
+    weight,
+    weighted,
+    detail: `types:${hasTypes ? "\u2713" : "\u2717"} tests:${hasTests ? "\u2713" : "\u2717"} config:${hasConfig ? "\u2713" : "\u2717"} stack:${analysis.stack.join(",") || "unknown"}`
+  };
+}
+function scoreToGrade(score) {
+  if (score >= 95) return "A+";
+  if (score >= 90) return "A";
+  if (score >= 85) return "A-";
+  if (score >= 80) return "B+";
+  if (score >= 75) return "B";
+  if (score >= 70) return "B-";
+  if (score >= 65) return "C+";
+  if (score >= 60) return "C";
+  if (score >= 55) return "C-";
+  if (score >= 40) return "D";
+  return "F";
+}
+function renderContextScore(score) {
+  const lines = [];
+  const gradeColor = score.grade.startsWith("A") ? "\u{1F7E2}" : score.grade.startsWith("B") ? "\u{1F535}" : score.grade.startsWith("C") ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push("");
+  lines.push(`  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`);
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2551   ${gradeColor} Context Score\u2122  ${padCenter(score.overall.toString(), 3)} / 100   Grade: ${padCenter(score.grade, 2)}    \u2551`);
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2551   ${score.meta.projectName.padEnd(20).substring(0, 20)}                              \u2551`);
+  lines.push(`  \u2551   ${score.meta.totalFiles} files \xB7 ${Math.round(score.meta.totalTokens / 1e3)}K tokens               \u2551`);
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+  const dims = [
+    { label: "Efficiency", dim: score.dimensions.efficiency },
+    { label: "Coverage", dim: score.dimensions.coverage },
+    { label: "Risk Control", dim: score.dimensions.riskControl },
+    { label: "Structure", dim: score.dimensions.structure },
+    { label: "Governance", dim: score.dimensions.governance }
+  ];
+  lines.push(`  \u2551                                                  \u2551`);
+  for (const { label, dim } of dims) {
+    const bar = renderBar(dim.score, 20);
+    const pct = dim.score.toString().padStart(3);
+    lines.push(`  \u2551   ${label.padEnd(14)} ${bar} ${pct}%  (\xD7${dim.weight}%)  \u2551`);
+  }
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2551   \u{1F4B0} vs. Sending Everything:                     \u2551`);
+  lines.push(`  \u2551   Tokens saved: ${formatNumber(score.comparison.savedTokens).padEnd(12)} (${score.comparison.savedPercent}%)            \u2551`);
+  lines.push(`  \u2551   Monthly savings: $${score.comparison.monthlySavingsUSD.toFixed(2).padEnd(10)}                  \u2551`);
+  lines.push(`  \u2551   (${score.comparison.optimizedTokens.toLocaleString()} vs ${score.comparison.naiveTokens.toLocaleString()} tokens)      \u2551`);
+  lines.push(`  \u2551                                                  \u2551`);
+  if (score.insights.length > 0) {
+    lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+    lines.push(`  \u2551                                                  \u2551`);
+    const top = score.insights.slice(0, 5);
+    for (const insight of top) {
+      const icon = insight.type === "strength" ? "\u2705" : insight.type === "weakness" ? "\u26A0\uFE0F" : "\u{1F4A1}";
+      const title = insight.title.substring(0, 44).padEnd(44);
+      lines.push(`  \u2551   ${icon} ${title}  \u2551`);
+    }
+    lines.push(`  \u2551                                                  \u2551`);
+  }
+  lines.push(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderBar(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+function padCenter(str, width) {
+  const pad2 = Math.max(0, width - str.length);
+  const left = Math.floor(pad2 / 2);
+  return " ".repeat(left) + str + " ".repeat(pad2 - left);
+}
+function formatNumber(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+}
+
+// src/engine/benchmark.ts
+async function runBenchmark(analysis, task = "general code review and refactoring", budget = 5e4) {
+  const criticalFiles = analysis.files.filter((f) => f.riskScore >= 80);
+  const highRiskFiles = analysis.files.filter((f) => f.riskScore >= 60 && f.riskScore < 80);
+  const ctoStart = performance.now();
+  const ctoSelection = await selectContext({ task, analysis, budget });
+  const ctoTime = performance.now() - ctoStart;
+  const ctoSelectedPaths = new Set(ctoSelection.files.map((f) => f.relativePath));
+  const ctoCritical = criticalFiles.filter((f) => ctoSelectedPaths.has(f.relativePath)).length;
+  const ctoHigh = highRiskFiles.filter((f) => ctoSelectedPaths.has(f.relativePath)).length;
+  const cto = {
+    filesSelected: ctoSelection.files.length,
+    tokensUsed: ctoSelection.totalTokens,
+    coverageScore: ctoSelection.coverage.score,
+    criticalFilesCovered: ctoCritical,
+    criticalFilesTotal: criticalFiles.length,
+    highRiskCovered: ctoHigh,
+    highRiskTotal: highRiskFiles.length,
+    costPerInteractionUSD: ctoSelection.totalTokens / 1e6 * 3,
+    // Sonnet pricing
+    timeMs: Math.round(ctoTime)
+  };
+  const naiveStart = performance.now();
+  const naiveFiles = [...analysis.files].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  let naiveTokens = 0;
+  let naiveCount = 0;
+  const naiveSelectedPaths = /* @__PURE__ */ new Set();
+  for (const f of naiveFiles) {
+    if (naiveTokens + f.tokens <= budget) {
+      naiveTokens += f.tokens;
+      naiveCount++;
+      naiveSelectedPaths.add(f.relativePath);
+    }
+  }
+  if (naiveTokens === 0 && analysis.totalTokens <= budget) {
+    naiveTokens = analysis.totalTokens;
+    naiveCount = analysis.totalFiles;
+    for (const f of analysis.files) naiveSelectedPaths.add(f.relativePath);
+  }
+  const naiveTime = performance.now() - naiveStart;
+  const naiveCritical = criticalFiles.filter((f) => naiveSelectedPaths.has(f.relativePath)).length;
+  const naiveHigh = highRiskFiles.filter((f) => naiveSelectedPaths.has(f.relativePath)).length;
+  const naiveCoverage = analysis.totalFiles > 0 ? Math.round(naiveCount / analysis.totalFiles * 100) : 0;
+  const naive = {
+    filesSelected: naiveCount,
+    tokensUsed: naiveTokens > 0 ? naiveTokens : analysis.totalTokens,
+    coverageScore: naiveTokens > 0 ? naiveCoverage : 100,
+    criticalFilesCovered: naiveCritical,
+    criticalFilesTotal: criticalFiles.length,
+    highRiskCovered: naiveHigh,
+    highRiskTotal: highRiskFiles.length,
+    costPerInteractionUSD: (naiveTokens > 0 ? naiveTokens : analysis.totalTokens) / 1e6 * 3,
+    timeMs: Math.round(naiveTime)
+  };
+  const randomStart = performance.now();
+  const shuffled = [...analysis.files].sort(() => Math.random() - 0.5);
+  let randomTokens = 0;
+  let randomCount = 0;
+  const randomSelectedPaths = /* @__PURE__ */ new Set();
+  for (const f of shuffled) {
+    if (randomTokens + f.tokens <= budget) {
+      randomTokens += f.tokens;
+      randomCount++;
+      randomSelectedPaths.add(f.relativePath);
+    }
+  }
+  const randomTime = performance.now() - randomStart;
+  const randomCritical = criticalFiles.filter((f) => randomSelectedPaths.has(f.relativePath)).length;
+  const randomHigh = highRiskFiles.filter((f) => randomSelectedPaths.has(f.relativePath)).length;
+  const randomCoverage = analysis.totalFiles > 0 ? Math.round(randomCount / analysis.totalFiles * 100) : 0;
+  const random = {
+    filesSelected: randomCount,
+    tokensUsed: randomTokens,
+    coverageScore: randomCoverage,
+    criticalFilesCovered: randomCritical,
+    criticalFilesTotal: criticalFiles.length,
+    highRiskCovered: randomHigh,
+    highRiskTotal: highRiskFiles.length,
+    costPerInteractionUSD: randomTokens / 1e6 * 3,
+    timeMs: Math.round(randomTime)
+  };
+  const ctoScore = computeStrategyScore(cto, budget);
+  const naiveScore = computeStrategyScore(naive, budget);
+  const randomScore = computeStrategyScore(random, budget);
+  const winner = ctoScore >= naiveScore && ctoScore >= randomScore ? "cto" : naiveScore >= randomScore ? "naive" : "random";
+  const interactionsPerMonth = 800;
+  const vsNaiveCostSaved = (naive.costPerInteractionUSD - cto.costPerInteractionUSD) * interactionsPerMonth;
+  return {
+    project: analysis.projectName,
+    totalFiles: analysis.totalFiles,
+    totalTokens: analysis.totalTokens,
+    budget,
+    task,
+    strategies: { cto, naive, random },
+    winner,
+    ctoAdvantage: {
+      vsNaiveTokensSaved: naive.tokensUsed - cto.tokensUsed,
+      vsNaiveTokensSavedPercent: naive.tokensUsed > 0 ? Math.round((naive.tokensUsed - cto.tokensUsed) / naive.tokensUsed * 100) : 0,
+      vsRandomCoverageGain: cto.coverageScore - random.coverageScore,
+      vsNaiveCostSavedMonthlyUSD: Math.round(vsNaiveCostSaved * 100) / 100
+    }
+  };
+}
+function computeStrategyScore(strategy, budget) {
+  const coverageWeight = strategy.coverageScore / 100;
+  const criticalWeight = strategy.criticalFilesTotal > 0 ? strategy.criticalFilesCovered / strategy.criticalFilesTotal : 1;
+  const efficiency = budget > 0 ? 1 - strategy.tokensUsed / budget : 0;
+  return coverageWeight * 0.5 + criticalWeight * 0.3 + Math.max(0, efficiency) * 0.2;
+}
+function renderBenchmark(result) {
+  const lines = [];
+  const { cto, naive, random } = result.strategies;
+  lines.push("");
+  lines.push(`  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`);
+  lines.push(`  \u2551           \u26A1 CTO Benchmark \u2014 ${result.project.substring(0, 20).padEnd(20)}            \u2551`);
+  lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+  lines.push(`  \u2551                                                              \u2551`);
+  lines.push(`  \u2551  ${pad("Metric", 20)} ${pad("CTO", 12)} ${pad("Naive", 12)} ${pad("Random", 12)} \u2551`);
+  lines.push(`  \u2551  ${"\u2500".repeat(56)} \u2551`);
+  lines.push(`  \u2551  ${pad("Files selected", 20)} ${pad(cto.filesSelected.toString(), 12)} ${pad(naive.filesSelected.toString(), 12)} ${pad(random.filesSelected.toString(), 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("Tokens used", 20)} ${pad(fmt(cto.tokensUsed), 12)} ${pad(fmt(naive.tokensUsed), 12)} ${pad(fmt(random.tokensUsed), 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("Coverage", 20)} ${pad(cto.coverageScore + "%", 12)} ${pad(naive.coverageScore + "%", 12)} ${pad(random.coverageScore + "%", 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("Critical files", 20)} ${pad(`${cto.criticalFilesCovered}/${cto.criticalFilesTotal}`, 12)} ${pad(`${naive.criticalFilesCovered}/${naive.criticalFilesTotal}`, 12)} ${pad(`${random.criticalFilesCovered}/${random.criticalFilesTotal}`, 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("High-risk files", 20)} ${pad(`${cto.highRiskCovered}/${cto.highRiskTotal}`, 12)} ${pad(`${naive.highRiskCovered}/${naive.highRiskTotal}`, 12)} ${pad(`${random.highRiskCovered}/${random.highRiskTotal}`, 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("Cost/interaction", 20)} ${pad("$" + cto.costPerInteractionUSD.toFixed(4), 12)} ${pad("$" + naive.costPerInteractionUSD.toFixed(4), 12)} ${pad("$" + random.costPerInteractionUSD.toFixed(4), 12)} \u2551`);
+  lines.push(`  \u2551  ${pad("Time", 20)} ${pad(cto.timeMs + "ms", 12)} ${pad(naive.timeMs + "ms", 12)} ${pad(random.timeMs + "ms", 12)} \u2551`);
+  lines.push(`  \u2551                                                              \u2551`);
+  lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+  lines.push(`  \u2551                                                              \u2551`);
+  lines.push(`  \u2551  \u{1F3C6} Winner: ${result.winner.toUpperCase().padEnd(48)} \u2551`);
+  if (result.ctoAdvantage.vsNaiveTokensSavedPercent > 0) {
+    lines.push(`  \u2551  \u{1F4C9} ${result.ctoAdvantage.vsNaiveTokensSavedPercent}% fewer tokens than naive                              \u2551`);
+  }
+  if (result.ctoAdvantage.vsRandomCoverageGain > 0) {
+    lines.push(`  \u2551  \u{1F4C8} +${result.ctoAdvantage.vsRandomCoverageGain}% better coverage than random                        \u2551`);
+  }
+  if (result.ctoAdvantage.vsNaiveCostSavedMonthlyUSD > 0) {
+    lines.push(`  \u2551  \u{1F4B0} $${result.ctoAdvantage.vsNaiveCostSavedMonthlyUSD.toFixed(2)}/mo saved vs naive (800 interactions)           \u2551`);
+  }
+  lines.push(`  \u2551                                                              \u2551`);
+  lines.push(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`);
+  lines.push("");
+  return lines.join("\n");
+}
+function pad(s, w) {
+  return s.padEnd(w).substring(0, w);
+}
+function fmt(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+}
+
+// src/cli/score.ts
+async function main() {
+  const args = process.argv.slice(2);
+  const jsonMode = args.includes("--json");
+  const benchmarkMode = args.includes("--benchmark");
+  const helpMode = args.includes("--help") || args.includes("-h");
+  const pathArg = args.find((a) => !a.startsWith("--") && !a.startsWith("-"));
+  const projectPath = resolve4(pathArg ?? ".");
+  if (helpMode) {
+    console.log(`
+  \u26A1 cto-score \u2014 How AI-ready is your codebase?
+
+  Usage:
+    npx cto-score              Scan current directory
+    npx cto-score ./path       Scan a specific project
+    npx cto-score --benchmark  Include CTO vs naive vs random comparison
+    npx cto-score --json       Output as JSON (for CI/scripts)
+
+  What it does:
+    Analyzes your project's structure, dependencies, and risk profile.
+    Gives you a single 0-100 score showing how efficiently AI tools
+    can work with your codebase.
+
+  No data leaves your machine. No API keys needed. MIT licensed.
+  Learn more: https://github.com/cto-ai/cto-ai-cli
+`);
+    process.exit(0);
+  }
+  console.log("");
+  console.log("  \u26A1 cto-score \u2014 analyzing your project...");
+  console.log("");
+  try {
+    const startTime = Date.now();
+    const analysis = await analyzeProject(projectPath);
+    const score = await computeContextScore(analysis);
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    if (jsonMode) {
+      console.log(JSON.stringify({
+        project: analysis.projectName,
+        files: analysis.totalFiles,
+        tokens: analysis.totalTokens,
+        score: score.overall,
+        grade: score.grade,
+        dimensions: {
+          efficiency: score.dimensions.efficiency.score,
+          coverage: score.dimensions.coverage.score,
+          riskControl: score.dimensions.riskControl.score,
+          structure: score.dimensions.structure.score,
+          governance: score.dimensions.governance.score
+        },
+        savings: {
+          percent: score.comparison.savedPercent,
+          monthlyUSD: score.comparison.monthlySavingsUSD,
+          tokensOptimized: score.comparison.optimizedTokens,
+          tokensNaive: score.comparison.naiveTokens
+        }
+      }, null, 2));
+      process.exit(0);
+    }
+    console.log(renderContextScore(score));
+    if (benchmarkMode) {
+      const benchmark = await runBenchmark(analysis);
+      console.log(renderBenchmark(benchmark));
+    }
+    console.log("");
+    console.log(`  Scanned in ${elapsed}s \xB7 ${analysis.totalFiles} files \xB7 ${Math.round(analysis.totalTokens / 1e3)}K tokens`);
+    console.log("");
+    console.log("  What does this mean?");
+    console.log(`    Your project scores ${score.overall}/100 (${score.grade}) for AI context efficiency.`);
+    if (score.overall >= 80) {
+      console.log("    \u2705 Great! AI tools can work effectively with your codebase.");
+    } else if (score.overall >= 60) {
+      console.log("    \u{1F7E1} Good, but there's room to improve. Run with --benchmark for details.");
+    } else {
+      console.log("    \u{1F534} AI tools are likely wasting tokens on your project. Run with --benchmark.");
+    }
+    console.log("");
+    console.log("  Next steps:");
+    console.log("    npx cto-score --benchmark    See CTO vs naive comparison");
+    console.log("    npm i -g cto-ai-cli          Install for full CLI + MCP server");
+    console.log("    https://github.com/cto-ai/cto-ai-cli   Full docs");
+    console.log("");
+  } catch (err) {
+    console.error(`  \u274C Error: ${err.message}`);
+    console.error("");
+    console.error("  Make sure you're running this in a project directory with source files.");
+    console.error("  Supported: TypeScript, JavaScript, Python, Go, Rust, Java, C/C++");
+    process.exit(1);
+  }
+}
+main();