cto-ai-cli 4.0.0 → 5.1.0

package/dist/engine/index.js

@@ -610,8 +610,8 @@ async function analyzeProject(projectPath, config) {
     maxDepth: mergedConfig.analysis.maxDepth
   });
   const tokenMethod = mergedConfig.tokens.method;
-  const files = [];
-  for (const entry of walkEntries) {
+  const BATCH_SIZE = 50;
+  async function estimateFileTokens2(entry) {
     let tokens;
     if (tokenMethod === "tiktoken") {
       try {
@@ -623,7 +623,7 @@ async function analyzeProject(projectPath, config) {
     } else {
       tokens = countTokensChars4(entry.size);
     }
-    files.push({
+    return {
       path: entry.path,
       relativePath: entry.relativePath,
       extension: entry.extension,
@@ -632,16 +632,20 @@ async function analyzeProject(projectPath, config) {
       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 files = [];
+  for (let i = 0; i < walkEntries.length; i += BATCH_SIZE) {
+    const batch = walkEntries.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(batch.map(estimateFileTokens2));
+    files.push(...results);
   }
   const graph = buildProjectGraph(absPath, files);
   for (const file of files) {
@@ -1565,10 +1569,7 @@ function deduplicateFindings(findings) {
 }
 
 // src/engine/pruner.ts
-import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 import { readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs"]);
 async function pruneFile(file, level) {
   if (level === "excluded") {
@@ -1600,23 +1601,7 @@ async function pruneTypeScript(file, level) {
   } catch {
     return emptyResult2(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 prunedContent = level === "signatures" ? extractSignaturesRegex(content) : extractSkeletonRegex(content);
   const prunedTokens = countTokensChars4(Buffer.byteLength(prunedContent, "utf-8"));
   const savingsPercent = file.tokens > 0 ? (file.tokens - prunedTokens) / file.tokens * 100 : 0;
   return {
@@ -1628,131 +1613,281 @@ async function pruneTypeScript(file, level) {
     savingsPercent: Math.max(0, savingsPercent)
   };
 }
-function extractSignaturesAST(sf) {
+function extractSignaturesRegex(content) {
+  const lines = content.split("\n");
   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());
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith("/**")) {
+      const docLines = [];
+      while (i < lines.length) {
+        docLines.push(lines[i]);
+        if (lines[i].includes("*/")) {
+          i++;
+          break;
+        }
+        i++;
       }
+      parts.push(docLines.join("\n"));
+      continue;
+    }
+    if (trimmed.startsWith("//")) {
+      parts.push(line);
+      i++;
+      continue;
+    }
+    if (/^\s*(import|export)\s/.test(line) && (trimmed.includes(" from ") || trimmed.startsWith("import "))) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*export\s*(\{|\*)/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?type\s+\w/.test(trimmed) && !trimmed.startsWith("typeof")) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?interface\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?(const\s+)?enum\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    const fnMatch = trimmed.match(/^(export\s+)?(async\s+)?function\s+(\w+)/);
+    if (fnMatch) {
+      const sig = extractFnSignature(lines, i);
+      parts.push(`${sig} { /* ... */ }`);
+      i = skipBlock(lines, i);
+      continue;
+    }
+    const arrowMatch = trimmed.match(/^(export\s+)?(const|let|var)\s+(\w+)/);
+    if (arrowMatch && looksLikeFunctionDecl(lines, i)) {
+      const prefix = trimmed.match(/^((?:export\s+)?(?:const|let|var)\s+\w+[^=]*=)/)?.[1];
+      if (prefix) {
+        parts.push(`${prefix} /* ... */;`);
+      }
+      i = skipBlock(lines, i);
+      continue;
     }
-  }
-  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());
+    if (arrowMatch) {
+      const block = collectStatement(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?(abstract\s+)?class\s+\w/.test(trimmed)) {
+      const classOutline = extractClassOutline(lines, i);
+      parts.push(classOutline.text);
+      i = classOutline.nextIndex;
+      continue;
+    }
+    i++;
   }
   return parts.join("\n");
 }
-function extractSkeletonAST(sf) {
+function extractSkeletonRegex(content) {
+  const lines = content.split("\n");
   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());
+  let i = 0;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (/^import\s/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(type|interface)\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(const\s+)?enum\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(async\s+)?function\s+\w/.test(trimmed)) {
+      const sig = extractFnSignature(lines, i);
+      parts.push(`${sig};`);
+      i = skipBlock(lines, i);
+      continue;
+    }
+    if (/^export\s+(abstract\s+)?class\s+/.test(trimmed)) {
+      const nameMatch = trimmed.match(/class\s+(\w+)/);
+      const name = nameMatch?.[1] ?? "Unknown";
+      const end = skipBlock(lines, i);
+      const methods = [];
+      for (let j = i + 1; j < end; j++) {
+        const mt = lines[j].trim();
+        const mm = mt.match(/^(?:static\s+)?(?:async\s+)?(\w+)\s*\(/);
+        if (mm && mm[1] !== "constructor") methods.push(mm[1]);
+      }
+      parts.push(`export class ${name} { /* methods: ${methods.join(", ")} */ }`);
+      i = end;
+      continue;
+    }
+    if (/^export\s*(\{|\*)/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    i++;
   }
   return parts.join("\n");
 }
+function collectBracedLine(lines, start) {
+  let text = lines[start];
+  let i = start + 1;
+  while (i < lines.length && !text.includes(";") && !text.trimEnd().endsWith("'") && !text.trimEnd().endsWith('"')) {
+    text += "\n" + lines[i];
+    i++;
+  }
+  return { text, nextIndex: i };
+}
+function collectBalanced(lines, start) {
+  let depth = 0;
+  let text = "";
+  let i = start;
+  let started = false;
+  while (i < lines.length) {
+    const line = lines[i];
+    text += (text ? "\n" : "") + line;
+    for (const ch of line) {
+      if (ch === "{" || ch === "(") {
+        depth++;
+        started = true;
+      }
+      if (ch === "}" || ch === ")") depth--;
+    }
+    i++;
+    if (started && depth <= 0) break;
+    if (!started && line.includes(";")) break;
+  }
+  return { text, nextIndex: i };
+}
+function collectStatement(lines, start) {
+  let text = lines[start];
+  let i = start + 1;
+  if (text.includes(";")) return { text, nextIndex: i };
+  let depth = 0;
+  for (const ch of text) {
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    if (ch === "}" || ch === ")" || ch === "]") depth--;
+  }
+  while (i < lines.length && depth > 0) {
+    text += "\n" + lines[i];
+    for (const ch of lines[i]) {
+      if (ch === "{" || ch === "(" || ch === "[") depth++;
+      if (ch === "}" || ch === ")" || ch === "]") depth--;
+    }
+    i++;
+  }
+  return { text, nextIndex: i };
+}
+function extractFnSignature(lines, start) {
+  let sig = "";
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    sig += (sig ? " " : "") + line;
+    if (line.includes("{")) {
+      sig = sig.replace(/\s*\{[^]*$/, "").trim();
+      break;
+    }
+    i++;
+  }
+  return sig;
+}
+function skipBlock(lines, start) {
+  let depth = 0;
+  let i = start;
+  let foundBrace = false;
+  while (i < lines.length) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundBrace = true;
+      }
+      if (ch === "}") depth--;
+    }
+    i++;
+    if (foundBrace && depth <= 0) break;
+    if (!foundBrace && lines[i - 1].includes(";")) break;
+  }
+  return i;
+}
+function looksLikeFunctionDecl(lines, start) {
+  const chunk = lines.slice(start, Math.min(start + 5, lines.length)).join(" ");
+  return /=>/.test(chunk) || /=\s*function/.test(chunk);
+}
+function extractClassOutline(lines, start) {
+  const header = lines[start].trim();
+  let headerText = header;
+  let i = start + 1;
+  if (!header.includes("{")) {
+    while (i < lines.length) {
+      headerText += " " + lines[i].trim();
+      if (lines[i].includes("{")) {
+        i++;
+        break;
+      }
+      i++;
+    }
+  } else {
+    i = start + 1;
+  }
+  const bodyParts = [headerText.replace(/\{[^]*$/, "{").trim()];
+  let depth = 1;
+  while (i < lines.length && depth > 0) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    for (const ch of line) {
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+    }
+    if (depth <= 0) {
+      i++;
+      break;
+    }
+    if (depth === 1) {
+      if (/^(private|protected|public|readonly|static|#)/.test(trimmed) && !trimmed.includes("(")) {
+        bodyParts.push(`  ${trimmed}`);
+      } else if (/^constructor\s*\(/.test(trimmed)) {
+        const sig = extractFnSignature(lines, i);
+        bodyParts.push(`  ${sig} { /* ... */ }`);
+      } else if (/^(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\w+\s*[(<]/.test(trimmed) && !trimmed.startsWith("//")) {
+        const sig = extractFnSignature(lines, i);
+        bodyParts.push(`  ${sig} { /* ... */ }`);
+      }
+    }
+    i++;
+  }
+  bodyParts.push("}");
+  return { text: bodyParts.join("\n"), nextIndex: i };
+}
 async function pruneGeneric(file, level) {
   let content;
   try {
@@ -1813,22 +1948,6 @@ function emptyResult2(file, level) {
     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 = join6(dir, "..");
-    const candidate = join6(dir, "tsconfig.json");
-    if (existsSync4(candidate)) return candidate;
-  }
-  return void 0;
-}
 
 // src/engine/coverage.ts
 function calculateCoverage(targetPaths, includedPaths, allFiles, graph, depth = 2) {
@@ -3252,7 +3371,7 @@ function fmt2(n) {
 }
 
 // src/engine/predictor.ts
-import { resolve as resolve8, join as join7 } from "path";
+import { resolve as resolve8, join as join6 } from "path";
 import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 var DEFAULT_PREDICTOR_CONFIG = {
   maxCoSelectionPairs: 500,
@@ -3262,9 +3381,9 @@ var DEFAULT_PREDICTOR_CONFIG = {
   // need at least 2 observations before predicting
 };
 async function getModelPath(projectPath) {
-  const ctoDir = join7(resolve8(projectPath), ".cto");
+  const ctoDir = join6(resolve8(projectPath), ".cto");
   await mkdir2(ctoDir, { recursive: true });
-  return join7(ctoDir, "predictor.json");
+  return join6(ctoDir, "predictor.json");
 }
 async function loadModel(projectPath) {
   try {
@@ -3514,7 +3633,7 @@ function pruneCoSelection(model, maxPairs) {
 }
 
 // src/engine/cross-repo.ts
-import { join as join8, basename as basename3 } from "path";
+import { join as join7, basename as basename3 } from "path";
 import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
 function computeFingerprint2(analysis) {
   const totalFiles = analysis.totalFiles;
@@ -3547,7 +3666,7 @@ function fingerprintHash(fp) {
 }
 function getGlobalModelPath() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
-  return join8(home, ".cto", "global-intelligence.json");
+  return join7(home, ".cto", "global-intelligence.json");
 }
 async function loadGlobalModel() {
   try {
@@ -3558,7 +3677,7 @@ async function loadGlobalModel() {
   }
 }
 async function saveGlobalModel(model) {
-  const dir = join8(getGlobalModelPath(), "..");
+  const dir = join7(getGlobalModelPath(), "..");
   await mkdir3(dir, { recursive: true });
   await writeFile4(getGlobalModelPath(), JSON.stringify(model, null, 2));
 }
@@ -3779,17 +3898,17 @@ function getCrossRepoStats(model) {
 }
 
 // src/engine/feedback.ts
-import { resolve as resolve10, join as join9 } from "path";
+import { resolve as resolve10, join as join8 } from "path";
 import { readFile as readFile9, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
 async function getFeedbackPath(projectPath) {
-  const ctoDir = join9(resolve10(projectPath), ".cto");
+  const ctoDir = join8(resolve10(projectPath), ".cto");
   await mkdir4(ctoDir, { recursive: true });
-  return join9(ctoDir, "feedback.json");
+  return join8(ctoDir, "feedback.json");
 }
 async function getModelPath2(projectPath) {
-  const ctoDir = join9(resolve10(projectPath), ".cto");
+  const ctoDir = join8(resolve10(projectPath), ".cto");
   await mkdir4(ctoDir, { recursive: true });
-  return join9(ctoDir, "feedback-model.json");
+  return join8(ctoDir, "feedback-model.json");
 }
 async function loadFeedback(projectPath) {
   try {
@@ -3815,16 +3934,30 @@ async function saveFeedbackModel(projectPath, model) {
 }
 function createEmptyModel3() {
   return {
-    version: 1,
+    version: 2,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     totalFeedback: 0,
     acceptRate: 0,
     fileAcceptance: {},
     taskTypeAcceptance: {},
     pairAcceptance: {},
+    sessions: {},
+    strategyComparison: {},
     insights: []
   };
 }
+var EWMA_ALPHA = 0.15;
+function ewmaUpdate(prev, newValue, alpha = EWMA_ALPHA) {
+  return alpha * newValue + (1 - alpha) * prev;
+}
+function wilsonLowerBound(successes, total, z = 1.96) {
+  if (total === 0) return 0;
+  const phat = successes / total;
+  const denom = 1 + z * z / total;
+  const center = phat + z * z / (2 * total);
+  const spread = z * Math.sqrt((phat * (1 - phat) + z * z / (4 * total)) / total);
+  return Math.max(0, (center - spread) / denom);
+}
 async function recordFeedback(projectPath, entry) {
   const entries = await loadFeedback(projectPath);
   const fullEntry = {
@@ -3853,13 +3986,20 @@ function rebuildModel(entries) {
           includedCount: 0,
           acceptedCount: 0,
           acceptRate: 0,
-          avgTimeToAccept: 0
+          ewmaAcceptRate: 0.5,
+          // prior: 50%
+          avgTimeToAccept: 0,
+          lastSeen: entry.timestamp,
+          bayesianLower: 0
         };
       }
       const fa = model.fileAcceptance[file];
       fa.includedCount++;
       if (accepted) fa.acceptedCount++;
       fa.acceptRate = fa.acceptedCount / fa.includedCount;
+      fa.ewmaAcceptRate = ewmaUpdate(fa.ewmaAcceptRate, accepted ? 1 : 0);
+      fa.bayesianLower = wilsonLowerBound(fa.acceptedCount, fa.includedCount);
+      fa.lastSeen = entry.timestamp;
       if (entry.outcome.timeToAcceptMs) {
         fa.avgTimeToAccept = (fa.avgTimeToAccept * (fa.includedCount - 1) + entry.outcome.timeToAcceptMs) / fa.includedCount;
       }
@@ -3870,13 +4010,15 @@ function rebuildModel(entries) {
         totalCount: 0,
         acceptedCount: 0,
         acceptRate: 0,
-        avgCompilable: 0
+        avgCompilable: 0,
+        ewmaAcceptRate: 0.5
       };
     }
     const tta = model.taskTypeAcceptance[tt];
     tta.totalCount++;
     if (accepted) tta.acceptedCount++;
     tta.acceptRate = tta.acceptedCount / tta.totalCount;
+    tta.ewmaAcceptRate = ewmaUpdate(tta.ewmaAcceptRate, accepted ? 1 : 0);
     if (entry.outcome.compilable !== void 0) {
       tta.avgCompilable = (tta.avgCompilable * (tta.totalCount - 1) + (entry.outcome.compilable ? 1 : 0)) / tta.totalCount;
     }
@@ -3893,6 +4035,36 @@ function rebuildModel(entries) {
         pa.acceptRate = pa.acceptedCount / pa.count;
       }
     }
+    if (entry.sessionId) {
+      if (!model.sessions[entry.sessionId]) {
+        model.sessions[entry.sessionId] = {
+          strategy: entry.strategy ?? "default",
+          entries: 0,
+          acceptRate: 0
+        };
+      }
+      const sess = model.sessions[entry.sessionId];
+      sess.entries++;
+      const sessionEntries = entries.filter((e) => e.sessionId === entry.sessionId);
+      const sessionAccepted = sessionEntries.filter((e) => e.outcome.accepted).length;
+      sess.acceptRate = sessionEntries.length > 0 ? sessionAccepted / sessionEntries.length : 0;
+    }
+    const strat = entry.strategy ?? "default";
+    if (!model.strategyComparison[strat]) {
+      model.strategyComparison[strat] = {
+        totalCount: 0,
+        acceptedCount: 0,
+        acceptRate: 0,
+        avgTimeToAccept: 0
+      };
+    }
+    const sc = model.strategyComparison[strat];
+    sc.totalCount++;
+    if (accepted) sc.acceptedCount++;
+    sc.acceptRate = sc.acceptedCount / sc.totalCount;
+    if (entry.outcome.timeToAcceptMs) {
+      sc.avgTimeToAccept = (sc.avgTimeToAccept * (sc.totalCount - 1) + entry.outcome.timeToAcceptMs) / sc.totalCount;
+    }
   }
   model.acceptRate = entries.length > 0 ? acceptedTotal / entries.length : 0;
   model.insights = generateInsights(model);
@@ -3900,43 +4072,64 @@ function rebuildModel(entries) {
 }
 function generateInsights(model) {
   const insights = [];
-  const highAccept = Object.entries(model.fileAcceptance).filter(([_, fa]) => fa.includedCount >= 3 && fa.acceptRate >= 0.8).sort((a, b) => b[1].acceptRate - a[1].acceptRate).slice(0, 5);
+  const highAccept = Object.entries(model.fileAcceptance).filter(([_, fa]) => fa.includedCount >= 3 && fa.bayesianLower >= 0.5).sort((a, b) => b[1].bayesianLower - a[1].bayesianLower).slice(0, 5);
   for (const [file, fa] of highAccept) {
     insights.push({
       type: "positive",
       title: `${file} consistently leads to accepted output`,
-      detail: `${Math.round(fa.acceptRate * 100)}% accept rate over ${fa.includedCount} selections`,
-      impact: Math.round(fa.acceptRate * fa.includedCount)
+      detail: `${Math.round(fa.acceptRate * 100)}% accept rate (${fa.acceptedCount}/${fa.includedCount}), Bayesian lower: ${Math.round(fa.bayesianLower * 100)}%, EWMA: ${Math.round(fa.ewmaAcceptRate * 100)}%`,
+      impact: Math.round(fa.bayesianLower * fa.includedCount * 10)
     });
   }
-  const lowAccept = Object.entries(model.fileAcceptance).filter(([_, fa]) => fa.includedCount >= 3 && fa.acceptRate < 0.3).sort((a, b) => a[1].acceptRate - b[1].acceptRate).slice(0, 5);
+  const lowAccept = Object.entries(model.fileAcceptance).filter(([_, fa]) => fa.includedCount >= 3 && fa.acceptRate < 0.3).sort((a, b) => a[1].ewmaAcceptRate - b[1].ewmaAcceptRate).slice(0, 5);
   for (const [file, fa] of lowAccept) {
     insights.push({
       type: "negative",
       title: `${file} often included but output rejected`,
-      detail: `Only ${Math.round(fa.acceptRate * 100)}% accept rate \u2014 may be adding noise`,
-      impact: Math.round((1 - fa.acceptRate) * fa.includedCount * 2)
+      detail: `Only ${Math.round(fa.acceptRate * 100)}% accept rate \u2014 EWMA trending ${Math.round(fa.ewmaAcceptRate * 100)}%`,
+      impact: Math.round((1 - fa.bayesianLower) * fa.includedCount * 5)
     });
   }
-  const bestTasks = Object.entries(model.taskTypeAcceptance).filter(([_, ta]) => ta.totalCount >= 2).sort((a, b) => b[1].acceptRate - a[1].acceptRate);
+  const bestTasks = Object.entries(model.taskTypeAcceptance).filter(([_, ta]) => ta.totalCount >= 2).sort((a, b) => b[1].ewmaAcceptRate - a[1].ewmaAcceptRate);
   for (const [taskType, ta] of bestTasks.slice(0, 3)) {
+    const trending = ta.ewmaAcceptRate > ta.acceptRate ? "improving" : ta.ewmaAcceptRate < ta.acceptRate - 0.05 ? "declining" : "stable";
     insights.push({
       type: ta.acceptRate >= 0.7 ? "positive" : "opportunity",
-      title: `${taskType} tasks: ${Math.round(ta.acceptRate * 100)}% acceptance`,
-      detail: `${ta.acceptedCount}/${ta.totalCount} accepted, ${Math.round(ta.avgCompilable * 100)}% compilable`,
-      impact: Math.round(ta.acceptRate * ta.totalCount * 3)
+      title: `${taskType} tasks: ${Math.round(ta.acceptRate * 100)}% acceptance (${trending})`,
+      detail: `${ta.acceptedCount}/${ta.totalCount} accepted, ${Math.round(ta.avgCompilable * 100)}% compilable, EWMA: ${Math.round(ta.ewmaAcceptRate * 100)}%`,
+      impact: Math.round(ta.ewmaAcceptRate * ta.totalCount * 3)
     });
   }
-  const powerPairs = Object.entries(model.pairAcceptance).filter(([_, pa]) => pa.count >= 3 && pa.acceptRate >= 0.9).sort((a, b) => b[1].acceptRate * b[1].count - a[1].acceptRate * a[1].count).slice(0, 3);
+  const powerPairs = Object.entries(model.pairAcceptance).filter(([_, pa]) => pa.count >= 4 && pa.acceptRate >= 0.85).sort((a, b) => {
+    const aWilson = wilsonLowerBound(a[1].acceptedCount, a[1].count);
+    const bWilson = wilsonLowerBound(b[1].acceptedCount, b[1].count);
+    return bWilson - aWilson;
+  }).slice(0, 3);
   for (const [pair, pa] of powerPairs) {
     const [a, b] = pair.split("|");
+    const wilson = wilsonLowerBound(pa.acceptedCount, pa.count);
     insights.push({
       type: "positive",
       title: `Power pair: ${a} + ${b}`,
-      detail: `${Math.round(pa.acceptRate * 100)}% acceptance when both included (${pa.count} times)`,
-      impact: Math.round(pa.acceptRate * pa.count * 5)
+      detail: `${Math.round(pa.acceptRate * 100)}% acceptance (${pa.count}x), confidence: ${Math.round(wilson * 100)}%`,
+      impact: Math.round(wilson * pa.count * 5)
     });
   }
+  const strategies = Object.entries(model.strategyComparison).filter(([_, sc]) => sc.totalCount >= 3);
+  if (strategies.length >= 2) {
+    strategies.sort((a, b) => b[1].acceptRate - a[1].acceptRate);
+    const best = strategies[0];
+    const worst = strategies[strategies.length - 1];
+    const diff = best[1].acceptRate - worst[1].acceptRate;
+    if (diff > 0.1) {
+      insights.push({
+        type: "opportunity",
+        title: `Strategy "${best[0]}" outperforms "${worst[0]}" by ${Math.round(diff * 100)}%`,
+        detail: `${best[0]}: ${Math.round(best[1].acceptRate * 100)}% (n=${best[1].totalCount}) vs ${worst[0]}: ${Math.round(worst[1].acceptRate * 100)}% (n=${worst[1].totalCount})`,
+        impact: Math.round(diff * 50)
+      });
+    }
+  }
   return insights.sort((a, b) => b.impact - a.impact);
 }
 async function getFeedbackBoosts(projectPath, task) {
@@ -3946,18 +4139,19 @@ async function getFeedbackBoosts(projectPath, task) {
   const taskType = classifyTask(task);
   for (const [file, fa] of Object.entries(model.fileAcceptance)) {
     if (fa.includedCount < 2) continue;
-    if (fa.acceptRate >= 0.7) {
-      boosts.set(file, (boosts.get(file) ?? 0) + fa.acceptRate * 5);
+    if (fa.bayesianLower >= 0.5) {
+      const boost = fa.ewmaAcceptRate * 5 * Math.min(1, fa.includedCount / 5);
+      boosts.set(file, (boosts.get(file) ?? 0) + boost);
     }
-    if (fa.acceptRate < 0.2 && fa.includedCount >= 3) {
-      boosts.set(file, (boosts.get(file) ?? 0) - 3);
+    if (fa.acceptRate < 0.2 && fa.includedCount >= 4) {
+      boosts.set(file, (boosts.get(file) ?? 0) - 3 * (1 - fa.bayesianLower));
     }
   }
   const tta = model.taskTypeAcceptance[taskType];
   if (tta && tta.totalCount >= 2) {
     if (tta.avgCompilable >= 0.8) {
       for (const [file, fa] of Object.entries(model.fileAcceptance)) {
-        if (fa.acceptRate >= 0.8) {
+        if (fa.bayesianLower >= 0.6) {
           boosts.set(file, (boosts.get(file) ?? 0) + 1);
         }
       }
@@ -3965,6 +4159,53 @@ async function getFeedbackBoosts(projectPath, task) {
   }
   return boosts;
 }
+async function exportFeedbackForTeam(projectPath, projectName) {
+  const model = await loadFeedbackModel(projectPath);
+  const entries = await loadFeedback(projectPath);
+  return {
+    version: 2,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectName,
+    model,
+    entrySummary: {
+      total: entries.length,
+      accepted: entries.filter((e) => e.outcome.accepted).length,
+      sessions: new Set(entries.map((e) => e.sessionId).filter(Boolean)).size
+    }
+  };
+}
+async function importTeamFeedback(projectPath, teamExport) {
+  const localModel = await loadFeedbackModel(projectPath);
+  for (const [file, fa] of Object.entries(teamExport.model.fileAcceptance)) {
+    const local = localModel.fileAcceptance[file];
+    if (!local) {
+      localModel.fileAcceptance[file] = {
+        ...fa,
+        includedCount: Math.max(1, Math.round(fa.includedCount * 0.5)),
+        acceptedCount: Math.max(0, Math.round(fa.acceptedCount * 0.5)),
+        ewmaAcceptRate: fa.ewmaAcceptRate * 0.7 + 0.5 * 0.3,
+        // blend with prior
+        bayesianLower: wilsonLowerBound(
+          Math.round(fa.acceptedCount * 0.5),
+          Math.max(1, Math.round(fa.includedCount * 0.5))
+        )
+      };
+    } else {
+      const totalLocal = local.includedCount;
+      const totalTeam = fa.includedCount;
+      const combinedCount = totalLocal + Math.round(totalTeam * 0.3);
+      const combinedAccepted = local.acceptedCount + Math.round(fa.acceptedCount * 0.3);
+      local.includedCount = combinedCount;
+      local.acceptedCount = combinedAccepted;
+      local.acceptRate = combinedCount > 0 ? combinedAccepted / combinedCount : 0;
+      local.ewmaAcceptRate = local.ewmaAcceptRate * 0.7 + fa.ewmaAcceptRate * 0.3;
+      local.bayesianLower = wilsonLowerBound(combinedAccepted, combinedCount);
+    }
+  }
+  localModel.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveFeedbackModel(projectPath, localModel);
+  return localModel;
+}
 function renderFeedbackReport(model) {
   const lines = [];
   lines.push("");
@@ -3991,6 +4232,28 @@ function renderFeedbackReport(model) {
 function pad3(s, w) {
   return s.padEnd(w).substring(0, w);
 }
+function renderCrossRepoReport(stats) {
+  const lines = [];
+  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        \u{1F310} Cross-Repo Intelligence                \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  Projects learned:    ${pad3(stats.totalProjects.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Total observations:  ${pad3(stats.totalObservations.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Archetypes:          ${pad3(stats.archetypes.length.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Universal patterns:  ${pad3(stats.universalPatterns.toString(), 8)}                   \u2551`);
+  lines.push("  \u2551                                                  \u2551");
+  if (stats.archetypes.length > 0) {
+    lines.push("  \u2551  Archetypes:                                     \u2551");
+    for (const a of stats.archetypes.slice(0, 5)) {
+      lines.push(`  \u2551    ${pad3(a.name, 24)} ${pad3(a.observations + " obs", 12)}     \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");
+  return lines.join("\n");
+}
 
 // src/engine/semantic.ts
 var DOMAIN_SIGNALS = {
@@ -4486,7 +4749,7 @@ function fmt3(n) {
 }
 
 // src/engine/compile-proof.ts
-import { resolve as resolve11, join as join10, dirname as dirname3, basename as basename4 } from "path";
+import { resolve as resolve11, join as join9, dirname as dirname3, basename as basename4 } from "path";
 import { writeFile as writeFile6, mkdir as mkdir5, rm, cp } from "fs/promises";
 import { execSync } from "child_process";
 async function runCompileProof(analysis, task, budget = 5e4) {
@@ -4688,21 +4951,21 @@ function extractKnownTypes(analysis, typePaths) {
   return types;
 }
 async function runTscWithContext(name, projectPath, selectedPaths, tokensUsed, typePaths, consumerCode) {
-  const tmpDir = join10(projectPath, ".cto", `compile-proof-${name.toLowerCase()}`);
+  const tmpDir = join9(projectPath, ".cto", `compile-proof-${name.toLowerCase()}`);
   try {
     await rm(tmpDir, { recursive: true, force: true });
     await mkdir5(tmpDir, { recursive: true });
     for (const filePath of selectedPaths) {
-      const src = join10(projectPath, filePath);
-      const dest = join10(tmpDir, filePath);
+      const src = join9(projectPath, filePath);
+      const dest = join9(tmpDir, filePath);
       try {
         await mkdir5(dirname3(dest), { recursive: true });
         await cp(src, dest);
       } catch {
       }
     }
-    await writeFile6(join10(tmpDir, "_compile_test.ts"), consumerCode);
-    await writeFile6(join10(tmpDir, "tsconfig.json"), JSON.stringify({
+    await writeFile6(join9(tmpDir, "_compile_test.ts"), consumerCode);
+    await writeFile6(join9(tmpDir, "tsconfig.json"), JSON.stringify({
       compilerOptions: {
         target: "ES2022",
         module: "nodenext",
@@ -4724,7 +4987,8 @@ async function runTscWithContext(name, projectPath, selectedPaths, tokensUsed, t
         env: { ...process.env, NODE_ENV: "production" }
       });
     } catch (err) {
-      tscOutput = err.stdout ?? err.message ?? "";
+      const e = err;
+      tscOutput = e.stdout ?? (err instanceof Error ? err.message : "") ?? "";
     }
     const errorLines = tscOutput.split("\n").filter((l) => l.includes("error TS")).map((l) => l.trim());
     compileErrors = errorLines.length;
@@ -5008,10 +5272,87 @@ function fmt5(n) {
   return n.toString();
 }
 
+// src/engine/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var currentLevel = process.env.CTO_LOG_LEVEL ?? "warn";
+var jsonOutput = process.env.CTO_LOG_JSON === "1";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setJsonLogging(enabled) {
+  jsonOutput = enabled;
+}
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+function emit(entry) {
+  if (!shouldLog(entry.level)) return;
+  if (jsonOutput) {
+    const stream = entry.level === "error" ? process.stderr : process.stdout;
+    stream.write(JSON.stringify(entry) + "\n");
+    return;
+  }
+  const prefix = entry.module ? `[${entry.module}]` : "";
+  const extra = Object.entries(entry).filter(([k]) => !["level", "msg", "ts", "module"].includes(k)).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+  const line = `${prefix} ${entry.msg}${extra ? " " + extra : ""}`.trim();
+  if (entry.level === "error") {
+    process.stderr.write(`  \u274C ${line}
+`);
+  } else if (entry.level === "warn") {
+    process.stderr.write(`  \u26A0\uFE0F  ${line}
+`);
+  } else {
+    process.stdout.write(`  ${line}
+`);
+  }
+}
+function createLogger(module) {
+  const log = (level, msg, data) => {
+    emit({ level, msg, ts: (/* @__PURE__ */ new Date()).toISOString(), module, ...data });
+  };
+  return {
+    debug: (msg, data) => log("debug", msg, data),
+    info: (msg, data) => log("info", msg, data),
+    warn: (msg, data) => log("warn", msg, data),
+    error: (msg, data) => log("error", msg, data)
+  };
+}
+
+// src/engine/errors.ts
+var CtoError = class extends Error {
+  code;
+  module;
+  context;
+  constructor(code, message, module, context) {
+    super(message);
+    this.name = "CtoError";
+    this.code = code;
+    this.module = module;
+    this.context = context;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      module: this.module,
+      context: this.context
+    };
+  }
+};
+function isCtoError(err) {
+  return err instanceof CtoError;
+}
+function wrapError(err, code, module, context) {
+  if (isCtoError(err)) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new CtoError(code, message, module, context);
+}
+
 // src/engine/monorepo.ts
 import { readFile as readFile11, readdir as readdir4 } from "fs/promises";
-import { join as join11, relative as relative6, basename as basename5 } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { join as join10, relative as relative6, basename as basename5 } from "path";
+import { existsSync as existsSync4 } from "fs";
 async function detectMonorepoTool(rootPath) {
   const checks = [
     { file: "nx.json", tool: "nx" },
@@ -5032,14 +5373,14 @@ async function detectMonorepoTool(rootPath) {
     }
   ];
   for (const check of checks) {
-    const filePath = join11(rootPath, check.file);
-    if (existsSync5(filePath)) {
+    const filePath = join10(rootPath, check.file);
+    if (existsSync4(filePath)) {
       if (!check.validate) return check.tool;
       try {
         const content = await readFile11(filePath, "utf-8");
         if (check.validate(content)) {
           if (check.tool === "npm-workspaces") {
-            if (existsSync5(join11(rootPath, "yarn.lock"))) return "yarn-workspaces";
+            if (existsSync4(join10(rootPath, "yarn.lock"))) return "yarn-workspaces";
             return "npm-workspaces";
           }
           return check.tool;
@@ -5054,15 +5395,15 @@ async function resolveWorkspaceGlobs(rootPath, globs) {
   const packagePaths = [];
   for (const glob of globs) {
     const cleanGlob = glob.replace(/\/?\*\*?$/, "");
-    const searchDir = join11(rootPath, cleanGlob);
-    if (!existsSync5(searchDir)) continue;
+    const searchDir = join10(rootPath, cleanGlob);
+    if (!existsSync4(searchDir)) continue;
     try {
       const entries = await readdir4(searchDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const pkgJsonPath = join11(searchDir, entry.name, "package.json");
-        if (existsSync5(pkgJsonPath)) {
-          packagePaths.push(join11(searchDir, entry.name));
+        const pkgJsonPath = join10(searchDir, entry.name, "package.json");
+        if (existsSync4(pkgJsonPath)) {
+          packagePaths.push(join10(searchDir, entry.name));
         }
       }
     } catch {
@@ -5074,12 +5415,12 @@ async function discoverPackages(rootPath, tool) {
   switch (tool) {
     case "npm-workspaces":
     case "yarn-workspaces": {
-      const pkgJson = JSON.parse(await readFile11(join11(rootPath, "package.json"), "utf-8"));
+      const pkgJson = JSON.parse(await readFile11(join10(rootPath, "package.json"), "utf-8"));
       const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces?.packages || [];
       return resolveWorkspaceGlobs(rootPath, workspaces);
     }
     case "pnpm-workspaces": {
-      const content = await readFile11(join11(rootPath, "pnpm-workspace.yaml"), "utf-8");
+      const content = await readFile11(join10(rootPath, "pnpm-workspace.yaml"), "utf-8");
       const packages = [];
       let inPackages = false;
       for (const line of content.split("\n")) {
@@ -5097,20 +5438,20 @@ async function discoverPackages(rootPath, tool) {
       return resolveWorkspaceGlobs(rootPath, packages);
     }
     case "turborepo": {
-      const pkgJson = JSON.parse(await readFile11(join11(rootPath, "package.json"), "utf-8"));
+      const pkgJson = JSON.parse(await readFile11(join10(rootPath, "package.json"), "utf-8"));
       const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces?.packages || [];
       if (workspaces.length > 0) return resolveWorkspaceGlobs(rootPath, workspaces);
-      if (existsSync5(join11(rootPath, "pnpm-workspace.yaml"))) {
+      if (existsSync4(join10(rootPath, "pnpm-workspace.yaml"))) {
         return discoverPackages(rootPath, "pnpm-workspaces");
       }
       return [];
     }
     case "nx": {
       const standardDirs = ["packages", "apps", "libs"];
-      const globs = standardDirs.filter((d) => existsSync5(join11(rootPath, d)));
+      const globs = standardDirs.filter((d) => existsSync4(join10(rootPath, d)));
       if (globs.length > 0) return resolveWorkspaceGlobs(rootPath, globs);
       try {
-        const pkgJson = JSON.parse(await readFile11(join11(rootPath, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(await readFile11(join10(rootPath, "package.json"), "utf-8"));
         const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : [];
         if (workspaces.length > 0) return resolveWorkspaceGlobs(rootPath, workspaces);
       } catch {
@@ -5118,7 +5459,7 @@ async function discoverPackages(rootPath, tool) {
       return [];
     }
     case "lerna": {
-      const lernaJson = JSON.parse(await readFile11(join11(rootPath, "lerna.json"), "utf-8"));
+      const lernaJson = JSON.parse(await readFile11(join10(rootPath, "lerna.json"), "utf-8"));
       const packages = lernaJson.packages || ["packages/*"];
       return resolveWorkspaceGlobs(rootPath, packages);
     }
@@ -5172,7 +5513,7 @@ async function analyzeMonorepo(rootPath, analysis) {
   const packages = [];
   const packageTokenMap = {};
   for (const pkgPath of packagePaths) {
-    const pkgJsonPath = join11(pkgPath, "package.json");
+    const pkgJsonPath = join10(pkgPath, "package.json");
     let name = basename5(pkgPath);
     let pkgDeps = [];
     try {
@@ -5215,7 +5556,7 @@ async function analyzeMonorepo(rootPath, analysis) {
   }
   const pkgNames = new Set(packages.map((p) => p.name));
   for (const pkg of packages) {
-    const pkgJsonPath = join11(pkg.path, "package.json");
+    const pkgJsonPath = join10(pkg.path, "package.json");
     try {
       const pkgJson = JSON.parse(await readFile11(pkgJsonPath, "utf-8"));
       const allDeps = {
@@ -5369,7 +5710,7 @@ function renderPackageContext(result) {
 // src/engine/quality-gate.ts
 import { readFile as readFile12, writeFile as writeFile7, mkdir as mkdir6 } from "fs/promises";
 import { resolve as resolve13 } from "path";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 var DEFAULT_GATE_CONFIG = {
   threshold: 70,
   failOnSecrets: true,
@@ -5380,7 +5721,7 @@ var DEFAULT_GATE_CONFIG = {
 };
 async function loadBaseline(projectPath, baselinePath) {
   const filePath = resolve13(projectPath, baselinePath || ".cto/baseline.json");
-  if (!existsSync6(filePath)) return null;
+  if (!existsSync5(filePath)) return null;
   try {
     const content = await readFile12(filePath, "utf-8");
     return JSON.parse(content);
@@ -5390,7 +5731,7 @@ async function loadBaseline(projectPath, baselinePath) {
 }
 async function saveBaseline(projectPath, score, commit, branch, baselinePath) {
   const dir = resolve13(projectPath, ".cto");
-  if (!existsSync6(dir)) await mkdir6(dir, { recursive: true });
+  if (!existsSync5(dir)) await mkdir6(dir, { recursive: true });
   const baseline = {
     score: score.overall,
     grade: score.grade,
@@ -5537,10 +5878,570 @@ Warnings: ${warnings.map((c) => c.name).join(", ")}`;
   }
   return summary;
 }
+
+// src/engine/code-review.ts
+import { resolve as resolve14, basename as basename6, dirname as dirname5 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+async function git2(args, cwd) {
+  try {
+    const { stdout } = await exec2("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function analyzeForReview(analysis, options = {}) {
+  const projectPath = resolve14(analysis.projectPath);
+  const baseBranch = options.baseBranch ?? "main";
+  const depth = options.depth ?? 2;
+  const maxPromptFiles = options.maxPromptFiles ?? 20;
+  const isRepo = await git2(["rev-parse", "--is-inside-work-tree"], projectPath) === "true";
+  if (!isRepo) {
+    return emptyResult3(baseBranch);
+  }
+  const branch = await git2(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+  const changedFiles = await getChangedFilesWithHunks(projectPath, baseBranch, analysis);
+  if (changedFiles.length === 0) {
+    return {
+      ...emptyResult3(baseBranch),
+      branch,
+      isGitRepo: true,
+      renderedSummary: "# Code Review\n\nNo changed files detected."
+    };
+  }
+  const totalLinesChanged = changedFiles.reduce((s, f) => s + f.linesAdded + f.linesRemoved, 0);
+  const breakingChanges = detectBreakingChanges(changedFiles, analysis);
+  const missingFiles = findMissingFiles(changedFiles, analysis, depth);
+  const impactRadius = computeImpactRadius(changedFiles, analysis, depth);
+  const reviewQuality = calculateReviewQuality(changedFiles, breakingChanges, missingFiles, impactRadius, totalLinesChanged);
+  const reviewPrompt = await generateReviewPrompt(changedFiles, breakingChanges, missingFiles, analysis, projectPath, maxPromptFiles);
+  const renderedSummary = renderReviewSummary(branch, baseBranch, changedFiles, breakingChanges, missingFiles, impactRadius, reviewQuality);
+  return {
+    branch,
+    baseBranch,
+    isGitRepo: true,
+    changedFiles,
+    totalLinesChanged,
+    breakingChanges,
+    missingFiles,
+    impactRadius,
+    reviewQuality,
+    reviewPrompt,
+    renderedSummary
+  };
+}
+async function getChangedFilesWithHunks(projectPath, baseBranch, analysis) {
+  const files = [];
+  const fileMap = new Map(analysis.files.map((f) => [f.relativePath, f]));
+  const numstat = await git2(["diff", "--numstat", "HEAD"], projectPath);
+  const branchNumstat = await git2(["diff", "--numstat", `${baseBranch}...HEAD`], projectPath);
+  const nameStatus = await git2(["diff", "--name-status", `${baseBranch}...HEAD`], projectPath);
+  const changeTypes = /* @__PURE__ */ new Map();
+  for (const line of nameStatus.split("\n")) {
+    const parts = line.trim().split("	");
+    if (parts.length < 2) continue;
+    const status = parts[0];
+    const filePath = parts[parts.length - 1];
+    if (status === "A") changeTypes.set(filePath, "added");
+    else if (status === "D") changeTypes.set(filePath, "deleted");
+    else if (status.startsWith("R")) changeTypes.set(filePath, "renamed");
+    else changeTypes.set(filePath, "modified");
+  }
+  const allNumstat = (numstat + "\n" + branchNumstat).split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of allNumstat) {
+    const parts = line.trim().split("	");
+    if (parts.length < 3) continue;
+    const added = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+    const removed = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+    const filePath = parts[2];
+    if (!filePath || seen.has(filePath)) continue;
+    seen.add(filePath);
+    const af = fileMap.get(filePath);
+    const changeType = changeTypes.get(filePath) ?? "modified";
+    const hunks = await parseDiffHunks(projectPath, baseBranch, filePath);
+    const hasExportChanges = hunks.some(
+      (h) => h.additions.some((l) => /^\s*export\s/.test(l)) || h.deletions.some((l) => /^\s*export\s/.test(l))
+    );
+    const hasTypeChanges = hunks.some(
+      (h) => h.additions.some((l) => /^\s*(interface|type|enum)\s/.test(l)) || h.deletions.some((l) => /^\s*(interface|type|enum)\s/.test(l))
+    );
+    files.push({
+      relativePath: filePath,
+      changeType,
+      linesAdded: added,
+      linesRemoved: removed,
+      riskScore: af?.riskScore ?? 0,
+      kind: af?.kind ?? "unknown",
+      hunks,
+      hasExportChanges,
+      hasTypeChanges
+    });
+  }
+  const workingNumstat = await git2(["diff", "--numstat"], projectPath);
+  for (const line of workingNumstat.split("\n")) {
+    const parts = line.trim().split("	");
+    if (parts.length < 3) continue;
+    const filePath = parts[2];
+    if (!filePath || seen.has(filePath)) continue;
+    seen.add(filePath);
+    const af = fileMap.get(filePath);
+    const added = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+    const removed = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+    files.push({
+      relativePath: filePath,
+      changeType: "modified",
+      linesAdded: added,
+      linesRemoved: removed,
+      riskScore: af?.riskScore ?? 0,
+      kind: af?.kind ?? "unknown",
+      hunks: [],
+      hasExportChanges: false,
+      hasTypeChanges: false
+    });
+  }
+  return files.sort((a, b) => b.riskScore - a.riskScore);
+}
+async function parseDiffHunks(projectPath, baseBranch, filePath) {
+  const diff = await git2(["diff", "-U3", `${baseBranch}...HEAD`, "--", filePath], projectPath);
+  if (!diff) return [];
+  const hunks = [];
+  const lines = diff.split("\n");
+  let currentHunk = null;
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@\s*(.*)/);
+    if (hunkMatch) {
+      if (currentHunk) hunks.push(currentHunk);
+      currentHunk = {
+        startLine: parseInt(hunkMatch[2], 10),
+        endLine: parseInt(hunkMatch[2], 10),
+        header: hunkMatch[3] || "",
+        additions: [],
+        deletions: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      currentHunk.additions.push(line.substring(1));
+      currentHunk.endLine++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      currentHunk.deletions.push(line.substring(1));
+    } else if (!line.startsWith("\\")) {
+      if (currentHunk) currentHunk.endLine++;
+    }
+  }
+  if (currentHunk) hunks.push(currentHunk);
+  return hunks;
+}
+function detectBreakingChanges(changedFiles, analysis) {
+  const breaks = [];
+  const adj = buildAdjacencyList(analysis.graph.edges);
+  for (const file of changedFiles) {
+    if (file.changeType === "deleted") {
+      const dependents = findDependents(file.relativePath, analysis);
+      if (dependents.length > 0) {
+        breaks.push({
+          file: file.relativePath,
+          type: "export-removed",
+          severity: "critical",
+          description: `File deleted but ${dependents.length} files depend on it`,
+          affectedFiles: dependents
+        });
+      }
+      continue;
+    }
+    for (const hunk of file.hunks) {
+      for (const del of hunk.deletions) {
+        const exportMatch = del.match(/^\s*export\s+(function|const|class|type|interface|enum)\s+(\w+)/);
+        if (exportMatch) {
+          const [, kind, name] = exportMatch;
+          const wasReAdded = hunk.additions.some(
+            (a) => new RegExp(`export\\s+${kind}\\s+${name}\\b`).test(a)
+          );
+          if (!wasReAdded) {
+            const dependents = findDependents(file.relativePath, analysis);
+            breaks.push({
+              file: file.relativePath,
+              type: kind === "type" || kind === "interface" ? "type-changed" : "export-removed",
+              severity: dependents.length > 3 ? "critical" : dependents.length > 0 ? "high" : "medium",
+              description: `Removed export ${kind} ${name}`,
+              affectedFiles: dependents
+            });
+          }
+        }
+        const propMatch = del.match(/^\s+(\w+)\s*[?:].*[;,]?\s*$/);
+        if (propMatch && file.hasTypeChanges) {
+          const propName = propMatch[1];
+          const wasReAdded = hunk.additions.some(
+            (a) => new RegExp(`\\b${propName}\\s*[?:]`).test(a)
+          );
+          if (!wasReAdded) {
+            breaks.push({
+              file: file.relativePath,
+              type: "interface-changed",
+              severity: "high",
+              description: `Removed property "${propName}" from type/interface`,
+              affectedFiles: findDependents(file.relativePath, analysis)
+            });
+          }
+        }
+      }
+      for (const add of hunk.additions) {
+        const fnMatch = add.match(/^\s*export\s+(async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+        if (fnMatch) {
+          const [, , fnName, newParams] = fnMatch;
+          for (const del of hunk.deletions) {
+            const origMatch = del.match(new RegExp(`export\\s+(async\\s+)?function\\s+${fnName}\\s*\\(([^)]*)\\)`));
+            if (origMatch) {
+              const oldParams = origMatch[2];
+              if (oldParams !== newParams) {
+                const oldCount = oldParams.split(",").filter((p) => p.trim()).length;
+                const newCount = newParams.split(",").filter((p) => p.trim()).length;
+                if (oldCount !== newCount || !paramsCompatible(oldParams, newParams)) {
+                  breaks.push({
+                    file: file.relativePath,
+                    type: "function-signature",
+                    severity: "high",
+                    description: `Function "${fnName}" signature changed: (${oldParams.trim()}) \u2192 (${newParams.trim()})`,
+                    affectedFiles: findDependents(file.relativePath, analysis)
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return breaks.sort((a, b) => {
+    const sev = { critical: 0, high: 1, medium: 2 };
+    return sev[a.severity] - sev[b.severity];
+  });
+}
+function paramsCompatible(oldParams, newParams) {
+  const oldParts = oldParams.split(",").map((p) => p.trim().split(":")[0].trim().replace("?", ""));
+  const newParts = newParams.split(",").map((p) => p.trim().split(":")[0].trim().replace("?", ""));
+  let j = 0;
+  for (let i = 0; i < oldParts.length && j < newParts.length; i++) {
+    if (oldParts[i] === newParts[j]) j++;
+  }
+  return j >= oldParts.length;
+}
+function findDependents(filePath, analysis) {
+  return analysis.files.filter((f) => f.imports.includes(filePath) || f.imports.some((imp) => imp.endsWith(filePath))).map((f) => f.relativePath);
+}
+function findMissingFiles(changedFiles, analysis, depth) {
+  const missing = [];
+  const changedPaths = new Set(changedFiles.map((f) => f.relativePath));
+  const fileMap = new Map(analysis.files.map((f) => [f.relativePath, f]));
+  for (const changed of changedFiles) {
+    if (changed.changeType === "deleted") continue;
+    const af = fileMap.get(changed.relativePath);
+    if (!af) continue;
+    if (changed.hasTypeChanges || changed.hasExportChanges) {
+      const dir2 = dirname5(changed.relativePath);
+      const base = basename6(changed.relativePath).replace(/\.[^.]+$/, "");
+      const typeVariants = [
+        `${dir2}/${base}.types.ts`,
+        `${dir2}/${base}.types.tsx`,
+        `${dir2}/types.ts`,
+        `${dir2}/types/${base}.ts`,
+        `${dir2}/index.d.ts`
+      ];
+      for (const variant of typeVariants) {
+        if (fileMap.has(variant) && !changedPaths.has(variant)) {
+          missing.push({
+            file: variant,
+            reason: `Type file for ${changed.relativePath} \u2014 may need updates`,
+            severity: changed.hasExportChanges ? "high" : "medium",
+            relatedChangedFile: changed.relativePath,
+            relationship: "sibling-type"
+          });
+        }
+      }
+    }
+    const testVariants = [
+      changed.relativePath.replace(/\.([^.]+)$/, ".test.$1"),
+      changed.relativePath.replace(/\.([^.]+)$/, ".spec.$1"),
+      changed.relativePath.replace(/^src\//, "tests/").replace(/\.([^.]+)$/, ".test.$1"),
+      changed.relativePath.replace(/^src\//, "__tests__/").replace(/\.([^.]+)$/, ".test.$1")
+    ];
+    for (const testPath of testVariants) {
+      if (fileMap.has(testPath) && !changedPaths.has(testPath)) {
+        missing.push({
+          file: testPath,
+          reason: `Test file for ${changed.relativePath} \u2014 should be updated`,
+          severity: "medium",
+          relatedChangedFile: changed.relativePath,
+          relationship: "test"
+        });
+        break;
+      }
+    }
+    if (changed.hasExportChanges) {
+      const importers = analysis.files.filter(
+        (f) => f.imports.includes(af.relativePath) && !changedPaths.has(f.relativePath)
+      );
+      for (const importer of importers.slice(0, 5)) {
+        missing.push({
+          file: importer.relativePath,
+          reason: `Imports ${changed.relativePath} which has export changes`,
+          severity: "high",
+          relatedChangedFile: changed.relativePath,
+          relationship: "imported-by"
+        });
+      }
+    }
+    const dir = dirname5(changed.relativePath);
+    const indexFile = `${dir}/index.ts`;
+    if (fileMap.has(indexFile) && !changedPaths.has(indexFile) && changed.hasExportChanges) {
+      missing.push({
+        file: indexFile,
+        reason: `Barrel export may need updating after changes to ${changed.relativePath}`,
+        severity: "medium",
+        relatedChangedFile: changed.relativePath,
+        relationship: "co-located"
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return missing.filter((m) => {
+    if (seen.has(m.file)) return false;
+    seen.add(m.file);
+    return true;
+  }).sort((a, b) => {
+    const sev = { high: 0, medium: 1, low: 2 };
+    return sev[a.severity] - sev[b.severity];
+  });
+}
+function computeImpactRadius(changedFiles, analysis, depth) {
+  const changedPaths = changedFiles.map((f) => f.relativePath);
+  const adj = buildAdjacencyList(analysis.graph.edges);
+  const direct = /* @__PURE__ */ new Set();
+  for (const path of changedPaths) {
+    const importers = adj.reverse.get(path) ?? [];
+    const imports = adj.forward.get(path) ?? [];
+    for (const n of [...importers, ...imports]) {
+      if (!changedPaths.includes(n)) direct.add(n);
+    }
+  }
+  const allAffected = bfsBidirectional(changedPaths, adj, depth);
+  const transitive = /* @__PURE__ */ new Set();
+  for (const path of allAffected) {
+    if (!changedPaths.includes(path) && !direct.has(path)) {
+      transitive.add(path);
+    }
+  }
+  const affectedTests = [...allAffected].filter((p) => {
+    const f = analysis.files.find((af) => af.relativePath === p);
+    return f?.kind === "test";
+  }).length;
+  const hotspots = changedFiles.map((f) => ({
+    file: f.relativePath,
+    dependents: adj.reverse.get(f.relativePath)?.length ?? 0,
+    riskScore: f.riskScore
+  })).sort((a, b) => b.dependents * b.riskScore - a.dependents * a.riskScore).slice(0, 5);
+  const totalAffected = direct.size + transitive.size;
+  const maxRisk = Math.max(...changedFiles.map((f) => f.riskScore), 0);
+  const avgRisk = changedFiles.length > 0 ? changedFiles.reduce((s, f) => s + f.riskScore, 0) / changedFiles.length : 0;
+  const riskScore = Math.min(100, Math.round(
+    avgRisk * 0.3 + maxRisk * 0.2 + Math.min(100, totalAffected * 3) * 0.3 + Math.min(100, changedFiles.length * 5) * 0.2
+  ));
+  return {
+    directlyAffected: direct.size,
+    transitivelyAffected: transitive.size,
+    totalAffected,
+    affectedTests,
+    riskScore,
+    hotspots
+  };
+}
+function calculateReviewQuality(changedFiles, breakingChanges, missingFiles, impactRadius, totalLinesChanged) {
+  const factors = [];
+  const sizeScore = totalLinesChanged <= 50 ? 100 : totalLinesChanged <= 200 ? 85 : totalLinesChanged <= 500 ? 65 : totalLinesChanged <= 1e3 ? 40 : 20;
+  factors.push({
+    name: "PR Size",
+    score: sizeScore,
+    weight: 0.25,
+    detail: `${totalLinesChanged} lines changed \u2014 ${sizeScore >= 80 ? "easy" : sizeScore >= 50 ? "manageable" : "too large"} to review`
+  });
+  const focusScore = changedFiles.length <= 3 ? 100 : changedFiles.length <= 8 ? 80 : changedFiles.length <= 15 ? 55 : 25;
+  factors.push({
+    name: "Focus",
+    score: focusScore,
+    weight: 0.2,
+    detail: `${changedFiles.length} files \u2014 ${focusScore >= 80 ? "focused" : focusScore >= 50 ? "moderate scope" : "unfocused"}`
+  });
+  const criticalBreaks = breakingChanges.filter((b) => b.severity === "critical").length;
+  const highBreaks = breakingChanges.filter((b) => b.severity === "high").length;
+  const breakScore = criticalBreaks > 0 ? 10 : highBreaks > 2 ? 30 : highBreaks > 0 ? 60 : breakingChanges.length > 0 ? 80 : 100;
+  factors.push({
+    name: "Breaking Changes",
+    score: breakScore,
+    weight: 0.25,
+    detail: `${breakingChanges.length} breaking changes (${criticalBreaks} critical, ${highBreaks} high)`
+  });
+  const highMissing = missingFiles.filter((m) => m.severity === "high").length;
+  const completenessScore = highMissing > 3 ? 20 : highMissing > 0 ? 50 : missingFiles.length > 3 ? 65 : missingFiles.length > 0 ? 80 : 100;
+  factors.push({
+    name: "Completeness",
+    score: completenessScore,
+    weight: 0.15,
+    detail: `${missingFiles.length} potentially missing files (${highMissing} high priority)`
+  });
+  const radiusScore = impactRadius.totalAffected <= 5 ? 100 : impactRadius.totalAffected <= 15 ? 75 : impactRadius.totalAffected <= 30 ? 50 : 25;
+  factors.push({
+    name: "Blast Radius",
+    score: radiusScore,
+    weight: 0.15,
+    detail: `${impactRadius.totalAffected} files affected (${impactRadius.directlyAffected} direct, ${impactRadius.transitivelyAffected} transitive)`
+  });
+  const overall = Math.round(factors.reduce((s, f) => s + f.score * f.weight, 0));
+  const grade = overall >= 95 ? "A+" : overall >= 90 ? "A" : overall >= 85 ? "A-" : overall >= 80 ? "B+" : overall >= 75 ? "B" : overall >= 70 ? "B-" : overall >= 65 ? "C+" : overall >= 60 ? "C" : overall >= 55 ? "C-" : overall >= 50 ? "D+" : overall >= 45 ? "D" : overall >= 40 ? "D-" : "F";
+  return { score: overall, grade, factors };
+}
+async function generateReviewPrompt(changedFiles, breakingChanges, missingFiles, analysis, projectPath, maxFiles) {
+  const lines = [];
+  lines.push("# Code Review Context");
+  lines.push("");
+  lines.push("## Project: " + analysis.projectName);
+  lines.push("## Stack: " + analysis.stack.join(", "));
+  lines.push("");
+  if (breakingChanges.length > 0) {
+    lines.push("## \u26A0\uFE0F BREAKING CHANGES DETECTED");
+    lines.push("");
+    for (const bc of breakingChanges) {
+      lines.push("- **" + bc.severity.toUpperCase() + "** " + bc.file + ": " + bc.description);
+      if (bc.affectedFiles.length > 0) {
+        lines.push("  Affected: " + bc.affectedFiles.slice(0, 5).join(", "));
+      }
+    }
+    lines.push("");
+  }
+  if (missingFiles.length > 0) {
+    lines.push("## \u{1F4CB} Potentially Missing Files");
+    lines.push("");
+    for (const mf of missingFiles.slice(0, 10)) {
+      lines.push("- " + mf.file + " \u2014 " + mf.reason);
+    }
+    lines.push("");
+  }
+  lines.push("## Changed Files");
+  lines.push("");
+  const topFiles = changedFiles.slice(0, maxFiles);
+  for (const file of topFiles) {
+    const icon = file.changeType === "added" ? "\u{1F195}" : file.changeType === "deleted" ? "\u{1F5D1}\uFE0F" : "\u{1F4DD}";
+    lines.push("### " + icon + " " + file.relativePath + " (risk: " + file.riskScore + ", " + file.kind + ")");
+    lines.push("+" + file.linesAdded + "/-" + file.linesRemoved + " lines");
+    lines.push("");
+    if (file.riskScore >= 40 && file.changeType !== "deleted") {
+      try {
+        const content = await readFile13(resolve14(projectPath, file.relativePath), "utf-8");
+        const ext = file.relativePath.split(".").pop() ?? "";
+        const maxChars = 4e3;
+        const truncated = content.length > maxChars;
+        lines.push("```" + ext);
+        lines.push(content.slice(0, maxChars));
+        if (truncated) lines.push("// ... [truncated]");
+        lines.push("```");
+        lines.push("");
+      } catch {
+      }
+    }
+  }
+  lines.push("## Review Instructions");
+  lines.push("");
+  lines.push("1. Check breaking changes above for correctness");
+  lines.push("2. Verify all affected files have been updated");
+  lines.push("3. Review changed files for bugs, security issues, and code quality");
+  lines.push("4. Ensure tests cover the changes");
+  if (missingFiles.length > 0) {
+    lines.push('5. Consider whether the "potentially missing files" need updates');
+  }
+  return lines.join("\n");
+}
+function renderReviewSummary(branch, baseBranch, changedFiles, breakingChanges, missingFiles, impactRadius, reviewQuality) {
+  const lines = [];
+  const qIcon = reviewQuality.score >= 80 ? "\u{1F7E2}" : reviewQuality.score >= 60 ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push("");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("  " + qIcon + " Code Review: " + reviewQuality.score + "/100 (" + reviewQuality.grade + ")");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("");
+  lines.push("  Branch: " + branch + " \u2190 " + baseBranch);
+  lines.push("  Files: " + changedFiles.length + " changed");
+  lines.push("  Lines: +" + changedFiles.reduce((s, f) => s + f.linesAdded, 0) + "/-" + changedFiles.reduce((s, f) => s + f.linesRemoved, 0));
+  lines.push("");
+  for (const f of reviewQuality.factors) {
+    const icon = f.score >= 80 ? "\u2705" : f.score >= 50 ? "\u26A0\uFE0F" : "\u274C";
+    lines.push("  " + icon + " " + f.name + ": " + f.score + "/100 \u2014 " + f.detail);
+  }
+  if (breakingChanges.length > 0) {
+    lines.push("");
+    lines.push("  \u26A0\uFE0F  BREAKING CHANGES (" + breakingChanges.length + "):");
+    for (const bc of breakingChanges.slice(0, 5)) {
+      const icon = bc.severity === "critical" ? "\u{1F534}" : bc.severity === "high" ? "\u{1F7E0}" : "\u{1F7E1}";
+      lines.push("    " + icon + " " + bc.file + ": " + bc.description);
+    }
+  }
+  if (missingFiles.length > 0) {
+    lines.push("");
+    lines.push("  \u{1F4CB} Potentially missing (" + missingFiles.length + "):");
+    for (const mf of missingFiles.slice(0, 5)) {
+      lines.push("    \u2192 " + mf.file + " (" + mf.reason + ")");
+    }
+  }
+  lines.push("");
+  lines.push("  \u{1F4A5} Impact: " + impactRadius.totalAffected + " files affected (" + impactRadius.directlyAffected + " direct, " + impactRadius.transitivelyAffected + " transitive)");
+  if (impactRadius.affectedTests > 0) {
+    lines.push("  \u{1F9EA} Tests: " + impactRadius.affectedTests + " test files in blast radius");
+  }
+  if (impactRadius.hotspots.length > 0) {
+    lines.push("");
+    lines.push("  \u{1F525} Hotspots:");
+    for (const h of impactRadius.hotspots.slice(0, 3)) {
+      lines.push("    " + h.file + " (risk: " + h.riskScore + ", " + h.dependents + " dependents)");
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function emptyResult3(baseBranch) {
+  return {
+    branch: "",
+    baseBranch,
+    isGitRepo: false,
+    changedFiles: [],
+    totalLinesChanged: 0,
+    breakingChanges: [],
+    missingFiles: [],
+    impactRadius: {
+      directlyAffected: 0,
+      transitivelyAffected: 0,
+      totalAffected: 0,
+      affectedTests: 0,
+      riskScore: 0,
+      hotspots: []
+    },
+    reviewQuality: {
+      score: 0,
+      grade: "F",
+      factors: []
+    },
+    reviewPrompt: "",
+    renderedSummary: "# Code Review\n\nNot a git repository."
+  };
+}
 export {
+  CtoError,
   DEFAULT_GATE_CONFIG,
   MODEL_REGISTRY2 as MODEL_REGISTRY,
   ProjectWatcher,
+  analyzeForReview,
   analyzeMonorepo,
   analyzeProject,
   analyzeSemantics,
@@ -5554,11 +6455,13 @@ export {
   configureCache,
   countTokensChars4,
   countTokensTiktoken,
+  createLogger,
   createProject,
   detectMonorepoTool,
   detectStack,
   estimateFileTokens,
   estimateTokens,
+  exportFeedbackForTeam,
   freeEncoder,
   generatePRContext,
   getActiveWatchers,
@@ -5572,8 +6475,10 @@ export {
   getPolicyPath,
   getPredictorBoosts,
   getPruneLevelForRisk,
+  importTeamFeedback,
   initProjectConfig,
   invalidateCache,
+  isCtoError,
   loadBaseline,
   loadConfig,
   loadFeedbackModel,
@@ -5594,11 +6499,13 @@ export {
   renderCompilabilityBenchmark,
   renderCompileProof,
   renderContextScore,
+  renderCrossRepoReport,
   renderFeedbackReport,
   renderMonorepoAnalysis,
   renderMultiModelResult,
   renderPackageContext,
   renderQualityBenchmark,
+  renderReviewSummary,
   renderSemanticAnalysis,
   runBenchmark,
   runCompilabilityBenchmark,
@@ -5612,9 +6519,13 @@ export {
   selectContext,
   selectPackageContext,
   semanticBoosts,
+  setJsonLogging,
+  setLogLevel,
   unwatchAll,
   unwatchProject,
   walkProject,
-  watchProject
+  watchProject,
+  wilsonLowerBound,
+  wrapError
 };
 //# sourceMappingURL=index.js.map