cto-ai-cli 1.3.0

package/dist/core/index.js

@@ -0,0 +1,4446 @@
+// src/core/analyzer.ts
+import { resolve as resolve3, basename } from "path";
+import { readFile as readFile3 } from "fs/promises";
+
+// src/core/config.ts
+import { parse, stringify } from "yaml";
+
+// src/utils/constants.ts
+var CTO_VERSION = "1.3.0";
+var CTO_DIR = ".config/cto";
+var CTO_CONFIG_FILE = "config.yaml";
+var CTO_PROJECTS_DIR = "projects";
+var CTO_BACKUPS_DIR = "backups";
+var CTO_SESSIONS_DIR = "sessions";
+var DEFAULT_EXTENSIONS = {
+  code: [
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "py",
+    "rb",
+    "go",
+    "rs",
+    "java",
+    "kt",
+    "swift",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "cs",
+    "php",
+    "vue",
+    "svelte",
+    "astro",
+    "lua",
+    "zig",
+    "ex",
+    "exs",
+    "clj",
+    "scala",
+    "dart"
+  ],
+  config: [
+    "json",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "env",
+    "cfg",
+    "xml",
+    "plist",
+    "properties"
+  ],
+  docs: ["md", "mdx", "txt", "rst", "adoc"],
+  ignore: [
+    "lock",
+    "map",
+    "min.js",
+    "min.css",
+    "bundle.js",
+    "chunk.js",
+    "LICENSE",
+    "CHANGELOG"
+  ]
+};
+var DEFAULT_TIER_THRESHOLDS = {
+  hotDays: 3,
+  warmDays: 14,
+  hotTokenLimit: 5e4,
+  warmTokenLimit: 2e5
+};
+var DEFAULT_IGNORE_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "vendor",
+  "target",
+  "bin",
+  "obj",
+  ".idea",
+  ".vscode",
+  ".DS_Store",
+  ".turbo",
+  ".vercel",
+  ".output",
+  "public/assets",
+  "static/assets",
+  ".cache",
+  "tmp",
+  ".tmp"
+];
+var DEFAULT_IGNORE_PATTERNS = [
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "*.lock",
+  "*.log",
+  "*.bundle.js",
+  "*.chunk.js",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "composer.lock",
+  "Gemfile.lock",
+  "Cargo.lock",
+  "poetry.lock"
+];
+var DEFAULT_CONFIG = {
+  version: CTO_VERSION,
+  extensions: DEFAULT_EXTENSIONS,
+  tiering: DEFAULT_TIER_THRESHOLDS,
+  ignoreDirs: DEFAULT_IGNORE_DIRS,
+  ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+  model: "sonnet",
+  tokenEstimation: "chars4"
+};
+var PROMPT_TEMPLATES = [
+  {
+    id: "task-focused",
+    name: "Focused Task",
+    description: "Optimized prompt for a specific task, includes only hot files",
+    category: "task",
+    template: `Project context: {projectName}
+Stack: {stack}
+
+Main files (hot tier \u2014 read these first):
+{hotFiles}
+
+Task: {taskDescription}
+
+Instructions:
+- Focus ONLY on the files listed above
+- If you need other files, ask before reading them
+- Use /compact if the conversation gets long`
+  },
+  {
+    id: "code-review",
+    name: "Code Review",
+    description: "Efficient code review prompt",
+    category: "review",
+    template: `Project context: {projectName}
+
+Files to review:
+{hotFiles}
+
+Review these files focusing on:
+1. Potential bugs
+2. Performance
+3. Security
+4. Best practices
+
+Do NOT read additional files unless strictly necessary.`
+  },
+  {
+    id: "debug-minimal",
+    name: "Minimal Debug",
+    description: "Debugging prompt with minimal context",
+    category: "debug",
+    template: `Project: {projectName}
+Stack: {stack}
+
+Error/Problem: {taskDescription}
+
+Relevant files (hot):
+{hotFiles}
+
+Debugging instructions:
+1. Analyze the error with the hot files
+2. If you need more files, ask for them one at a time
+3. Propose a minimal fix
+4. Do NOT refactor unrelated code`
+  },
+  {
+    id: "refactor-safe",
+    name: "Safe Refactor",
+    description: "Refactoring prompt with full context",
+    category: "refactor",
+    template: `Project: {projectName}
+Stack: {stack}
+
+Hot files (modify):
+{hotFiles}
+
+Warm files (context only, do not modify unless necessary):
+{warmFiles}
+
+Refactor goal: {taskDescription}
+
+Rules:
+- Change only what is necessary
+- Keep the public interface intact
+- Verify you don't break imports`
+  },
+  {
+    id: "test-gen",
+    name: "Generate Tests",
+    description: "Test generation prompt",
+    category: "test",
+    template: `Project: {projectName}
+Stack: {stack}
+
+Files to test:
+{hotFiles}
+
+Generate tests for the listed files:
+- Project test framework: {testFramework}
+- Cover happy path and edge cases
+- Do NOT read files you don't need
+- Use mocks for external dependencies`
+  }
+];
+var CHARS_PER_TOKEN = 4;
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { createHash } from "crypto";
+function getCTORoot() {
+  return join(homedir(), CTO_DIR);
+}
+function getCTOConfigPath() {
+  return join(getCTORoot(), CTO_CONFIG_FILE);
+}
+function getProjectHash(projectPath) {
+  const normalized = resolve(projectPath);
+  return createHash("sha256").update(normalized).digest("hex").substring(0, 12);
+}
+function getProjectDir(projectPath) {
+  const hash = getProjectHash(projectPath);
+  return join(getCTORoot(), CTO_PROJECTS_DIR, hash);
+}
+function getProjectConfigPath(projectPath) {
+  return join(getProjectDir(projectPath), CTO_CONFIG_FILE);
+}
+function getProjectAnalysisPath(projectPath) {
+  return join(getProjectDir(projectPath), "analysis.json");
+}
+function getBackupsDir(projectPath) {
+  return join(getProjectDir(projectPath), CTO_BACKUPS_DIR);
+}
+function getSessionsDir(projectPath) {
+  return join(getProjectDir(projectPath), CTO_SESSIONS_DIR);
+}
+function getArtifactsDir(projectPath) {
+  return join(getProjectDir(projectPath), "artifacts");
+}
+
+// src/utils/fs.ts
+import { readFile, writeFile, mkdir, stat, readdir, copyFile, unlink, rm } from "fs/promises";
+import { join as join2, extname, relative } from "path";
+import { existsSync } from "fs";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function readJSON(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeJSON(filePath, data) {
+  const dir = join2(filePath, "..");
+  await ensureDir(dir);
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function readText(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeText(filePath, content) {
+  const dir = join2(filePath, "..");
+  await ensureDir(dir);
+  await writeFile(filePath, content, "utf-8");
+}
+function fileExists(filePath) {
+  return existsSync(filePath);
+}
+async function getFileStat(filePath) {
+  try {
+    return await stat(filePath);
+  } catch {
+    return null;
+  }
+}
+async function copyFileWithBackup(src, dest) {
+  await ensureDir(join2(dest, ".."));
+  await copyFile(src, dest);
+}
+async function removeFile(filePath) {
+  try {
+    await unlink(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removeDir(dirPath) {
+  try {
+    await rm(dirPath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 getFileStat(fullPath);
+              if (!fileStat) return;
+              let lines = 0;
+              try {
+                const content = await readFile(fullPath, "utf-8");
+                lines = content.split("\n").length;
+              } catch {
+                lines = 0;
+              }
+              results.push({
+                path: fullPath,
+                relativePath: relative(rootPath, fullPath),
+                extension: ext,
+                size: fileStat.size,
+                lastModified: fileStat.mtime,
+                lastAccessed: fileStat.atime,
+                lines
+              });
+            })()
+          );
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  await walk(rootPath, 0);
+  return results;
+}
+function getAllExtensions(config) {
+  return [
+    ...config.extensions.code,
+    ...config.extensions.config,
+    ...config.extensions.docs
+  ];
+}
+
+// src/core/config.ts
+async function initCTODir() {
+  await ensureDir(getCTORoot());
+}
+async function loadGlobalConfig() {
+  const configPath = getCTOConfigPath();
+  if (!fileExists(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const content = await readText(configPath);
+  if (!content) return { ...DEFAULT_CONFIG };
+  try {
+    const parsed = parse(content);
+    return mergeConfig(DEFAULT_CONFIG, parsed);
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveGlobalConfig(config) {
+  await initCTODir();
+  const configPath = getCTOConfigPath();
+  await writeText(configPath, stringify(config, { indent: 2 }));
+}
+async function loadProjectConfig(projectPath) {
+  const globalConfig = await loadGlobalConfig();
+  const projectConfigPath = getProjectConfigPath(projectPath);
+  if (!fileExists(projectConfigPath)) {
+    return globalConfig;
+  }
+  const content = await readText(projectConfigPath);
+  if (!content) return globalConfig;
+  try {
+    const parsed = parse(content);
+    return mergeConfig(globalConfig, parsed);
+  } catch {
+    return globalConfig;
+  }
+}
+async function saveProjectConfig(projectPath, config) {
+  const projectConfigPath = getProjectConfigPath(projectPath);
+  const existing = await loadProjectConfig(projectPath);
+  const merged = { ...existing, ...config, projectPath };
+  await writeText(projectConfigPath, stringify(merged, { indent: 2 }));
+}
+function mergeConfig(base, override) {
+  return {
+    version: override.version ?? base.version,
+    extensions: override.extensions ? {
+      code: override.extensions.code ?? base.extensions.code,
+      config: override.extensions.config ?? base.extensions.config,
+      docs: override.extensions.docs ?? base.extensions.docs,
+      ignore: override.extensions.ignore ?? base.extensions.ignore
+    } : base.extensions,
+    tiering: override.tiering ? { ...base.tiering, ...override.tiering } : base.tiering,
+    ignoreDirs: override.ignoreDirs ?? base.ignoreDirs,
+    ignorePatterns: override.ignorePatterns ?? base.ignorePatterns,
+    model: override.model ?? base.model,
+    tokenEstimation: override.tokenEstimation ?? base.tokenEstimation
+  };
+}
+async function hasGlobalConfig() {
+  return fileExists(getCTOConfigPath());
+}
+
+// src/core/tiering.ts
+function classifyFile(entry, thresholds) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - entry.lastModified.getTime();
+  const diffDays = diffMs / (1e3 * 60 * 60 * 24);
+  if (diffDays <= thresholds.hotDays) {
+    return "hot";
+  }
+  if (diffDays <= thresholds.warmDays) {
+    return "warm";
+  }
+  return "cold";
+}
+function classifyFileWithAST(file, thresholds) {
+  const now = /* @__PURE__ */ new Date();
+  const modDate = file.lastModified instanceof Date ? file.lastModified : new Date(file.lastModified);
+  const diffMs = now.getTime() - modDate.getTime();
+  const diffDays = diffMs / (1e3 * 60 * 60 * 24);
+  let baseTier;
+  if (diffDays <= thresholds.hotDays) {
+    baseTier = "hot";
+  } else if (diffDays <= thresholds.warmDays) {
+    baseTier = "warm";
+  } else {
+    baseTier = "cold";
+  }
+  if (file.isHub && (file.importedByCount ?? 0) >= 3) {
+    if (baseTier === "cold") return "warm";
+    if (baseTier === "warm") return "hot";
+  }
+  if ((file.complexity ?? 0) > 30 && baseTier === "warm") {
+    return "hot";
+  }
+  return baseTier;
+}
+function buildTierSummary(files, totalTokens) {
+  const hot = files.filter((f) => f.tier === "hot");
+  const warm = files.filter((f) => f.tier === "warm");
+  const cold = files.filter((f) => f.tier === "cold");
+  return {
+    hot: buildTierDetail(hot, totalTokens),
+    warm: buildTierDetail(warm, totalTokens),
+    cold: buildTierDetail(cold, totalTokens)
+  };
+}
+function buildTierDetail(files, totalTokens) {
+  const tierTokens = files.reduce((sum, f) => sum + f.tokens, 0);
+  const tierSize = files.reduce((sum, f) => sum + f.size, 0);
+  return {
+    files,
+    totalTokens: tierTokens,
+    totalSize: tierSize,
+    count: files.length,
+    percentage: totalTokens > 0 ? tierTokens / totalTokens * 100 : 0
+  };
+}
+function getTierFiles(files, tier) {
+  return files.filter((f) => f.tier === tier).sort((a, b) => b.tokens - a.tokens);
+}
+function getTokenSavings(files) {
+  const withoutOptimization = files.reduce((sum, f) => sum + f.tokens, 0);
+  const withOptimization = files.filter((f) => f.tier === "hot").reduce((sum, f) => sum + f.tokens, 0);
+  const saved = withoutOptimization - withOptimization;
+  const savingsPercent = withoutOptimization > 0 ? saved / withoutOptimization * 100 : 0;
+  return {
+    withOptimization,
+    withoutOptimization,
+    saved,
+    savingsPercent
+  };
+}
+
+// src/core/tokenizer.ts
+import { encodingForModel } from "js-tiktoken";
+import { readFile as readFile2 } from "fs/promises";
+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);
+}
+async function estimateFileTokens(filePath, method = "chars4") {
+  if (method === "chars4") {
+    const { stat: stat3 } = await import("fs/promises");
+    const s = await stat3(filePath);
+    return countTokensChars4(s.size);
+  }
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    return countTokensTiktoken(content);
+  } catch {
+    const { stat: stat3 } = await import("fs/promises");
+    const s = await stat3(filePath);
+    return countTokensChars4(s.size);
+  }
+}
+function freeEncoder() {
+  encoder = null;
+}
+
+// src/core/ast.ts
+import { Project, SyntaxKind } from "ts-morph";
+import { resolve as resolve2, relative as relative2, dirname, join as join3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var TS_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
+function createProject(projectPath, filePaths) {
+  const tsConfigPath = join3(projectPath, "tsconfig.json");
+  const hasTsConfig = existsSync2(tsConfigPath);
+  const project = new Project({
+    tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: hasTsConfig ? void 0 : {
+      allowJs: true,
+      jsx: 4,
+      // JsxEmit.ReactJSX
+      esModuleInterop: true,
+      moduleResolution: 100
+      // Bundler
+    }
+  });
+  const tsFiles = filePaths.filter((f) => {
+    const ext = f.split(".").pop()?.toLowerCase() ?? "";
+    return TS_EXTENSIONS.has(ext);
+  });
+  for (const filePath of tsFiles) {
+    try {
+      project.addSourceFileAtPath(filePath);
+    } catch {
+    }
+  }
+  return project;
+}
+function buildDependencyGraph(project, projectPath) {
+  const absPath = resolve2(projectPath);
+  const edges = [];
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const sourceFile of project.getSourceFiles()) {
+    const fromRel = relative2(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 hubs = nodes.map((node) => ({
+    relativePath: node,
+    importedByCount: importedByCount.get(node) ?? 0,
+    importCount: importCount.get(node) ?? 0,
+    score: (importedByCount.get(node) ?? 0) * 2 + (importCount.get(node) ?? 0)
+  })).filter((h) => h.importedByCount >= 2 || h.score >= 4).sort((a, b) => b.score - a.score);
+  const leaves = nodes.filter(
+    (node) => (importedByCount.get(node) ?? 0) === 0 && (importCount.get(node) ?? 0) > 0
+  );
+  return { nodes, edges, hubs, leaves };
+}
+function analyzeFileComplexity(project, projectPath, filePath) {
+  const absPath = resolve2(projectPath);
+  const sourceFile = project.getSourceFile(filePath);
+  if (!sourceFile) return null;
+  const relPath = relative2(absPath, sourceFile.getFilePath());
+  const functions = [];
+  for (const func of sourceFile.getFunctions()) {
+    const name = func.getName() ?? "<anonymous>";
+    const complexity = calculateCyclomaticComplexity(func);
+    functions.push({
+      name,
+      complexity,
+      startLine: func.getStartLineNumber(),
+      endLine: func.getEndLineNumber()
+    });
+  }
+  for (const cls of sourceFile.getClasses()) {
+    for (const method of cls.getMethods()) {
+      const name = `${cls.getName() ?? "<class>"}.${method.getName()}`;
+      const complexity = calculateCyclomaticComplexity(method);
+      functions.push({
+        name,
+        complexity,
+        startLine: method.getStartLineNumber(),
+        endLine: method.getEndLineNumber()
+      });
+    }
+  }
+  for (const varDecl of sourceFile.getVariableDeclarations()) {
+    const init = varDecl.getInitializer();
+    if (init && (init.getKind() === SyntaxKind.ArrowFunction || init.getKind() === SyntaxKind.FunctionExpression)) {
+      const name = varDecl.getName();
+      const complexity = calculateCyclomaticComplexity(init);
+      functions.push({
+        name,
+        complexity,
+        startLine: varDecl.getStartLineNumber(),
+        endLine: varDecl.getEndLineNumber()
+      });
+    }
+  }
+  const totalComplexity = functions.length > 0 ? functions.reduce((sum, f) => sum + f.complexity, 0) : 1;
+  const avgComplexity = functions.length > 0 ? totalComplexity / functions.length : 1;
+  return {
+    relativePath: relPath,
+    cyclomaticComplexity: totalComplexity,
+    functions: functions.sort((a, b) => b.complexity - a.complexity),
+    modelSuggestion: suggestModel(avgComplexity, totalComplexity)
+  };
+}
+function analyzeAllComplexity(project, projectPath) {
+  const results = [];
+  const absPath = resolve2(projectPath);
+  for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    const relPath = relative2(absPath, filePath);
+    if (relPath.startsWith("..") || relPath.includes("node_modules")) continue;
+    const result = analyzeFileComplexity(project, projectPath, filePath);
+    if (result) results.push(result);
+  }
+  return results.sort((a, b) => b.cyclomaticComplexity - a.cyclomaticComplexity);
+}
+function enrichFilesWithAST(files, graph, complexities) {
+  const importedByMap = /* @__PURE__ */ new Map();
+  const importsMap = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!importsMap.has(edge.from)) importsMap.set(edge.from, []);
+    importsMap.get(edge.from).push(edge.to);
+    if (!importedByMap.has(edge.to)) importedByMap.set(edge.to, []);
+    importedByMap.get(edge.to).push(edge.from);
+  }
+  const hubSet = new Set(graph.hubs.map((h) => h.relativePath));
+  const complexityMap = new Map(complexities.map((c) => [c.relativePath, c]));
+  return files.map((file) => {
+    const imports = importsMap.get(file.relativePath) ?? [];
+    const importedBy = importedByMap.get(file.relativePath) ?? [];
+    const comp = complexityMap.get(file.relativePath);
+    return {
+      ...file,
+      imports,
+      importedBy,
+      importCount: imports.length,
+      importedByCount: importedBy.length,
+      isHub: hubSet.has(file.relativePath),
+      complexity: comp?.cyclomaticComplexity ?? 0,
+      modelSuggestion: comp?.modelSuggestion ?? "sonnet"
+    };
+  });
+}
+function resolveImport(sourceFile, moduleSpecifier, projectRoot) {
+  if (!moduleSpecifier.startsWith(".")) return null;
+  const sourceDir = dirname(sourceFile.getFilePath());
+  const basePath = resolve2(sourceDir, moduleSpecifier);
+  const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  for (const ext of extensions) {
+    const candidate = basePath.endsWith(ext) ? basePath : basePath + ext;
+    if (existsSync2(candidate)) {
+      const rel = relative2(projectRoot, candidate);
+      if (!rel.startsWith("..")) return rel;
+    }
+  }
+  if (moduleSpecifier.endsWith(".js")) {
+    const tsPath = basePath.replace(/\.js$/, ".ts");
+    if (existsSync2(tsPath)) {
+      const rel = relative2(projectRoot, tsPath);
+      if (!rel.startsWith("..")) return rel;
+    }
+  }
+  return null;
+}
+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 text = descendant.getText();
+        if (text.includes("&&") || text.includes("||") || text.includes("??")) {
+          complexity++;
+        }
+        break;
+      }
+    }
+  });
+  return complexity;
+}
+function suggestModel(avgComplexity, totalComplexity) {
+  if (avgComplexity > 15 || totalComplexity > 50) return "opus";
+  if (avgComplexity > 5 || totalComplexity > 20) return "sonnet";
+  return "haiku";
+}
+
+// src/core/analyzer.ts
+function estimateTokens2(sizeInBytes) {
+  return Math.ceil(sizeInBytes / CHARS_PER_TOKEN);
+}
+async function analyzeProject(projectPath) {
+  const absPath = resolve3(projectPath);
+  const config = await loadProjectConfig(absPath);
+  const extensions = getAllExtensions(config);
+  const useTiktoken = config.tokenEstimation === "tiktoken";
+  const entries = await walkProject(absPath, {
+    ignoreDirs: config.ignoreDirs,
+    ignorePatterns: config.ignorePatterns,
+    extensions
+  });
+  const files = [];
+  for (const entry of entries) {
+    let tokens;
+    if (useTiktoken) {
+      try {
+        const content = await readFile3(entry.path, "utf-8");
+        tokens = estimateTokens(content, entry.size, "tiktoken");
+      } catch {
+        tokens = estimateTokens2(entry.size);
+      }
+    } else {
+      tokens = estimateTokens2(entry.size);
+    }
+    const tier = classifyFile(entry, config.tiering);
+    files.push({
+      path: entry.path,
+      relativePath: entry.relativePath,
+      size: entry.size,
+      tokens,
+      extension: entry.extension,
+      lastModified: entry.lastModified,
+      lastAccessed: entry.lastAccessed,
+      tier,
+      lines: entry.lines
+    });
+  }
+  let dependencyGraph;
+  try {
+    const project = createProject(absPath, files.map((f) => f.path));
+    dependencyGraph = buildDependencyGraph(project, absPath);
+    const complexities = analyzeAllComplexity(project, absPath);
+    const enriched = enrichFilesWithAST(files, dependencyGraph, complexities);
+    for (let i = 0; i < enriched.length; i++) {
+      files[i] = enriched[i];
+      files[i].tier = classifyFileWithAST(enriched[i], config.tiering);
+    }
+  } catch {
+  }
+  if (useTiktoken) freeEncoder();
+  files.sort((a, b) => b.tokens - a.tokens);
+  const totalTokens = files.reduce((sum, f) => sum + f.tokens, 0);
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  const analysis = {
+    projectPath: absPath,
+    projectName: basename(absPath),
+    totalFiles: files.length,
+    totalTokens,
+    totalSize,
+    files,
+    tiers: buildTierSummary(files, totalTokens),
+    analyzedAt: /* @__PURE__ */ new Date(),
+    dependencyGraph,
+    tokenEstimationMethod: config.tokenEstimation
+  };
+  await saveAnalysis(absPath, analysis);
+  return analysis;
+}
+async function saveAnalysis(projectPath, analysis) {
+  const analysisPath = getProjectAnalysisPath(projectPath);
+  await writeJSON(analysisPath, analysis);
+}
+async function loadAnalysis(projectPath) {
+  const absPath = resolve3(projectPath);
+  const analysisPath = getProjectAnalysisPath(absPath);
+  return readJSON(analysisPath);
+}
+function detectStack(files) {
+  const stack = [];
+  const extensions = new Set(files.map((f) => f.extension));
+  const filenames = new Set(files.map((f) => basename(f.path)));
+  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("rb")) stack.push("Ruby");
+  if (extensions.has("java") || extensions.has("kt")) stack.push("Java/Kotlin");
+  if (extensions.has("swift")) stack.push("Swift");
+  if (extensions.has("php")) stack.push("PHP");
+  if (extensions.has("vue")) stack.push("Vue");
+  if (extensions.has("svelte")) stack.push("Svelte");
+  if (filenames.has("next.config.js") || filenames.has("next.config.mjs") || filenames.has("next.config.ts")) {
+    stack.push("Next.js");
+  }
+  if (filenames.has("nuxt.config.ts") || filenames.has("nuxt.config.js")) stack.push("Nuxt");
+  if (filenames.has("astro.config.mjs")) stack.push("Astro");
+  if (filenames.has("vite.config.ts") || filenames.has("vite.config.js")) stack.push("Vite");
+  if (filenames.has("tailwind.config.js") || filenames.has("tailwind.config.ts")) stack.push("TailwindCSS");
+  if (filenames.has("prisma")) stack.push("Prisma");
+  if (filenames.has("docker-compose.yml") || filenames.has("Dockerfile")) stack.push("Docker");
+  return stack;
+}
+function detectTestFramework(files) {
+  const filenames = files.map((f) => basename(f.path));
+  const paths = files.map((f) => f.relativePath);
+  if (filenames.some((f) => f.includes(".test.") || f.includes(".spec."))) {
+    if (paths.some((p) => p.includes("vitest") || p.includes("vite"))) return "vitest";
+    if (paths.some((p) => p.includes("jest"))) return "jest";
+    return "jest/vitest";
+  }
+  if (paths.some((p) => p.includes("pytest") || p.includes("test_"))) return "pytest";
+  if (paths.some((p) => p.includes("_test.go"))) return "go test";
+  if (paths.some((p) => p.includes("_test.rs"))) return "cargo test";
+  return "unknown";
+}
+
+// src/core/generator.ts
+import { join as join4 } from "path";
+
+// src/core/security.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve4, relative as relative3 } from "path";
+var DEFAULT_SECURITY_CONFIG = {
+  encryptionEnabled: false,
+  secretDetection: true,
+  auditLogging: true,
+  retentionDays: 90,
+  securePermissions: true
+};
+var BUILTIN_PATTERN_DEFS = [
+  // 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_PATTERN_DEFS.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 readFile4(filePath, "utf-8");
+    const relPath = relative3(resolve4(projectPath), resolve4(filePath));
+    return scanContentForSecrets(content, relPath, customPatterns);
+  } catch {
+    return [];
+  }
+}
+async function scanProjectForSecrets(projectPath, filePaths, customPatterns = []) {
+  const allFindings = [];
+  for (const fp of filePaths) {
+    const findings = await scanFileForSecrets(fp, projectPath, customPatterns);
+    allFindings.push(...findings);
+  }
+  return allFindings.sort((a, b) => {
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    return severityOrder[a.severity] - severityOrder[b.severity];
+  });
+}
+function sanitizeContent(content, customPatterns = []) {
+  let sanitized = content;
+  const allPatterns = buildPatterns(customPatterns);
+  for (const secretPattern of allPatterns) {
+    sanitized = sanitized.replace(secretPattern.pattern, (match) => {
+      if (isTemplateOrPlaceholder(match)) return match;
+      return redactSecret(match);
+    });
+  }
+  return sanitized;
+}
+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/core/generator.ts
+async function generateClaudeMd(analysis) {
+  const config = await loadProjectConfig(analysis.projectPath);
+  const stack = detectStack(analysis.files);
+  const testFramework = detectTestFramework(analysis.files);
+  const hotFiles = analysis.tiers.hot.files;
+  const warmFiles = analysis.tiers.warm.files;
+  const lines = [];
+  lines.push(`# CLAUDE.md \u2014 ${analysis.projectName}`);
+  lines.push("");
+  lines.push("> Auto-generated by CTO (Claude Token Optimizer)");
+  lines.push(`> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`);
+  lines.push("");
+  lines.push("## Project Overview");
+  lines.push("");
+  if (stack.length > 0) {
+    lines.push(`**Stack:** ${stack.join(", ")}`);
+  }
+  lines.push(`**Files:** ${analysis.totalFiles} | **Tokens:** ~${formatNum(analysis.totalTokens)}`);
+  if (testFramework !== "unknown") {
+    lines.push(`**Test framework:** ${testFramework}`);
+  }
+  lines.push("");
+  lines.push("## Token Budget");
+  lines.push("");
+  lines.push(`| Tier | Files | Tokens | % |`);
+  lines.push(`|------|-------|--------|---|`);
+  lines.push(`| \u{1F525} Hot | ${analysis.tiers.hot.count} | ~${formatNum(analysis.tiers.hot.totalTokens)} | ${analysis.tiers.hot.percentage.toFixed(1)}% |`);
+  lines.push(`| \u{1F321}\uFE0F Warm | ${analysis.tiers.warm.count} | ~${formatNum(analysis.tiers.warm.totalTokens)} | ${analysis.tiers.warm.percentage.toFixed(1)}% |`);
+  lines.push(`| \u2744\uFE0F Cold | ${analysis.tiers.cold.count} | ~${formatNum(analysis.tiers.cold.totalTokens)} | ${analysis.tiers.cold.percentage.toFixed(1)}% |`);
+  lines.push("");
+  if (hotFiles.length > 0) {
+    lines.push("## \u{1F525} Hot Files (Read First)");
+    lines.push("");
+    lines.push("These files are actively being worked on:");
+    lines.push("");
+    for (const f of hotFiles.slice(0, 20)) {
+      lines.push(`- \`${f.relativePath}\` (~${formatNum(f.tokens)} tokens)`);
+    }
+    if (hotFiles.length > 20) {
+      lines.push(`- ... and ${hotFiles.length - 20} more`);
+    }
+    lines.push("");
+  }
+  if (warmFiles.length > 0) {
+    lines.push("## \u{1F321}\uFE0F Warm Files (Read If Needed)");
+    lines.push("");
+    lines.push("Recently touched but not actively changing:");
+    lines.push("");
+    for (const f of warmFiles.slice(0, 15)) {
+      lines.push(`- \`${f.relativePath}\` (~${formatNum(f.tokens)} tokens)`);
+    }
+    if (warmFiles.length > 15) {
+      lines.push(`- ... and ${warmFiles.length - 15} more`);
+    }
+    lines.push("");
+  }
+  lines.push("## Guidelines for Claude");
+  lines.push("");
+  lines.push("1. **Start with hot files** \u2014 they contain the most relevant context");
+  lines.push("2. **Ask before reading cold files** \u2014 they are likely stale or rarely changed");
+  lines.push("3. **Use `/compact` after ~10 exchanges** to free up context window");
+  lines.push("4. **Prefer focused edits** \u2014 avoid reading entire files when only a function is needed");
+  if (config.model === "sonnet") {
+    lines.push("5. **Use Sonnet for most tasks** \u2014 switch to Opus only for complex architectural changes");
+  }
+  lines.push("");
+  const topDirs = getTopDirectories(analysis.files);
+  if (topDirs.length > 0) {
+    lines.push("## Project Structure");
+    lines.push("");
+    for (const dir of topDirs) {
+      lines.push(`- \`${dir.name}/\` \u2014 ${dir.fileCount} files, ~${formatNum(dir.tokens)} tokens`);
+    }
+    lines.push("");
+  }
+  const content = sanitizeContent(lines.join("\n"));
+  const artifact = {
+    type: "claude-md",
+    content,
+    targetPath: join4(analysis.projectPath, "CLAUDE.md"),
+    projectPath: analysis.projectPath
+  };
+  const artifactsDir = getArtifactsDir(analysis.projectPath);
+  await writeText(join4(artifactsDir, "CLAUDE.md"), content);
+  return artifact;
+}
+async function generateClaudeignore(analysis) {
+  const config = await loadProjectConfig(analysis.projectPath);
+  const coldFiles = analysis.tiers.cold.files;
+  const lines = [];
+  lines.push("# .claudeignore \u2014 Auto-generated by CTO");
+  lines.push(`# Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`);
+  lines.push("# Cold-tier files that Claude should skip");
+  lines.push("");
+  lines.push("# Dependencies & build output");
+  for (const dir of config.ignoreDirs) {
+    lines.push(dir);
+  }
+  lines.push("");
+  lines.push("# Generated files");
+  for (const pattern of config.ignorePatterns) {
+    lines.push(pattern);
+  }
+  lines.push("");
+  const coldDirs = getColdDirectories(coldFiles);
+  if (coldDirs.length > 0) {
+    lines.push("# Cold directories (rarely modified)");
+    for (const dir of coldDirs) {
+      lines.push(`# ${dir} \u2014 cold tier`);
+    }
+    lines.push("");
+  }
+  lines.push("# Ignored extensions");
+  for (const ext of config.extensions.ignore) {
+    lines.push(`*.${ext}`);
+  }
+  lines.push("");
+  const content = lines.join("\n");
+  const artifact = {
+    type: "claudeignore",
+    content,
+    targetPath: join4(analysis.projectPath, ".claudeignore"),
+    projectPath: analysis.projectPath
+  };
+  const artifactsDir = getArtifactsDir(analysis.projectPath);
+  await writeText(join4(artifactsDir, ".claudeignore"), content);
+  return artifact;
+}
+async function loadGeneratedArtifact(projectPath, type) {
+  const artifactsDir = getArtifactsDir(projectPath);
+  const filename = type === "claude-md" ? "CLAUDE.md" : ".claudeignore";
+  return readText(join4(artifactsDir, filename));
+}
+function formatNum(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return n.toString();
+}
+function getTopDirectories(files) {
+  const dirs = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const parts = f.relativePath.split("/");
+    if (parts.length > 1) {
+      const topDir = parts[0];
+      const existing = dirs.get(topDir) ?? { count: 0, tokens: 0 };
+      existing.count++;
+      existing.tokens += f.tokens;
+      dirs.set(topDir, existing);
+    }
+  }
+  return Array.from(dirs.entries()).map(([name, data]) => ({ name, fileCount: data.count, tokens: data.tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 10);
+}
+function getColdDirectories(coldFiles) {
+  const dirs = /* @__PURE__ */ new Map();
+  for (const f of coldFiles) {
+    const parts = f.relativePath.split("/");
+    if (parts.length > 1) {
+      const dir = parts.slice(0, -1).join("/");
+      dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+    }
+  }
+  return Array.from(dirs.entries()).filter(([, count]) => count >= 3).sort((a, b) => b[1] - a[1]).map(([dir]) => dir).slice(0, 20);
+}
+
+// src/core/session.ts
+import { join as join5, basename as basename3 } from "path";
+import { randomUUID } from "crypto";
+import { createPatch } from "diff";
+var BACKUP_MANIFEST = "manifest.json";
+async function loadManifest(projectPath) {
+  const manifestPath = join5(getBackupsDir(projectPath), BACKUP_MANIFEST);
+  return await readJSON(manifestPath) ?? [];
+}
+async function saveManifest(projectPath, entries) {
+  const backupsDir = getBackupsDir(projectPath);
+  await ensureDir(backupsDir);
+  await writeJSON(join5(backupsDir, BACKUP_MANIFEST), entries);
+}
+async function applyArtifact(artifact) {
+  const backupsDir = getBackupsDir(artifact.projectPath);
+  await ensureDir(backupsDir);
+  const hadOriginal = fileExists(artifact.targetPath);
+  const backupId = randomUUID().substring(0, 8);
+  const timestamp = /* @__PURE__ */ new Date();
+  const backupFilename = `${artifact.type}_${backupId}_${timestamp.getTime()}`;
+  const backupPath = join5(backupsDir, backupFilename);
+  if (hadOriginal) {
+    try {
+      await copyFileWithBackup(artifact.targetPath, backupPath);
+    } catch (err) {
+      return {
+        success: false,
+        artifact,
+        error: `Failed to create backup: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  try {
+    await writeText(artifact.targetPath, artifact.content);
+  } catch (err) {
+    return {
+      success: false,
+      artifact,
+      error: `Failed to write artifact: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const backup = {
+    id: backupId,
+    artifactType: artifact.type,
+    originalPath: artifact.targetPath,
+    backupPath,
+    timestamp,
+    projectPath: artifact.projectPath,
+    hadOriginal
+  };
+  const manifest = await loadManifest(artifact.projectPath);
+  manifest.push(backup);
+  await saveManifest(artifact.projectPath, manifest);
+  return { success: true, artifact, backup };
+}
+async function revertArtifact(projectPath, artifactType) {
+  const manifest = await loadManifest(projectPath);
+  if (manifest.length === 0) {
+    return { success: false, backup: {}, error: "No backups found" };
+  }
+  const candidates = artifactType ? manifest.filter((b) => b.artifactType === artifactType) : manifest;
+  if (candidates.length === 0) {
+    return {
+      success: false,
+      backup: {},
+      error: `No backups found for type: ${artifactType}`
+    };
+  }
+  const latest = candidates[candidates.length - 1];
+  try {
+    if (latest.hadOriginal) {
+      await copyFileWithBackup(latest.backupPath, latest.originalPath);
+    } else {
+      await removeFile(latest.originalPath);
+    }
+    const idx = manifest.findIndex((b) => b.id === latest.id);
+    if (idx >= 0) manifest.splice(idx, 1);
+    await saveManifest(projectPath, manifest);
+    await removeFile(latest.backupPath);
+    return { success: true, backup: latest };
+  } catch (err) {
+    return {
+      success: false,
+      backup: latest,
+      error: `Failed to revert: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+async function diffArtifact(artifact) {
+  const currentContent = fileExists(artifact.targetPath) ? await readText(artifact.targetPath) : null;
+  const oldContent = currentContent ?? "";
+  const newContent = artifact.content;
+  const hasChanges = oldContent !== newContent;
+  const diff = createPatch(
+    basename3(artifact.targetPath),
+    oldContent,
+    newContent,
+    "current",
+    "generated by CTO"
+  );
+  return {
+    artifact,
+    currentContent,
+    diff,
+    hasChanges
+  };
+}
+async function listBackups(projectPath) {
+  return loadManifest(projectPath);
+}
+
+// src/core/clean.ts
+import { resolve as resolve5 } from "path";
+async function cleanProject(projectPath) {
+  const absPath = resolve5(projectPath);
+  const projectDir = getProjectDir(absPath);
+  if (!fileExists(projectDir)) {
+    return {
+      success: false,
+      projectPath: absPath,
+      removedDir: projectDir,
+      error: "No CTO data found for this project"
+    };
+  }
+  try {
+    const removed = await removeDir(projectDir);
+    return {
+      success: removed,
+      projectPath: absPath,
+      removedDir: projectDir,
+      error: removed ? void 0 : "Failed to remove project directory"
+    };
+  } catch (err) {
+    return {
+      success: false,
+      projectPath: absPath,
+      removedDir: projectDir,
+      error: `Clean failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/utils/format.ts
+import chalk from "chalk";
+function formatTokens(tokens) {
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M`;
+  }
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}K`;
+  }
+  return tokens.toString();
+}
+
+// src/core/prompts.ts
+function getPromptTemplates() {
+  return PROMPT_TEMPLATES;
+}
+function getPromptById(id) {
+  return PROMPT_TEMPLATES.find((t) => t.id === id);
+}
+function renderPrompt(template, analysis, taskDescription = "") {
+  const stack = detectStack(analysis.files);
+  const testFramework = detectTestFramework(analysis.files);
+  const hotFiles = analysis.tiers.hot.files.slice(0, 15).map((f) => `  - ${f.relativePath} (~${formatTokens(f.tokens)} tokens)`).join("\n");
+  const warmFiles = analysis.tiers.warm.files.slice(0, 10).map((f) => `  - ${f.relativePath} (~${formatTokens(f.tokens)} tokens)`).join("\n");
+  return template.template.replace("{projectName}", analysis.projectName).replace("{stack}", stack.join(", ") || "Not detected").replace("{hotFiles}", hotFiles || "  (no hot files)").replace("{warmFiles}", warmFiles || "  (no warm files)").replace("{taskDescription}", taskDescription || "[describe your task here]").replace("{testFramework}", testFramework);
+}
+function listPromptCategories() {
+  return [...new Set(PROMPT_TEMPLATES.map((t) => t.category))];
+}
+
+// src/core/watcher.ts
+import chokidar from "chokidar";
+import { resolve as resolve6, extname as extname2 } from "path";
+import { EventEmitter } from "events";
+import "fs/promises";
+var ProjectWatcher = class extends EventEmitter {
+  watcher = null;
+  projectPath;
+  options;
+  currentAnalysis = null;
+  tierCache = /* @__PURE__ */ new Map();
+  debounceTimer = null;
+  pendingChanges = [];
+  extensions = /* @__PURE__ */ new Set();
+  running = false;
+  constructor(projectPath, options = {}) {
+    super();
+    this.projectPath = resolve6(projectPath);
+    this.options = {
+      debounceMs: options.debounceMs ?? 1e3,
+      autoRegenerate: options.autoRegenerate ?? true,
+      verbose: options.verbose ?? false
+    };
+  }
+  async start() {
+    if (this.running) return;
+    const config = await loadProjectConfig(this.projectPath);
+    const allExtensions = getAllExtensions(config);
+    this.extensions = new Set(allExtensions);
+    this.emit("status", "Performing initial analysis...");
+    this.currentAnalysis = await analyzeProject(this.projectPath);
+    for (const file of this.currentAnalysis.files) {
+      this.tierCache.set(file.relativePath, file.tier);
+    }
+    this.emit("status", `Watching ${this.currentAnalysis.totalFiles} files...`);
+    this.emit("analysis", this.currentAnalysis);
+    const globs = allExtensions.map((ext) => `**/*.${ext}`);
+    this.watcher = chokidar.watch(globs, {
+      cwd: this.projectPath,
+      ignored: [
+        ...config.ignoreDirs.map((d) => `**/${d}/**`),
+        ...config.ignorePatterns
+      ],
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100
+      }
+    });
+    this.watcher.on("add", (path) => this.handleEvent("add", path));
+    this.watcher.on("change", (path) => this.handleEvent("change", path));
+    this.watcher.on("unlink", (path) => this.handleEvent("unlink", path));
+    this.watcher.on("error", (error) => this.emit("error", error));
+    this.running = true;
+  }
+  async stop() {
+    if (!this.running) return;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    this.running = false;
+    this.emit("status", "Watcher stopped");
+  }
+  isRunning() {
+    return this.running;
+  }
+  getLastAnalysis() {
+    return this.currentAnalysis;
+  }
+  handleEvent(type, filePath) {
+    const ext = extname2(filePath).slice(1).toLowerCase();
+    if (!this.extensions.has(ext)) return;
+    const event = {
+      type,
+      filePath: resolve6(this.projectPath, filePath),
+      relativePath: filePath,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.pendingChanges.push(event);
+    this.emit("fileChange", event);
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.processPendingChanges();
+    }, this.options.debounceMs);
+  }
+  async processPendingChanges() {
+    const changes = [...this.pendingChanges];
+    this.pendingChanges = [];
+    if (changes.length === 0) return;
+    this.emit("status", `Processing ${changes.length} change(s)...`);
+    const tierChanges = [];
+    for (const change of changes) {
+      if (change.type === "unlink") {
+        const prevTier2 = this.tierCache.get(change.relativePath);
+        if (prevTier2) {
+          this.tierCache.delete(change.relativePath);
+        }
+        continue;
+      }
+      const prevTier = this.tierCache.get(change.relativePath);
+      if (prevTier) {
+        const newTier = "hot";
+        if (prevTier !== newTier) {
+          tierChanges.push({
+            relativePath: change.relativePath,
+            previousTier: prevTier,
+            newTier,
+            reason: `File ${change.type === "add" ? "created" : "modified"}`
+          });
+          this.tierCache.set(change.relativePath, newTier);
+        }
+      } else {
+        this.tierCache.set(change.relativePath, "hot");
+        tierChanges.push({
+          relativePath: change.relativePath,
+          previousTier: "cold",
+          newTier: "hot",
+          reason: "New file detected"
+        });
+      }
+    }
+    for (const tc of tierChanges) {
+      this.emit("tierChange", tc);
+    }
+    try {
+      this.currentAnalysis = await analyzeProject(this.projectPath);
+      this.emit("analysis", this.currentAnalysis);
+      for (const file of this.currentAnalysis.files) {
+        this.tierCache.set(file.relativePath, file.tier);
+      }
+      if (this.options.autoRegenerate && tierChanges.length > 0) {
+        this.emit("status", "Regenerating artifacts...");
+        const claudeMd = await generateClaudeMd(this.currentAnalysis);
+        const claudeignore = await generateClaudeignore(this.currentAnalysis);
+        this.emit("regenerated", { claudeMd, claudeignore });
+      }
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+};
+
+// src/core/sessions.ts
+import { resolve as resolve7 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
+var CURRENT_SESSION_FILE = "current.json";
+async function startSession(projectPath, description) {
+  const absPath = resolve7(projectPath);
+  const sessionsDir = getSessionsDir(absPath);
+  await ensureDir(sessionsDir);
+  const session = {
+    id: randomUUID2().substring(0, 8),
+    projectPath: absPath,
+    startedAt: /* @__PURE__ */ new Date(),
+    tokensEstimated: 0,
+    filesRead: [],
+    description,
+    coldFilesRead: 0,
+    warmFilesRead: 0,
+    hotFilesRead: 0,
+    suggestions: []
+  };
+  await writeJSON(join6(sessionsDir, CURRENT_SESSION_FILE), session);
+  return session;
+}
+async function endSession(projectPath, analysis) {
+  const absPath = resolve7(projectPath);
+  const sessionsDir = getSessionsDir(absPath);
+  const currentPath = join6(sessionsDir, CURRENT_SESSION_FILE);
+  const session = await readJSON(currentPath);
+  if (!session) return null;
+  session.endedAt = /* @__PURE__ */ new Date();
+  session.suggestions = generateSessionSuggestions(session, analysis);
+  const archiveName = `session_${session.id}_${new Date(session.startedAt).getTime()}.json`;
+  await writeJSON(join6(sessionsDir, archiveName), session);
+  const { unlink: unlink2 } = await import("fs/promises");
+  try {
+    await unlink2(currentPath);
+  } catch {
+  }
+  return session;
+}
+async function getCurrentSession(projectPath) {
+  const absPath = resolve7(projectPath);
+  const sessionsDir = getSessionsDir(absPath);
+  return readJSON(join6(sessionsDir, CURRENT_SESSION_FILE));
+}
+async function logFileRead(projectPath, fileRead) {
+  const absPath = resolve7(projectPath);
+  const sessionsDir = getSessionsDir(absPath);
+  const currentPath = join6(sessionsDir, CURRENT_SESSION_FILE);
+  const session = await readJSON(currentPath);
+  if (!session) return;
+  session.filesRead.push(fileRead.relativePath);
+  session.tokensEstimated += fileRead.tokens;
+  switch (fileRead.tier) {
+    case "hot":
+      session.hotFilesRead++;
+      break;
+    case "warm":
+      session.warmFilesRead++;
+      break;
+    case "cold":
+      session.coldFilesRead++;
+      break;
+  }
+  await writeJSON(currentPath, session);
+}
+async function listSessions(projectPath, limit = 20) {
+  const absPath = resolve7(projectPath);
+  const sessionsDir = getSessionsDir(absPath);
+  let files;
+  try {
+    files = await readdir2(sessionsDir);
+  } catch {
+    return [];
+  }
+  const sessionFiles = files.filter((f) => f.startsWith("session_") && f.endsWith(".json")).sort().reverse().slice(0, limit);
+  const sessions = [];
+  for (const file of sessionFiles) {
+    const s = await readJSON(join6(sessionsDir, file));
+    if (s) sessions.push(s);
+  }
+  return sessions;
+}
+async function getSessionMetrics(projectPath, analysis) {
+  const sessions = await listSessions(projectPath, 100);
+  const totalTokensInProject = analysis?.totalTokens ?? 0;
+  const totalTokensConsumed = sessions.reduce((s, ses) => s + ses.tokensEstimated, 0);
+  const totalTokensSaved = sessions.length * totalTokensInProject - totalTokensConsumed;
+  const fileReadCounts = /* @__PURE__ */ new Map();
+  for (const ses of sessions) {
+    for (const f of ses.filesRead) {
+      const existing = fileReadCounts.get(f) ?? { count: 0, tier: "cold" };
+      existing.count++;
+      const fileInfo = analysis?.files.find((fi) => fi.relativePath === f);
+      if (fileInfo) existing.tier = fileInfo.tier;
+      fileReadCounts.set(f, existing);
+    }
+  }
+  const mostReadFiles = Array.from(fileReadCounts.entries()).map(([relativePath, data]) => ({ relativePath, readCount: data.count, tier: data.tier })).sort((a, b) => b.readCount - a.readCount).slice(0, 10);
+  const durationsMs = sessions.filter((s) => s.endedAt).map((s) => new Date(s.endedAt).getTime() - new Date(s.startedAt).getTime());
+  const averageSessionDuration = durationsMs.length > 0 ? durationsMs.reduce((a, b) => a + b, 0) / durationsMs.length / 6e4 : 0;
+  const wastePatterns = detectWastePatterns(sessions, analysis);
+  return {
+    totalSessions: sessions.length,
+    totalTokensConsumed,
+    totalTokensSaved: Math.max(0, totalTokensSaved),
+    savingsPercent: totalTokensInProject > 0 ? Math.max(0, totalTokensSaved / (sessions.length * totalTokensInProject) * 100) : 0,
+    averageSessionDuration,
+    mostReadFiles,
+    wastePatterns
+  };
+}
+function detectWastePatterns(sessions, analysis) {
+  const patterns = [];
+  const totalCold = sessions.reduce((s, ses) => s + ses.coldFilesRead, 0);
+  if (totalCold > 5) {
+    patterns.push({
+      type: "cold-reads",
+      description: `${totalCold} cold files read across ${sessions.length} sessions`,
+      impact: totalCold * 500,
+      suggestion: "Review .claudeignore \u2014 cold files are being read frequently"
+    });
+  }
+  const allReads = sessions.flatMap((s) => s.filesRead);
+  const readCounts = /* @__PURE__ */ new Map();
+  for (const f of allReads) {
+    readCounts.set(f, (readCounts.get(f) ?? 0) + 1);
+  }
+  const repeatedFiles = Array.from(readCounts.entries()).filter(([, count]) => count >= 5);
+  if (repeatedFiles.length > 0) {
+    const topRepeated = repeatedFiles.sort((a, b) => b[1] - a[1]).slice(0, 3);
+    patterns.push({
+      type: "repeated-reads",
+      description: `${repeatedFiles.length} files read 5+ times: ${topRepeated.map(([f, c]) => `${f} (${c}x)`).join(", ")}`,
+      impact: repeatedFiles.reduce((s, [, c]) => s + c * 200, 0),
+      suggestion: "Consider moving frequently-read files to hot tier"
+    });
+  }
+  const largeSessions = sessions.filter((s) => s.tokensEstimated > 5e4);
+  if (largeSessions.length > 0) {
+    patterns.push({
+      type: "large-context",
+      description: `${largeSessions.length} sessions with >50K tokens estimated`,
+      impact: largeSessions.reduce((s, ses) => s + ses.tokensEstimated - 5e4, 0),
+      suggestion: "Use /compact more aggressively or narrow the file scope"
+    });
+  }
+  return patterns;
+}
+function generateSessionSuggestions(session, analysis) {
+  const suggestions = [];
+  if (session.coldFilesRead > 3) {
+    suggestions.push(`You read ${session.coldFilesRead} cold files \u2014 consider updating .claudeignore`);
+  }
+  if (session.tokensEstimated > 8e4) {
+    suggestions.push("High token usage \u2014 use /compact to free context window");
+  }
+  if (analysis) {
+    const coldFilesRead = session.filesRead.filter((f) => {
+      const fileInfo = analysis.files.find((fi) => fi.relativePath === f);
+      return fileInfo?.tier === "cold";
+    });
+    if (coldFilesRead.length > 0) {
+      suggestions.push(`Move to hot tier: ${coldFilesRead.slice(0, 3).join(", ")}`);
+    }
+  }
+  return suggestions;
+}
+async function getTodaySessions(projectPath) {
+  const sessions = await listSessions(projectPath, 50);
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  return sessions.filter((s) => new Date(s.startedAt) >= todayStart);
+}
+
+// src/core/dashboard.ts
+import { resolve as resolve8, basename as basename5 } from "path";
+import chalk2 from "chalk";
+import "cli-table3";
+async function getDashboardData(projectPath) {
+  const absPath = resolve8(projectPath);
+  let analysis = await loadAnalysis(absPath);
+  if (!analysis) {
+    analysis = await analyzeProject(absPath);
+  }
+  const todaySessions = await getTodaySessions(absPath);
+  const metrics = await getSessionMetrics(absPath, analysis);
+  const recentSessions = await listSessions(absPath, 5);
+  const savings = getTokenSavings(analysis.files);
+  const tokensConsumed = todaySessions.reduce((s, ses) => s + ses.tokensEstimated, 0);
+  const tokensSaved = todaySessions.length * analysis.totalTokens - tokensConsumed;
+  return {
+    projectName: basename5(absPath),
+    sessionsToday: todaySessions.length,
+    tokensConsumed,
+    tokensSaved: Math.max(0, tokensSaved),
+    savingsRatio: analysis.totalTokens > 0 ? Math.max(0, tokensSaved / (todaySessions.length * analysis.totalTokens || 1)) * 100 : 0,
+    mostReadFiles: metrics.mostReadFiles.map(({ relativePath, readCount }) => ({ relativePath, readCount })),
+    suggestions: metrics.wastePatterns.map((p) => p.suggestion),
+    tiers: analysis.tiers,
+    recentSessions
+  };
+}
+function renderDashboard(data) {
+  const lines = [];
+  const width = 52;
+  const border = "\u2500".repeat(width);
+  lines.push("");
+  lines.push(chalk2.bold.cyan(`\u250C${border}\u2510`));
+  lines.push(chalk2.bold.cyan(`\u2502 \u{1F4CA} CTO Dashboard \u2014 ${pad(data.projectName, width - 22)} \u2502`));
+  lines.push(chalk2.bold.cyan(`\u251C${border}\u2524`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`Sessions today:        ${data.sessionsToday}`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`Tokens consumed:       ~${formatTokens(data.tokensConsumed)}`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`Tokens saved:          ~${formatTokens(data.tokensSaved)}`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`Savings ratio:         ${data.savingsRatio.toFixed(0)}%`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u251C${border}\u2524`));
+  lines.push(chalk2.cyan(`\u2502 ${pad("Tier Breakdown:", width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`  \u{1F525} Hot:  ${data.tiers.hot.count} files (~${formatTokens(data.tiers.hot.totalTokens)} tokens)`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`  \u{1F321}\uFE0F  Warm: ${data.tiers.warm.count} files (~${formatTokens(data.tiers.warm.totalTokens)} tokens)`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u2502 ${pad(`  \u2744\uFE0F  Cold: ${data.tiers.cold.count} files (~${formatTokens(data.tiers.cold.totalTokens)} tokens)`, width)} \u2502`));
+  lines.push(chalk2.cyan(`\u251C${border}\u2524`));
+  if (data.mostReadFiles.length > 0) {
+    lines.push(chalk2.cyan(`\u2502 ${pad("Most Read Files:", width)} \u2502`));
+    for (const f of data.mostReadFiles.slice(0, 5)) {
+      const name = f.relativePath.length > 35 ? "..." + f.relativePath.slice(-32) : f.relativePath;
+      lines.push(chalk2.cyan(`\u2502 ${pad(`  ${f.readCount}x ${name}`, width)} \u2502`));
+    }
+    lines.push(chalk2.cyan(`\u251C${border}\u2524`));
+  }
+  if (data.recentSessions.length > 0) {
+    lines.push(chalk2.cyan(`\u2502 ${pad("Recent Sessions:", width)} \u2502`));
+    for (const s of data.recentSessions.slice(0, 3)) {
+      const date = new Date(s.startedAt);
+      const timeStr = `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
+      const desc = s.description ? s.description.slice(0, 25) : `${s.filesRead.length} files`;
+      const duration = s.endedAt ? `${Math.round((new Date(s.endedAt).getTime() - date.getTime()) / 6e4)}m` : "active";
+      lines.push(chalk2.cyan(`\u2502 ${pad(`  ${timeStr} \u2014 ${desc} (${duration})`, width)} \u2502`));
+    }
+    lines.push(chalk2.cyan(`\u251C${border}\u2524`));
+  }
+  if (data.suggestions.length > 0) {
+    lines.push(chalk2.cyan(`\u2502 ${pad("\u{1F4A1} Suggestions:", width)} \u2502`));
+    for (const s of data.suggestions.slice(0, 3)) {
+      const trimmed = s.length > width - 4 ? s.slice(0, width - 7) + "..." : s;
+      lines.push(chalk2.cyan(`\u2502 ${pad(`  ${trimmed}`, width)} \u2502`));
+    }
+  } else {
+    lines.push(chalk2.cyan(`\u2502 ${pad("\u2705 No issues detected", width)} \u2502`));
+  }
+  lines.push(chalk2.bold.cyan(`\u2514${border}\u2518`));
+  lines.push("");
+  return lines.join("\n");
+}
+function pad(str, len) {
+  const stripped = str.replace(/\x1B\[[0-9;]*m/g, "");
+  if (stripped.length >= len) return str;
+  return str + " ".repeat(len - stripped.length);
+}
+
+// src/core/reports.ts
+import { resolve as resolve9, basename as basename6 } from "path";
+import chalk3 from "chalk";
+async function generateWeeklyReport(projectPath) {
+  const absPath = resolve9(projectPath);
+  const now = /* @__PURE__ */ new Date();
+  const weekStart = new Date(now);
+  weekStart.setDate(weekStart.getDate() - 7);
+  weekStart.setHours(0, 0, 0, 0);
+  const allSessions = await listSessions(absPath, 200);
+  const weekSessions = allSessions.filter(
+    (s) => new Date(s.startedAt) >= weekStart
+  );
+  const prevWeekStart = new Date(weekStart);
+  prevWeekStart.setDate(prevWeekStart.getDate() - 7);
+  const prevWeekSessions = allSessions.filter(
+    (s) => new Date(s.startedAt) >= prevWeekStart && new Date(s.startedAt) < weekStart
+  );
+  let analysis = await loadAnalysis(absPath);
+  if (!analysis) {
+    analysis = await analyzeProject(absPath);
+  }
+  const totalTokensConsumed = weekSessions.reduce((s, ses) => s + ses.tokensEstimated, 0);
+  const totalTokensSaved = weekSessions.length * analysis.totalTokens - totalTokensConsumed;
+  const prevTokens = prevWeekSessions.reduce((s, ses) => s + ses.tokensEstimated, 0);
+  const trend = prevTokens > 0 ? (totalTokensConsumed - prevTokens) / prevTokens * 100 : 0;
+  const fileCounts = /* @__PURE__ */ new Map();
+  for (const s of weekSessions) {
+    for (const f of s.filesRead) {
+      fileCounts.set(f, (fileCounts.get(f) ?? 0) + 1);
+    }
+  }
+  const topFiles = Array.from(fileCounts.entries()).map(([relativePath, readCount]) => ({ relativePath, readCount })).sort((a, b) => b.readCount - a.readCount).slice(0, 10);
+  const metrics = await getSessionMetrics(absPath, analysis);
+  const suggestions = metrics.wastePatterns.map((p) => p.suggestion);
+  return {
+    projectPath: absPath,
+    projectName: basename6(absPath),
+    weekStart,
+    weekEnd: now,
+    sessions: weekSessions,
+    totalTokensConsumed,
+    totalTokensSaved: Math.max(0, totalTokensSaved),
+    trend,
+    topFiles,
+    suggestions
+  };
+}
+function renderWeeklyReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk3.bold.cyan(`\u{1F4CA} Weekly Report \u2014 ${report.projectName}`));
+  lines.push(chalk3.dim(`   ${formatDateRange(report.weekStart, report.weekEnd)}`));
+  lines.push("");
+  lines.push(chalk3.bold("  Summary"));
+  lines.push(`  Sessions:          ${report.sessions.length}`);
+  lines.push(`  Tokens consumed:   ~${formatTokens(report.totalTokensConsumed)}`);
+  lines.push(`  Tokens saved:      ~${formatTokens(report.totalTokensSaved)}`);
+  if (report.trend !== 0) {
+    const trendStr = report.trend > 0 ? chalk3.red(`+${report.trend.toFixed(1)}% vs last week`) : chalk3.green(`${report.trend.toFixed(1)}% vs last week`);
+    lines.push(`  Trend:             ${trendStr}`);
+  }
+  lines.push("");
+  if (report.topFiles.length > 0) {
+    lines.push(chalk3.bold("  Most Read Files"));
+    for (const f of report.topFiles.slice(0, 5)) {
+      lines.push(`    ${f.readCount}x  ${f.relativePath}`);
+    }
+    lines.push("");
+  }
+  if (report.sessions.length > 0) {
+    lines.push(chalk3.bold("  Sessions"));
+    for (const s of report.sessions.slice(0, 10)) {
+      const date = new Date(s.startedAt);
+      const dateStr = `${date.getMonth() + 1}/${date.getDate()}`;
+      const desc = s.description ?? `${s.filesRead.length} files`;
+      const tokens = `~${formatTokens(s.tokensEstimated)}`;
+      lines.push(`    ${dateStr}  ${tokens.padEnd(8)}  ${desc}`);
+    }
+    if (report.sessions.length > 10) {
+      lines.push(chalk3.dim(`    ... and ${report.sessions.length - 10} more`));
+    }
+    lines.push("");
+  }
+  if (report.suggestions.length > 0) {
+    lines.push(chalk3.bold("  \u{1F4A1} Suggestions"));
+    for (const s of report.suggestions) {
+      lines.push(`    \u2022 ${s}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function generateProjectReport(projectPaths) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk3.bold.cyan("\u{1F4CA} Project Comparison Report"));
+  lines.push("");
+  for (const p of projectPaths) {
+    const absPath = resolve9(p);
+    let analysis = await loadAnalysis(absPath);
+    if (!analysis) {
+      try {
+        analysis = await analyzeProject(absPath);
+      } catch {
+        continue;
+      }
+    }
+    const metrics = await getSessionMetrics(absPath, analysis);
+    const name = basename6(absPath);
+    lines.push(chalk3.bold(`  ${name}`));
+    lines.push(`    Files: ${analysis.totalFiles} | Tokens: ~${formatTokens(analysis.totalTokens)}`);
+    lines.push(`    Sessions: ${metrics.totalSessions} | Consumed: ~${formatTokens(metrics.totalTokensConsumed)}`);
+    lines.push(`    Savings: ~${formatTokens(metrics.totalTokensSaved)} (${metrics.savingsPercent.toFixed(0)}%)`);
+    if (metrics.wastePatterns.length > 0) {
+      lines.push(`    \u26A0\uFE0F  ${metrics.wastePatterns.length} waste pattern(s) detected`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function exportMetrics(projectPath, format = "json") {
+  const absPath = resolve9(projectPath);
+  const sessions = await listSessions(absPath, 1e3);
+  let analysis = await loadAnalysis(absPath);
+  if (!analysis) analysis = await analyzeProject(absPath);
+  const metrics = await getSessionMetrics(absPath, analysis);
+  if (format === "json") {
+    return JSON.stringify({ metrics, sessions, analysis: { totalFiles: analysis.totalFiles, totalTokens: analysis.totalTokens } }, null, 2);
+  }
+  const header = "session_id,started_at,ended_at,tokens_estimated,files_read,hot_files,warm_files,cold_files,description";
+  const rows = sessions.map(
+    (s) => `${s.id},${s.startedAt},${s.endedAt ?? ""},${s.tokensEstimated},${s.filesRead.length},${s.hotFilesRead},${s.warmFilesRead},${s.coldFilesRead},"${(s.description ?? "").replace(/"/g, '""')}"`
+  );
+  return [header, ...rows].join("\n");
+}
+function formatDateRange(start, end) {
+  const fmt = (d) => `${d.getMonth() + 1}/${d.getDate()}`;
+  return `${fmt(start)} \u2014 ${fmt(end)}`;
+}
+
+// src/core/audit.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
+import { readdir as readdir3, chmod } from "fs/promises";
+import { join as join7 } from "path";
+import { userInfo } from "os";
+var AUDIT_DIR = "audit";
+var MAX_ENTRIES_PER_FILE = 500;
+function getAuditDir() {
+  return join7(getCTORoot(), AUDIT_DIR);
+}
+function getCurrentAuditFile() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0].replace(/-/g, "");
+  return join7(getAuditDir(), `audit_${date}.json`);
+}
+function computeIntegrityHash(entry) {
+  const payload = JSON.stringify({
+    id: entry.id,
+    timestamp: entry.timestamp,
+    action: entry.action,
+    user: entry.user,
+    projectPath: entry.projectPath,
+    details: entry.details
+  });
+  return createHash2("sha256").update(payload).digest("hex");
+}
+async function logAudit(action, projectPath, details = {}) {
+  const auditDir = getAuditDir();
+  await ensureDir(auditDir);
+  let currentUser;
+  try {
+    currentUser = userInfo().username;
+  } catch {
+    currentUser = process.env.USER ?? process.env.USERNAME ?? "unknown";
+  }
+  const partialEntry = {
+    id: randomUUID3().substring(0, 12),
+    timestamp: /* @__PURE__ */ new Date(),
+    action,
+    user: currentUser,
+    projectPath,
+    details
+  };
+  const entry = {
+    ...partialEntry,
+    integrityHash: computeIntegrityHash(partialEntry)
+  };
+  const auditFile = getCurrentAuditFile();
+  let entries = await readJSON(auditFile) ?? [];
+  entries.push(entry);
+  if (entries.length > MAX_ENTRIES_PER_FILE) {
+    entries = entries.slice(-MAX_ENTRIES_PER_FILE);
+  }
+  await writeJSON(auditFile, entries);
+  try {
+    await chmod(auditFile, 384);
+  } catch {
+  }
+  return entry;
+}
+async function getAuditEntries(options = {}) {
+  const auditDir = getAuditDir();
+  let files;
+  try {
+    files = await readdir3(auditDir);
+  } catch {
+    return [];
+  }
+  const auditFiles = files.filter((f) => f.startsWith("audit_") && f.endsWith(".json")).sort().reverse();
+  const allEntries = [];
+  const limit = options.limit ?? 100;
+  for (const file of auditFiles) {
+    if (allEntries.length >= limit) break;
+    const entries = await readJSON(join7(auditDir, file));
+    if (!entries) continue;
+    for (const entry of entries.reverse()) {
+      if (allEntries.length >= limit) break;
+      if (options.projectPath && entry.projectPath !== options.projectPath) continue;
+      if (options.action && entry.action !== options.action) continue;
+      if (options.since && new Date(entry.timestamp) < options.since) continue;
+      allEntries.push(entry);
+    }
+  }
+  return allEntries;
+}
+function verifyAuditEntry(entry) {
+  const { integrityHash, ...rest } = entry;
+  const expected = computeIntegrityHash(rest);
+  return expected === integrityHash;
+}
+async function verifyAuditIntegrity() {
+  const entries = await getAuditEntries({ limit: 1e4 });
+  const invalidEntries = [];
+  for (const entry of entries) {
+    if (!verifyAuditEntry(entry)) {
+      invalidEntries.push(entry);
+    }
+  }
+  return {
+    totalEntries: entries.length,
+    validEntries: entries.length - invalidEntries.length,
+    invalidEntries
+  };
+}
+async function purgeOldAuditEntries(retentionDays) {
+  const auditDir = getAuditDir();
+  let files;
+  try {
+    files = await readdir3(auditDir);
+  } catch {
+    return 0;
+  }
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - retentionDays);
+  const cutoffStr = cutoff.toISOString().split("T")[0].replace(/-/g, "");
+  let purged = 0;
+  const { unlink: unlink2 } = await import("fs/promises");
+  for (const file of files) {
+    if (!file.startsWith("audit_") || !file.endsWith(".json")) continue;
+    const dateStr = file.replace("audit_", "").replace(".json", "");
+    if (dateStr < cutoffStr) {
+      try {
+        await unlink2(join7(auditDir, file));
+        purged++;
+      } catch {
+      }
+    }
+  }
+  return purged;
+}
+
+// src/core/integrity.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile6, readdir as readdir4, stat as stat2, chmod as chmod2 } from "fs/promises";
+import { join as join8 } from "path";
+var MANIFEST_FILE = "integrity.json";
+function hashContent(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+async function hashFile(filePath) {
+  try {
+    const content = await readFile6(filePath);
+    return hashContent(content);
+  } catch {
+    return null;
+  }
+}
+async function buildIntegrityManifest(projectPath) {
+  const projectDir = getProjectDir(projectPath);
+  const entries = [];
+  const artifactsDir = getArtifactsDir(projectPath);
+  await hashDirEntries(artifactsDir, entries, "artifact");
+  const backupsDir = getBackupsDir(projectPath);
+  await hashDirEntries(backupsDir, entries, "backup");
+  const sessionsDir = getSessionsDir(projectPath);
+  await hashDirEntries(sessionsDir, entries, "session");
+  const configFile = join8(projectDir, "config.yaml");
+  const configHash = await hashFile(configFile);
+  if (configHash) {
+    const s = await stat2(configFile);
+    entries.push({
+      filePath: "config.yaml",
+      hash: configHash,
+      size: s.size,
+      createdAt: s.mtime,
+      type: "config"
+    });
+  }
+  const manifest = {
+    version: CTO_VERSION,
+    createdAt: /* @__PURE__ */ new Date(),
+    entries
+  };
+  const manifestPath = join8(projectDir, MANIFEST_FILE);
+  await writeJSON(manifestPath, manifest);
+  try {
+    await chmod2(manifestPath, 384);
+  } catch {
+  }
+  return manifest;
+}
+async function verifyIntegrity(projectPath) {
+  const projectDir = getProjectDir(projectPath);
+  const manifestPath = join8(projectDir, MANIFEST_FILE);
+  const manifest = await readJSON(manifestPath);
+  if (!manifest) {
+    return { valid: false, total: 0, verified: 0, corrupted: [], missing: ["integrity.json"] };
+  }
+  const corrupted = [];
+  const missing = [];
+  let verified = 0;
+  for (const entry of manifest.entries) {
+    const fullPath = join8(projectDir, getSubDir(entry.type), entry.filePath);
+    const currentHash = await hashFile(fullPath);
+    if (currentHash === null) {
+      missing.push(entry.filePath);
+    } else if (currentHash !== entry.hash) {
+      corrupted.push(entry.filePath);
+    } else {
+      verified++;
+    }
+  }
+  return {
+    valid: corrupted.length === 0 && missing.length === 0,
+    total: manifest.entries.length,
+    verified,
+    corrupted,
+    missing
+  };
+}
+async function secureFilePermissions(projectPath) {
+  const projectDir = getProjectDir(projectPath);
+  let count = 0;
+  async function secureDirRecursive(dir) {
+    let entries;
+    try {
+      entries = await readdir4(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join8(dir, entry);
+      try {
+        const s = await stat2(fullPath);
+        if (s.isDirectory()) {
+          await chmod2(fullPath, 448);
+          count++;
+          await secureDirRecursive(fullPath);
+        } else {
+          await chmod2(fullPath, 384);
+          count++;
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    await chmod2(projectDir, 448);
+    count++;
+    await secureDirRecursive(projectDir);
+  } catch {
+  }
+  return count;
+}
+async function purgeOldData(projectPath, retentionDays) {
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - retentionDays);
+  let purgedSessions = 0;
+  let purgedBackups = 0;
+  const sessionsDir = getSessionsDir(projectPath);
+  purgedSessions = await purgeOldFiles(sessionsDir, cutoff, "session_");
+  return { purgedSessions, purgedBackups };
+}
+async function purgeOldFiles(dir, cutoff, prefix) {
+  let count = 0;
+  const { unlink: unlink2 } = await import("fs/promises");
+  let files;
+  try {
+    files = await readdir4(dir);
+  } catch {
+    return 0;
+  }
+  for (const file of files) {
+    if (!file.startsWith(prefix)) continue;
+    const fullPath = join8(dir, file);
+    try {
+      const s = await stat2(fullPath);
+      if (s.mtime < cutoff) {
+        await unlink2(fullPath);
+        count++;
+      }
+    } catch {
+    }
+  }
+  return count;
+}
+async function hashDirEntries(dir, entries, type) {
+  let files;
+  try {
+    files = await readdir4(dir);
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    const fullPath = join8(dir, file);
+    try {
+      const s = await stat2(fullPath);
+      if (!s.isFile()) continue;
+      const hash = await hashFile(fullPath);
+      if (hash) {
+        entries.push({
+          filePath: file,
+          hash,
+          size: s.size,
+          createdAt: s.mtime,
+          type
+        });
+      }
+    } catch {
+    }
+  }
+}
+function getSubDir(type) {
+  switch (type) {
+    case "artifact":
+      return "artifacts";
+    case "backup":
+      return "backups";
+    case "session":
+      return "sessions";
+    case "config":
+      return "";
+  }
+}
+
+// src/core/pruning.ts
+import { readFile as readFile7 } from "fs/promises";
+import { extname as extname3 } from "path";
+var TS_EXTENSIONS2 = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs"]);
+function getPruneLevelForTier(tier) {
+  switch (tier) {
+    case "hot":
+      return "full";
+    case "warm":
+      return "signatures";
+    case "cold":
+      return "skeleton";
+  }
+}
+async function pruneFile(file, level) {
+  const pruneLevel = level ?? getPruneLevelForTier(file.tier);
+  if (pruneLevel === "full" || pruneLevel === "none") {
+    let content2 = "";
+    try {
+      content2 = await readFile7(file.path, "utf-8");
+    } catch {
+    }
+    return {
+      relativePath: file.relativePath,
+      originalTokens: file.tokens,
+      prunedTokens: pruneLevel === "none" ? 0 : file.tokens,
+      pruneLevel,
+      content: pruneLevel === "none" ? "" : content2,
+      savings: pruneLevel === "none" ? 100 : 0
+    };
+  }
+  let content = "";
+  try {
+    content = await readFile7(file.path, "utf-8");
+  } catch {
+    return emptyPruned(file, pruneLevel);
+  }
+  const ext = extname3(file.relativePath).slice(1).toLowerCase();
+  const isTS = TS_EXTENSIONS2.has(ext);
+  let prunedContent;
+  if (isTS) {
+    prunedContent = pruneLevel === "signatures" ? extractSignatures(content) : extractSkeleton(content);
+  } else {
+    prunedContent = pruneLevel === "signatures" ? extractGenericSignatures(content, ext) : extractGenericSkeleton(content);
+  }
+  const prunedTokens = countTokensChars4(Buffer.byteLength(prunedContent, "utf-8"));
+  const savings = file.tokens > 0 ? (file.tokens - prunedTokens) / file.tokens * 100 : 0;
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens,
+    pruneLevel,
+    content: prunedContent,
+    savings: Math.max(0, savings)
+  };
+}
+async function pruneProject(files) {
+  const prunedFiles = [];
+  for (const file of files) {
+    const pruned = await pruneFile(file);
+    prunedFiles.push(pruned);
+  }
+  const totalOriginalTokens = prunedFiles.reduce((s, f) => s + f.originalTokens, 0);
+  const totalPrunedTokens = prunedFiles.reduce((s, f) => s + f.prunedTokens, 0);
+  const totalSavings = totalOriginalTokens - totalPrunedTokens;
+  return {
+    files: prunedFiles,
+    totalOriginalTokens,
+    totalPrunedTokens,
+    totalSavings,
+    savingsPercent: totalOriginalTokens > 0 ? totalSavings / totalOriginalTokens * 100 : 0
+  };
+}
+function extractSignatures(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let braceDepth = 0;
+  let inFunctionBody = false;
+  let skipUntilBraceClose = false;
+  let functionBraceStart = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (braceDepth === 0 || !inFunctionBody) {
+      if (isImportOrExport(trimmed) || isTypeDefinition(trimmed) || isComment(trimmed) || trimmed === "") {
+        result.push(line);
+        updateBraceDepth(trimmed);
+        continue;
+      }
+    }
+    if (!inFunctionBody && isFunctionSignature(trimmed)) {
+      result.push(line);
+      const openBraces = (trimmed.match(/\{/g) || []).length;
+      const closeBraces = (trimmed.match(/\}/g) || []).length;
+      if (openBraces > closeBraces) {
+        inFunctionBody = true;
+        functionBraceStart = braceDepth + openBraces - closeBraces;
+        result.push("  // ... implementation omitted");
+      }
+      braceDepth += openBraces - closeBraces;
+      continue;
+    }
+    if (inFunctionBody) {
+      const openBraces = (trimmed.match(/\{/g) || []).length;
+      const closeBraces = (trimmed.match(/\}/g) || []).length;
+      braceDepth += openBraces - closeBraces;
+      if (braceDepth < functionBraceStart) {
+        result.push(line);
+        inFunctionBody = false;
+      }
+      continue;
+    }
+    if (isClassOrInterface(trimmed) || isPropertySignature(trimmed)) {
+      result.push(line);
+    }
+    updateBraceDepthLine(line);
+  }
+  return result.join("\n");
+  function updateBraceDepth(trimmed) {
+    braceDepth += (trimmed.match(/\{/g) || []).length;
+    braceDepth -= (trimmed.match(/\}/g) || []).length;
+  }
+  function updateBraceDepthLine(line) {
+    const t = line.trim();
+    braceDepth += (t.match(/\{/g) || []).length;
+    braceDepth -= (t.match(/\}/g) || []).length;
+  }
+}
+function extractSkeleton(content) {
+  const lines = content.split("\n");
+  const result = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (isImportOrExport(trimmed) || isTypeDefinition(trimmed) || isClassOrInterface(trimmed) || isFunctionSignature(trimmed) || trimmed.startsWith("//") || trimmed === "") {
+      if (isFunctionSignature(trimmed) && trimmed.includes("{")) {
+        result.push(line.split("{")[0].trimEnd() + ";");
+      } else {
+        result.push(line);
+      }
+    }
+  }
+  return result.join("\n");
+}
+function extractGenericSignatures(content, ext) {
+  const lines = content.split("\n");
+  const result = [];
+  if (ext === "py") {
+    let inBody = false;
+    let bodyIndent = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const indent = line.length - line.trimStart().length;
+      if (trimmed.startsWith("import ") || trimmed.startsWith("from ") || trimmed === "") {
+        result.push(line);
+        inBody = false;
+        continue;
+      }
+      if (trimmed.startsWith("def ") || trimmed.startsWith("class ") || trimmed.startsWith("async def ")) {
+        result.push(line);
+        inBody = true;
+        bodyIndent = indent;
+        continue;
+      }
+      if (inBody && trimmed.startsWith('"""') || trimmed.startsWith("'''")) {
+        result.push(line);
+        continue;
+      }
+      if (inBody && indent > bodyIndent && result.length > 0) {
+        if (!result[result.length - 1].includes("...")) {
+          result.push(" ".repeat(bodyIndent + 4) + "...");
+        }
+        continue;
+      }
+      if (indent <= bodyIndent) {
+        inBody = false;
+      }
+      if (trimmed.startsWith("#")) {
+        result.push(line);
+      }
+    }
+  } else {
+    let kept = 0;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (kept < 5 || trimmed === "" || trimmed.startsWith("#") || trimmed.startsWith("//") || /^(export|import|function|class|interface|type|const|let|var|def|pub |fn |struct |enum )/i.test(trimmed)) {
+        result.push(line);
+        kept++;
+      }
+    }
+  }
+  return result.join("\n");
+}
+function extractGenericSkeleton(content) {
+  const lines = content.split("\n");
+  return lines.filter((line) => {
+    const t = line.trim();
+    return t === "" || t.startsWith("#") || t.startsWith("//") || /^(export|import|from|function|class|interface|type|const|let|var|def |pub |fn |struct |enum |module )/i.test(t);
+  }).join("\n");
+}
+function isImportOrExport(line) {
+  return /^(import |export |export default |export type |export interface )/.test(line);
+}
+function isTypeDefinition(line) {
+  return /^(type |interface |enum )/.test(line);
+}
+function isComment(line) {
+  return line.startsWith("//") || line.startsWith("/*") || line.startsWith(" *") || line.startsWith("*/");
+}
+function isFunctionSignature(line) {
+  return /^(export )?(async )?(function |const \w+ = (?:async )?\(|(?:public|private|protected|static|async) )/.test(line) || /^\w+\s*\(.*\)\s*[:{]/.test(line);
+}
+function isClassOrInterface(line) {
+  return /^(export )?(abstract )?(class |interface )/.test(line);
+}
+function isPropertySignature(line) {
+  return /^\s+(readonly |public |private |protected )?\w+[\?:]/.test(line) && !line.includes("{");
+}
+function emptyPruned(file, level) {
+  return {
+    relativePath: file.relativePath,
+    originalTokens: file.tokens,
+    prunedTokens: 0,
+    pruneLevel: level,
+    content: "",
+    savings: 100
+  };
+}
+
+// src/core/git.ts
+import { execFile } from "child_process";
+import { resolve as resolve11 } from "path";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function git(args, cwd) {
+  try {
+    const { stdout } = await exec("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function isGitRepo(projectPath) {
+  const result = await git(["rev-parse", "--is-inside-work-tree"], projectPath);
+  return result === "true";
+}
+async function getCurrentBranch(projectPath) {
+  return git(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+}
+async function getGitContext(projectPath, diffBase) {
+  const absPath = resolve11(projectPath);
+  const isRepo = await isGitRepo(absPath);
+  if (!isRepo) {
+    return {
+      branch: "",
+      isGitRepo: false,
+      changedFiles: [],
+      recentCommits: 0,
+      activeDevelopers: []
+    };
+  }
+  const branch = await getCurrentBranch(absPath);
+  const changedFiles = await getChangedFiles(absPath, diffBase);
+  const recentCommits = await getRecentCommitCount(absPath, 14);
+  const activeDevelopers = await getActiveDevelopers(absPath, 14);
+  return {
+    branch,
+    isGitRepo: true,
+    changedFiles,
+    recentCommits,
+    activeDevelopers
+  };
+}
+async function getChangedFiles(projectPath, diffBase) {
+  const absPath = resolve11(projectPath);
+  const files = [];
+  const diffOutput = await git(["diff", "--name-only", "HEAD"], absPath);
+  const stagedOutput = await git(["diff", "--name-only", "--cached"], absPath);
+  const untrackedOutput = await git(["ls-files", "--others", "--exclude-standard"], absPath);
+  const changedSet = /* @__PURE__ */ new Set();
+  for (const line of [...diffOutput.split("\n"), ...stagedOutput.split("\n"), ...untrackedOutput.split("\n")]) {
+    const f = line.trim();
+    if (f) changedSet.add(f);
+  }
+  if (diffBase) {
+    const baseOutput = await git(["diff", "--name-only", diffBase, "HEAD"], absPath);
+    for (const line of baseOutput.split("\n")) {
+      const f = line.trim();
+      if (f) changedSet.add(f);
+    }
+  }
+  for (const relativePath of changedSet) {
+    const info = await getFileGitInfo(absPath, relativePath);
+    if (info) files.push(info);
+  }
+  return files.sort((a, b) => b.linesChanged - a.linesChanged);
+}
+async function getFileGitInfo(projectPath, relativePath) {
+  const absPath = resolve11(projectPath);
+  const logOutput = await git(
+    ["log", "-1", "--format=%aI|%an", "--", relativePath],
+    absPath
+  );
+  let lastCommitDate = /* @__PURE__ */ new Date();
+  let lastAuthor = "unknown";
+  if (logOutput) {
+    const [date, author] = logOutput.split("|");
+    lastCommitDate = new Date(date);
+    lastAuthor = author ?? "unknown";
+  }
+  const countOutput = await git(
+    ["rev-list", "--count", "HEAD", "--", relativePath],
+    absPath
+  );
+  const commitCount = parseInt(countOutput, 10) || 0;
+  const untrackedOutput = await git(["ls-files", "--others", "--exclude-standard", "--", relativePath], absPath);
+  const isNewFile = untrackedOutput.trim() === relativePath;
+  const statOutput = await git(["diff", "--numstat", "HEAD", "--", relativePath], absPath);
+  let linesChanged = 0;
+  if (statOutput) {
+    const parts = statOutput.split("	");
+    linesChanged = (parseInt(parts[0], 10) || 0) + (parseInt(parts[1], 10) || 0);
+  }
+  const diffCheck = await git(["diff", "--name-only", "HEAD", "--", relativePath], absPath);
+  const isInDiff = diffCheck.trim().length > 0 || isNewFile;
+  return {
+    relativePath,
+    lastCommitDate,
+    lastAuthor,
+    commitCount,
+    isInDiff,
+    isNewFile,
+    linesChanged
+  };
+}
+async function getRecentCommitCount(projectPath, days) {
+  const since = /* @__PURE__ */ new Date();
+  since.setDate(since.getDate() - days);
+  const output = await git(
+    ["rev-list", "--count", "--since", since.toISOString(), "HEAD"],
+    resolve11(projectPath)
+  );
+  return parseInt(output, 10) || 0;
+}
+async function getActiveDevelopers(projectPath, days) {
+  const since = /* @__PURE__ */ new Date();
+  since.setDate(since.getDate() - days);
+  const output = await git(
+    ["log", "--since", since.toISOString(), "--format=%an"],
+    resolve11(projectPath)
+  );
+  if (!output) return [];
+  const authors = new Set(output.split("\n").map((a) => a.trim()).filter(Boolean));
+  return Array.from(authors);
+}
+function classifyFileWithGit(file, gitInfo, thresholds) {
+  if (gitInfo?.isInDiff) return "hot";
+  if (gitInfo?.isNewFile) return "hot";
+  const referenceDate = gitInfo?.lastCommitDate ?? file.lastModified;
+  const date = referenceDate instanceof Date ? referenceDate : new Date(referenceDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffDays = (now.getTime() - date.getTime()) / (1e3 * 60 * 60 * 24);
+  if (diffDays <= thresholds.hotDays) return "hot";
+  if (diffDays <= thresholds.warmDays) return "warm";
+  if (gitInfo && gitInfo.commitCount >= 20 && diffDays <= thresholds.warmDays * 2) {
+    return "warm";
+  }
+  return "cold";
+}
+async function enrichFilesWithGit(files, projectPath, thresholds) {
+  const isRepo = await isGitRepo(projectPath);
+  if (!isRepo) return files;
+  const gitContext = await getGitContext(projectPath);
+  const gitMap = new Map(gitContext.changedFiles.map((f) => [f.relativePath, f]));
+  return files.map((file) => {
+    const gitInfo = gitMap.get(file.relativePath);
+    const gitTier = classifyFileWithGit(file, gitInfo, thresholds);
+    const promotedTier = promoteTier(file.tier, gitTier);
+    return {
+      ...file,
+      tier: promotedTier
+    };
+  });
+}
+function promoteTier(current, candidate) {
+  const order = { hot: 0, warm: 1, cold: 2 };
+  return order[candidate] < order[current] ? candidate : current;
+}
+
+// src/core/costs.ts
+var MODEL_PRICING = {
+  opus: {
+    model: "opus",
+    inputPerMillion: 15,
+    outputPerMillion: 75,
+    cacheReadPerMillion: 1.5
+  },
+  sonnet: {
+    model: "sonnet",
+    inputPerMillion: 3,
+    outputPerMillion: 15,
+    cacheReadPerMillion: 0.3
+  },
+  haiku: {
+    model: "haiku",
+    inputPerMillion: 0.25,
+    outputPerMillion: 1.25,
+    cacheReadPerMillion: 0.03
+  }
+};
+function estimateCost(tokens, model = "sonnet") {
+  const pricing = MODEL_PRICING[model];
+  const cost = tokens / 1e6 * pricing.inputPerMillion;
+  return {
+    tokens,
+    cost,
+    formatted: formatCurrency(cost)
+  };
+}
+function estimateSessionCost(files, model = "sonnet") {
+  const allTokens = files.reduce((s, f) => s + f.tokens, 0);
+  const hotTokens = files.filter((f) => f.tier === "hot").reduce((s, f) => s + f.tokens, 0);
+  const withoutCTO = estimateCost(allTokens, model);
+  const withCTO = estimateCost(hotTokens, model);
+  const savedTokens = allTokens - hotTokens;
+  const saved = estimateCost(savedTokens, model);
+  return {
+    model,
+    withoutCTO,
+    withCTO,
+    saved,
+    savingsPercent: allTokens > 0 ? savedTokens / allTokens * 100 : 0
+  };
+}
+function estimateWeeklyCost(sessions, totalProjectTokens, model = "sonnet") {
+  const totalConsumed = sessions.reduce((s, ses) => s + ses.tokensEstimated, 0);
+  const totalWithout = sessions.length * totalProjectTokens;
+  const totalCost = estimateCost(totalConsumed, model);
+  const costWithoutCTO = estimateCost(totalWithout, model);
+  const savedCost = estimateCost(Math.max(0, totalWithout - totalConsumed), model);
+  const avgCostPerSession = sessions.length > 0 ? formatCurrency(totalCost.cost / sessions.length) : "$0.00";
+  return {
+    totalCost,
+    savedCost,
+    costWithoutCTO,
+    sessionsCount: sessions.length,
+    avgCostPerSession
+  };
+}
+function estimateMonthlySavings(avgSessionsPerDay, avgTokensSaved, model = "sonnet") {
+  const pricing = MODEL_PRICING[model];
+  const dailySaved = avgTokensSaved * avgSessionsPerDay / 1e6 * pricing.inputPerMillion;
+  return {
+    daily: formatCurrency(dailySaved),
+    weekly: formatCurrency(dailySaved * 7),
+    monthly: formatCurrency(dailySaved * 30),
+    yearly: formatCurrency(dailySaved * 365)
+  };
+}
+function getModelPricingTable() {
+  const lines = [];
+  lines.push("| Model | Input/1M | Output/1M | Cache Read/1M |");
+  lines.push("|-------|----------|-----------|---------------|");
+  for (const [, pricing] of Object.entries(MODEL_PRICING)) {
+    lines.push(
+      `| ${pricing.model.padEnd(7)} | $${pricing.inputPerMillion.toFixed(2).padStart(6)} | $${pricing.outputPerMillion.toFixed(2).padStart(7)} | $${pricing.cacheReadPerMillion.toFixed(2).padStart(11)} |`
+    );
+  }
+  return lines.join("\n");
+}
+function formatCurrency(amount) {
+  if (amount < 0.01) return `$${amount.toFixed(4)}`;
+  if (amount < 1) return `$${amount.toFixed(3)}`;
+  if (amount < 100) return `$${amount.toFixed(2)}`;
+  return `$${Math.round(amount).toLocaleString()}`;
+}
+
+// src/core/budget.ts
+async function optimizeBudget(files, budget) {
+  const included = [];
+  const excluded = [];
+  let usedTokens = 0;
+  const tierOrder = { hot: 0, warm: 1, cold: 2 };
+  const sorted = [...files].sort((a, b) => {
+    const tierDiff = tierOrder[a.tier] - tierOrder[b.tier];
+    if (tierDiff !== 0) return tierDiff;
+    return b.tokens - a.tokens;
+  });
+  for (const file of sorted) {
+    const pruneLevel = getPruneLevelForTier(file.tier);
+    if (file.tier === "hot") {
+      if (usedTokens + file.tokens <= budget) {
+        usedTokens += file.tokens;
+        included.push(toBudgetFile(file, file.tokens, "full", true, "Hot file \u2014 included in full"));
+        continue;
+      }
+      const pruned = await pruneFile(file, "signatures");
+      if (usedTokens + pruned.prunedTokens <= budget) {
+        usedTokens += pruned.prunedTokens;
+        included.push(toBudgetFile(file, pruned.prunedTokens, "signatures", true, "Hot file \u2014 pruned to signatures (budget constraint)"));
+        continue;
+      }
+    }
+    if (file.tier === "warm") {
+      const pruned = await pruneFile(file, "signatures");
+      if (usedTokens + pruned.prunedTokens <= budget) {
+        usedTokens += pruned.prunedTokens;
+        included.push(toBudgetFile(file, pruned.prunedTokens, "signatures", true, "Warm file \u2014 signatures only"));
+        continue;
+      }
+      const skeleton = await pruneFile(file, "skeleton");
+      if (usedTokens + skeleton.prunedTokens <= budget) {
+        usedTokens += skeleton.prunedTokens;
+        included.push(toBudgetFile(file, skeleton.prunedTokens, "skeleton", true, "Warm file \u2014 skeleton (budget constraint)"));
+        continue;
+      }
+    }
+    if (file.tier === "cold") {
+      const skeleton = await pruneFile(file, "skeleton");
+      if (usedTokens + skeleton.prunedTokens <= budget) {
+        usedTokens += skeleton.prunedTokens;
+        included.push(toBudgetFile(file, skeleton.prunedTokens, "skeleton", true, "Cold file \u2014 skeleton only"));
+        continue;
+      }
+    }
+    excluded.push(toBudgetFile(file, file.tokens, pruneLevel, false, `Excluded \u2014 exceeds budget (${file.tokens} tokens)`));
+  }
+  return {
+    budget,
+    usedTokens,
+    remainingTokens: budget - usedTokens,
+    includedFiles: included,
+    excludedFiles: excluded,
+    fillPercent: budget > 0 ? usedTokens / budget * 100 : 0
+  };
+}
+function toBudgetFile(file, tokens, pruneLevel, included, reason) {
+  return {
+    relativePath: file.relativePath,
+    tokens,
+    tier: file.tier,
+    pruneLevel,
+    included,
+    reason
+  };
+}
+
+// src/core/prompt-engineer.ts
+var DEFAULT_OPTIONS = {
+  enableCoT: true,
+  enableConstraints: true,
+  enableAntiHallucination: true
+};
+function buildRolePriming(stack) {
+  const stackStr = stack.length > 0 ? stack.join(", ") : "software";
+  return `You are a senior ${stackStr} engineer with deep expertise in clean architecture, testing, and production-quality code. You prioritize correctness, readability, and maintainability.`;
+}
+function buildChainOfThought(task) {
+  const lines = [];
+  lines.push("## Thinking Process");
+  lines.push("");
+  lines.push("Before writing any code:");
+  if (task === "debug") {
+    lines.push("1. **Reproduce** \u2014 Understand the exact symptom and when it occurs");
+    lines.push("2. **Hypothesize** \u2014 List the most likely root causes (max 3)");
+    lines.push("3. **Verify** \u2014 Check each hypothesis against the code");
+    lines.push("4. **Fix** \u2014 Apply the minimal fix that addresses the root cause");
+    lines.push("5. **Validate** \u2014 Explain why the fix works and what edge cases it covers");
+  } else if (task === "review") {
+    lines.push("1. **Understand** \u2014 Read the code and understand its purpose");
+    lines.push("2. **Assess** \u2014 Evaluate correctness, readability, performance, security");
+    lines.push("3. **Prioritize** \u2014 Rank issues by severity (critical > major > minor > nitpick)");
+    lines.push("4. **Suggest** \u2014 Provide concrete, actionable improvements with code examples");
+  } else if (task === "refactor") {
+    lines.push("1. **Analyze** \u2014 Identify code smells and structural issues");
+    lines.push("2. **Plan** \u2014 Define the target structure before changing anything");
+    lines.push("3. **Preserve** \u2014 Ensure behavior doesn't change (no functional modifications)");
+    lines.push("4. **Refactor** \u2014 Apply changes incrementally, one pattern at a time");
+    lines.push("5. **Verify** \u2014 Confirm all existing tests still pass");
+  } else if (task === "test") {
+    lines.push("1. **Identify** \u2014 What needs testing? (happy path, edge cases, errors)");
+    lines.push("2. **Structure** \u2014 Use AAA pattern: Arrange, Act, Assert");
+    lines.push("3. **Cover** \u2014 Test boundaries, null/undefined, async errors, type edges");
+    lines.push("4. **Isolate** \u2014 Mock external dependencies, test units independently");
+    lines.push('5. **Name** \u2014 Use descriptive test names: "should [expected] when [condition]"');
+  } else if (task === "feature") {
+    lines.push("1. **Clarify** \u2014 Restate the requirement in your own words");
+    lines.push("2. **Design** \u2014 Plan the approach before coding (types, interfaces, flow)");
+    lines.push("3. **Implement** \u2014 Build incrementally, starting with types and interfaces");
+    lines.push("4. **Test** \u2014 Write tests alongside implementation");
+    lines.push("5. **Integrate** \u2014 Ensure it works with existing code without regressions");
+  } else if (task === "architecture") {
+    lines.push("1. **Context** \u2014 Understand current architecture and constraints");
+    lines.push("2. **Options** \u2014 Present 2-3 viable approaches with trade-offs");
+    lines.push("3. **Recommend** \u2014 Choose the best option and explain why");
+    lines.push("4. **Plan** \u2014 Define migration steps if changing existing architecture");
+    lines.push("5. **Risks** \u2014 Identify risks and mitigation strategies");
+  } else {
+    lines.push("1. **Understand** \u2014 Read the relevant code before making changes");
+    lines.push("2. **Plan** \u2014 Think about the approach before writing code");
+    lines.push("3. **Implement** \u2014 Write clean, well-typed code");
+    lines.push("4. **Verify** \u2014 Check for edge cases and potential issues");
+  }
+  return lines.join("\n");
+}
+function buildConstraints(stack, testFramework) {
+  const lines = [];
+  lines.push("## Constraints");
+  lines.push("");
+  lines.push("- **Do NOT** delete or modify existing tests unless explicitly asked");
+  lines.push("- **Do NOT** change function signatures that are part of the public API");
+  lines.push("- **Do NOT** introduce new dependencies without mentioning it");
+  lines.push("- **Always** handle errors explicitly (no silent catches)");
+  lines.push("- **Always** preserve existing code style and conventions");
+  lines.push("- **Prefer** minimal changes \u2014 smallest diff that solves the problem");
+  if (stack.includes("TypeScript")) {
+    lines.push("- **Always** use strict TypeScript types (no `any` unless unavoidable)");
+    lines.push("- **Prefer** `interface` for object shapes, `type` for unions/intersections");
+    lines.push("- **Use** named exports over default exports");
+  }
+  if (stack.includes("React") || stack.includes("Next.js")) {
+    lines.push("- **Use** functional components with hooks (no class components)");
+    lines.push("- **Prefer** composition over prop drilling");
+  }
+  if (stack.includes("Python")) {
+    lines.push("- **Follow** PEP 8 and use type hints");
+    lines.push("- **Use** f-strings over .format() or % formatting");
+  }
+  if (testFramework) {
+    lines.push(`- **Tests** use ${testFramework} \u2014 follow existing test patterns`);
+    lines.push("- **Run** tests after changes to verify nothing breaks");
+  }
+  return lines.join("\n");
+}
+function buildAntiHallucination() {
+  const lines = [];
+  lines.push("## Important");
+  lines.push("");
+  lines.push("- If you are unsure about something, **ask before proceeding**");
+  lines.push("- Do not invent APIs, functions, or types that don't exist in the codebase");
+  lines.push("- If you need to read a file to answer correctly, say so");
+  lines.push("- Prefer showing a concrete code snippet over a vague description");
+  lines.push("- If a task is ambiguous, state your assumptions explicitly");
+  return lines.join("\n");
+}
+function buildOutputFormat(task) {
+  const lines = [];
+  lines.push("## Response Format");
+  lines.push("");
+  if (task === "debug") {
+    lines.push("1. **Root cause**: One sentence explaining the bug");
+    lines.push("2. **Fix**: The code change with explanation");
+    lines.push("3. **Test**: How to verify the fix works");
+  } else if (task === "review") {
+    lines.push("For each issue found:");
+    lines.push("- **Severity**: critical | major | minor | nitpick");
+    lines.push("- **Location**: file:line");
+    lines.push("- **Issue**: What's wrong");
+    lines.push("- **Fix**: Suggested code change");
+  } else if (task === "refactor") {
+    lines.push("1. **Before/After**: Show the structural change clearly");
+    lines.push("2. **Why**: Explain the improvement");
+    lines.push("3. **Risk**: Any behavior changes to watch for");
+  } else {
+    lines.push("- Start with a brief summary of what you'll do");
+    lines.push("- Show code changes with context (surrounding lines)");
+    lines.push("- Explain non-obvious decisions");
+  }
+  return lines.join("\n");
+}
+function buildFilePriority(hotFiles) {
+  if (hotFiles.length === 0) return "";
+  const lines = [];
+  lines.push("## Priority Files");
+  lines.push("");
+  lines.push("Read these files first \u2014 they are the most active and relevant:");
+  lines.push("");
+  for (const f of hotFiles.slice(0, 20)) {
+    const tokens = f.tokens > 1e3 ? `~${Math.round(f.tokens / 1e3)}K` : `~${f.tokens}`;
+    lines.push(`- \`${f.relativePath}\` (${tokens} tokens)`);
+  }
+  return lines.join("\n");
+}
+function buildEnhancedPrompt(analysis, opts = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...opts };
+  const stack = opts.stack ?? detectStack(analysis.files);
+  const testFramework = opts.testFramework ?? detectTestFramework(analysis.files);
+  const hotFiles = opts.hotFiles ?? analysis.files.filter((f) => f.tier === "hot");
+  const sections = [];
+  sections.push(`# ${analysis.projectName} \u2014 AI Context`);
+  sections.push("");
+  sections.push(`> Generated by CTO v1.3.0 with prompt engineering enhancements.`);
+  sections.push("");
+  sections.push(buildRolePriming(stack));
+  sections.push("");
+  sections.push("## Project Overview");
+  sections.push("");
+  sections.push(`| Property | Value |`);
+  sections.push(`|----------|-------|`);
+  sections.push(`| Stack | ${stack.join(", ") || "Unknown"} |`);
+  if (testFramework) sections.push(`| Tests | ${testFramework} |`);
+  sections.push(`| Files | ${analysis.totalFiles} (${hotFiles.length} hot) |`);
+  sections.push(`| Tokens | ~${Math.round(analysis.totalTokens / 1e3)}K |`);
+  sections.push("");
+  const filePriority = buildFilePriority(hotFiles);
+  if (filePriority) {
+    sections.push(filePriority);
+    sections.push("");
+  }
+  if (options.enableCoT) {
+    sections.push(buildChainOfThought(opts.task));
+    sections.push("");
+  }
+  if (options.enableConstraints) {
+    sections.push(buildConstraints(stack, testFramework));
+    sections.push("");
+  }
+  if (opts.task) {
+    sections.push(buildOutputFormat(opts.task));
+    sections.push("");
+  }
+  if (options.enableAntiHallucination) {
+    sections.push(buildAntiHallucination());
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function getTaskPromptBlock(task) {
+  const blocks = {
+    "debug": [
+      "## Debug Instructions",
+      "",
+      "You are debugging an issue. Follow this approach:",
+      "- Read the error message/symptom carefully",
+      "- Trace the data flow from input to the point of failure",
+      "- Check for: null/undefined, type mismatches, async race conditions, off-by-one errors",
+      "- Fix the ROOT CAUSE, not the symptom",
+      "- Add a regression test if possible"
+    ].join("\n"),
+    "review": [
+      "## Code Review Instructions",
+      "",
+      "Review this code with focus on:",
+      "- **Correctness**: Does it do what it claims? Edge cases?",
+      "- **Security**: Input validation, injection risks, secrets exposure",
+      "- **Performance**: N+1 queries, unnecessary iterations, memory leaks",
+      "- **Readability**: Clear naming, appropriate abstractions, documentation",
+      "- **Testing**: Adequate coverage, meaningful assertions",
+      "",
+      "Rate each issue: \u{1F534} Critical | \u{1F7E0} Major | \u{1F7E1} Minor | \u26AA Nitpick"
+    ].join("\n"),
+    "refactor": [
+      "## Refactor Instructions",
+      "",
+      "Refactor for better structure WITHOUT changing behavior:",
+      "- Extract common logic into reusable functions",
+      "- Replace magic numbers/strings with named constants",
+      "- Simplify complex conditionals",
+      "- Apply SOLID principles where beneficial (don't over-engineer)",
+      "- Keep the diff as small as possible",
+      "- Verify all tests pass after refactoring"
+    ].join("\n"),
+    "test": [
+      "## Testing Instructions",
+      "",
+      "Write comprehensive tests:",
+      "- **Happy path**: Normal expected usage",
+      "- **Edge cases**: Empty inputs, boundaries, large data",
+      "- **Error cases**: Invalid inputs, network failures, permissions",
+      "- **Async**: Race conditions, timeout handling",
+      "",
+      'Structure: describe("module") > describe("function") > it("should...")',
+      "Use AAA: Arrange (setup) \u2192 Act (execute) \u2192 Assert (verify)"
+    ].join("\n"),
+    "docs": [
+      "## Documentation Instructions",
+      "",
+      "- Use clear, concise language",
+      "- Include code examples for every API/function documented",
+      "- Document parameters, return types, and exceptions",
+      '- Add a "Quick Start" section for new users',
+      "- Include troubleshooting for common issues"
+    ].join("\n"),
+    "simple-edit": [
+      "## Simple Edit",
+      "",
+      "- Make the minimum change necessary",
+      "- Do not refactor surrounding code",
+      "- Preserve existing style exactly"
+    ].join("\n"),
+    "feature": [
+      "## Feature Development Instructions",
+      "",
+      "Build this feature following this order:",
+      "1. Define types/interfaces first",
+      "2. Implement core logic with proper error handling",
+      "3. Write tests alongside implementation",
+      "4. Integrate with existing modules",
+      "5. Update exports and any relevant documentation",
+      "",
+      "Ensure backward compatibility \u2014 existing tests must still pass."
+    ].join("\n"),
+    "architecture": [
+      "## Architecture Decision",
+      "",
+      "Analyze the architectural question by providing:",
+      "1. **Current state**: How things work now",
+      "2. **Options**: At least 2-3 approaches with pros/cons table",
+      "3. **Recommendation**: Your pick with justification",
+      "4. **Migration path**: Steps to get from current \u2192 proposed",
+      "5. **Risks**: What could go wrong and how to mitigate",
+      "",
+      "Consider: scalability, maintainability, team familiarity, testing impact."
+    ].join("\n")
+  };
+  return blocks[task];
+}
+
+// src/core/adapters.ts
+function generateClaude(analysis, config) {
+  const lines = [];
+  const hot = analysis.files.filter((f) => f.tier === "hot");
+  const warm = analysis.files.filter((f) => f.tier === "warm");
+  lines.push(`# CLAUDE.md \u2014 ${analysis.projectName}`);
+  lines.push("");
+  lines.push("## Project Overview");
+  lines.push("");
+  lines.push(`- **Stack:** ${detectStack(analysis.files).join(", ") || "Unknown"}`);
+  lines.push(`- **Files:** ${analysis.totalFiles} (${hot.length} hot, ${warm.length} warm)`);
+  lines.push(`- **Tokens:** ~${Math.round(analysis.totalTokens / 1e3)}K total`);
+  lines.push("");
+  lines.push("## Priority Files (read first)");
+  lines.push("");
+  for (const f of hot.slice(0, 20)) {
+    lines.push(`- \`${f.relativePath}\` (~${Math.round(f.tokens / 1e3)}K tokens)`);
+  }
+  lines.push("");
+  lines.push("## Guidelines");
+  lines.push("");
+  lines.push("- Read hot-tier files first for full context");
+  lines.push("- Warm files can be read on demand");
+  lines.push("- Cold files are rarely needed");
+  return lines.join("\n");
+}
+function generateCursor(analysis, config) {
+  const lines = [];
+  const hot = analysis.files.filter((f) => f.tier === "hot");
+  const stack = detectStack(analysis.files);
+  const testFw = detectTestFramework(analysis.files);
+  lines.push("# Cursor Rules \u2014 Generated by CTO");
+  lines.push("");
+  lines.push("## Project Context");
+  lines.push("");
+  lines.push(`This is a ${stack.join(", ")} project with ${analysis.totalFiles} files.`);
+  if (testFw) lines.push(`Test framework: ${testFw}`);
+  lines.push("");
+  lines.push("## Key Files");
+  lines.push("");
+  lines.push("Always reference these files for context:");
+  lines.push("");
+  for (const f of hot.slice(0, 15)) {
+    lines.push(`- ${f.relativePath}`);
+  }
+  lines.push("");
+  lines.push("## Code Style");
+  lines.push("");
+  if (stack.includes("TypeScript")) {
+    lines.push("- Use TypeScript with strict types");
+    lines.push("- Prefer interfaces over type aliases for object shapes");
+    lines.push("- Use named exports");
+  }
+  if (stack.includes("React") || stack.includes("Next.js")) {
+    lines.push("- Use functional components with hooks");
+    lines.push("- Prefer composition over inheritance");
+  }
+  if (stack.includes("Python")) {
+    lines.push("- Follow PEP 8");
+    lines.push("- Use type hints");
+  }
+  lines.push("");
+  lines.push("## File Organization");
+  lines.push("");
+  const dirs = [...new Set(analysis.files.map((f) => f.relativePath.split("/")[0]))].slice(0, 10);
+  for (const dir of dirs) {
+    const count = analysis.files.filter((f) => f.relativePath.startsWith(dir + "/")).length;
+    if (count > 0) lines.push(`- \`${dir}/\` \u2014 ${count} files`);
+  }
+  return lines.join("\n");
+}
+function generateCopilot(analysis, config) {
+  const lines = [];
+  const hot = analysis.files.filter((f) => f.tier === "hot");
+  const stack = detectStack(analysis.files);
+  const testFw = detectTestFramework(analysis.files);
+  lines.push("# Copilot Instructions \u2014 Generated by CTO");
+  lines.push("");
+  lines.push("## Context");
+  lines.push("");
+  lines.push(`This is a ${stack.join(", ")} project.`);
+  lines.push(`Total files: ${analysis.totalFiles}. Focus on the ${hot.length} most active files.`);
+  lines.push("");
+  lines.push("## Important Files");
+  lines.push("");
+  for (const f of hot.slice(0, 15)) {
+    lines.push(`- \`${f.relativePath}\``);
+  }
+  lines.push("");
+  lines.push("## Conventions");
+  lines.push("");
+  if (stack.includes("TypeScript")) {
+    lines.push("- All code must be TypeScript");
+    lines.push("- Use ESM imports (import/export)");
+    lines.push("- Strict null checks enabled");
+  }
+  if (testFw) {
+    lines.push(`- Tests use ${testFw}`);
+    lines.push("- Write tests for all new functions");
+  }
+  lines.push("");
+  lines.push("## Architecture");
+  lines.push("");
+  const topDirs = [...new Set(analysis.files.map((f) => f.relativePath.split("/")[0]))].slice(0, 8);
+  for (const dir of topDirs) {
+    const dirFiles = analysis.files.filter((f) => f.relativePath.startsWith(dir + "/"));
+    if (dirFiles.length > 0) {
+      lines.push(`- \`${dir}/\` \u2014 ${dirFiles.length} files, ~${Math.round(dirFiles.reduce((s, f) => s + f.tokens, 0) / 1e3)}K tokens`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateGemini(analysis, config) {
+  const lines = [];
+  const hot = analysis.files.filter((f) => f.tier === "hot");
+  const warm = analysis.files.filter((f) => f.tier === "warm");
+  const stack = detectStack(analysis.files);
+  lines.push("# GEMINI.md \u2014 Project Context");
+  lines.push("");
+  lines.push("## Overview");
+  lines.push("");
+  lines.push(`| Property | Value |`);
+  lines.push(`|----------|-------|`);
+  lines.push(`| Stack | ${stack.join(", ")} |`);
+  lines.push(`| Total Files | ${analysis.totalFiles} |`);
+  lines.push(`| Hot Files | ${hot.length} |`);
+  lines.push(`| Warm Files | ${warm.length} |`);
+  lines.push(`| Total Tokens | ~${Math.round(analysis.totalTokens / 1e3)}K |`);
+  lines.push("");
+  lines.push("## Priority Files");
+  lines.push("");
+  lines.push("Read these files first for full project understanding:");
+  lines.push("");
+  for (const f of hot.slice(0, 20)) {
+    lines.push(`1. \`${f.relativePath}\` \u2014 ${f.tier} tier, ~${Math.round(f.tokens / 1e3)}K tokens`);
+  }
+  lines.push("");
+  lines.push("## Project Structure");
+  lines.push("");
+  const topDirs = [...new Set(analysis.files.map((f) => f.relativePath.split("/")[0]))].slice(0, 10);
+  for (const dir of topDirs) {
+    const count = analysis.files.filter((f) => f.relativePath.startsWith(dir + "/")).length;
+    if (count > 0) lines.push(`- **${dir}/** \u2014 ${count} files`);
+  }
+  return lines.join("\n");
+}
+function generateWindsurf(analysis, config) {
+  const lines = [];
+  const hot = analysis.files.filter((f) => f.tier === "hot");
+  const warm = analysis.files.filter((f) => f.tier === "warm");
+  const stack = detectStack(analysis.files);
+  const testFw = detectTestFramework(analysis.files);
+  lines.push("# Windsurf Rules \u2014 Project Context");
+  lines.push("");
+  lines.push(`You are working on **${analysis.projectName}**, a ${stack.join(", ") || "software"} project.`);
+  lines.push("");
+  lines.push("## Project Overview");
+  lines.push("");
+  lines.push(`| Property | Value |`);
+  lines.push(`|----------|-------|`);
+  lines.push(`| Stack | ${stack.join(", ")} |`);
+  if (testFw) lines.push(`| Tests | ${testFw} |`);
+  lines.push(`| Files | ${analysis.totalFiles} (${hot.length} hot, ${warm.length} warm) |`);
+  lines.push(`| Tokens | ~${Math.round(analysis.totalTokens / 1e3)}K |`);
+  lines.push("");
+  lines.push("## Priority Files");
+  lines.push("");
+  lines.push("Read these files first \u2014 they are actively being worked on:");
+  lines.push("");
+  for (const f of hot.slice(0, 20)) {
+    lines.push(`- \`${f.relativePath}\` (~${Math.round(f.tokens / 1e3)}K tokens)`);
+  }
+  lines.push("");
+  lines.push("## Guidelines");
+  lines.push("");
+  lines.push("- Read hot-tier files first for full context");
+  lines.push("- Warm files can be read on demand");
+  lines.push("- Cold files are rarely needed \u2014 skip unless specifically asked");
+  lines.push("- Prefer minimal changes that solve the problem");
+  lines.push("- Always preserve existing code style and conventions");
+  if (testFw) {
+    lines.push(`- Tests use ${testFw} \u2014 run tests after changes`);
+  }
+  lines.push("");
+  lines.push("## Architecture");
+  lines.push("");
+  const topDirs = [...new Set(analysis.files.map((f) => f.relativePath.split("/")[0]))].slice(0, 10);
+  for (const dir of topDirs) {
+    const dirFiles = analysis.files.filter((f) => f.relativePath.startsWith(dir + "/"));
+    if (dirFiles.length > 0) {
+      lines.push(`- \`${dir}/\` \u2014 ${dirFiles.length} files, ~${Math.round(dirFiles.reduce((s, f) => s + f.tokens, 0) / 1e3)}K tokens`);
+    }
+  }
+  return lines.join("\n");
+}
+var AI_ADAPTERS = {
+  claude: { target: "claude", fileName: "CLAUDE.md", generate: generateClaude },
+  cursor: { target: "cursor", fileName: ".cursorrules", generate: generateCursor },
+  copilot: { target: "copilot", fileName: "copilot-instructions.md", generate: generateCopilot },
+  gemini: { target: "gemini", fileName: "GEMINI.md", generate: generateGemini },
+  windsurf: { target: "windsurf", fileName: ".windsurfrules", generate: generateWindsurf }
+};
+var ALL_AI_TARGETS = ["claude", "cursor", "copilot", "gemini", "windsurf"];
+function generateForTarget(target, analysis, config, options) {
+  const adapter = AI_ADAPTERS[target];
+  let content = adapter.generate(analysis, config);
+  if (options?.enhanced) {
+    const enhanced = buildEnhancedPrompt(analysis, { task: options.task });
+    content = enhanced;
+    if (options.task) {
+      content += "\n" + getTaskPromptBlock(options.task) + "\n";
+    }
+  }
+  return {
+    fileName: adapter.fileName,
+    content
+  };
+}
+function generateForAllTargets(analysis, config, options) {
+  return ALL_AI_TARGETS.map((target) => ({
+    target,
+    ...generateForTarget(target, analysis, config, options)
+  }));
+}
+
+// src/core/pr-context.ts
+import { resolve as resolve12 } from "path";
+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 generatePRContext(analysis, baseBranch = "main") {
+  const projectPath = resolve12(analysis.projectPath);
+  if (!await isGitRepo(projectPath)) {
+    return emptyPRContext(baseBranch);
+  }
+  const diffOutput = await git2(["diff", "--name-only", baseBranch, "HEAD"], projectPath);
+  const stagedOutput = await git2(["diff", "--name-only", "--cached"], projectPath);
+  const untrackedOutput = await git2(["diff", "--name-only", "HEAD"], projectPath);
+  const changedSet = /* @__PURE__ */ new Set();
+  for (const line of [...diffOutput.split("\n"), ...stagedOutput.split("\n"), ...untrackedOutput.split("\n")]) {
+    const f = line.trim();
+    if (f) changedSet.add(f);
+  }
+  const changedFiles = Array.from(changedSet);
+  const depSet = /* @__PURE__ */ new Set();
+  if (analysis.dependencyGraph) {
+    for (const changed of changedFiles) {
+      collectDependencies(changed, analysis.dependencyGraph, depSet, 2);
+    }
+    for (const f of changedFiles) depSet.delete(f);
+  }
+  const dependencies = Array.from(depSet);
+  const allRelevant = /* @__PURE__ */ new Set([...changedFiles, ...dependencies]);
+  const contextFiles = analysis.files.filter((f) => allRelevant.has(f.relativePath));
+  const totalTokens = contextFiles.reduce((s, f) => s + f.tokens, 0);
+  const generatedContent = renderPRContext(analysis, changedFiles, dependencies, contextFiles);
+  return {
+    baseBranch,
+    changedFiles,
+    dependencies,
+    contextFiles,
+    totalTokens,
+    generatedContent
+  };
+}
+function collectDependencies(file, graph, result, depth) {
+  if (depth <= 0) return;
+  const imports = graph.edges.filter((e) => e.from === file).map((e) => e.to);
+  for (const imp of imports) {
+    if (!result.has(imp)) {
+      result.add(imp);
+      collectDependencies(imp, graph, result, depth - 1);
+    }
+  }
+}
+function renderPRContext(analysis, changedFiles, dependencies, contextFiles) {
+  const lines = [];
+  const totalTokens = contextFiles.reduce((s, f) => s + f.tokens, 0);
+  lines.push(`# PR Context \u2014 ${analysis.projectName}`);
+  lines.push("");
+  lines.push(`> Focused context for code review. ${changedFiles.length} changed files + ${dependencies.length} dependencies.`);
+  lines.push("");
+  lines.push("## Changed Files");
+  lines.push("");
+  for (const f of changedFiles) {
+    const info = contextFiles.find((c) => c.relativePath === f);
+    const tokens = info ? `~${Math.round(info.tokens / 1e3)}K tokens` : "";
+    lines.push(`- \`${f}\` ${tokens}`);
+  }
+  lines.push("");
+  if (dependencies.length > 0) {
+    lines.push("## Dependencies (context)");
+    lines.push("");
+    for (const f of dependencies) {
+      const info = contextFiles.find((c) => c.relativePath === f);
+      const tokens = info ? `~${Math.round(info.tokens / 1e3)}K tokens` : "";
+      lines.push(`- \`${f}\` ${tokens}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Review Guidelines");
+  lines.push("");
+  lines.push("- Focus on the changed files listed above");
+  lines.push("- Dependencies are included for type/interface context only");
+  lines.push(`- Total context: ~${Math.round(totalTokens / 1e3)}K tokens`);
+  return lines.join("\n");
+}
+function emptyPRContext(baseBranch) {
+  return {
+    baseBranch,
+    changedFiles: [],
+    dependencies: [],
+    contextFiles: [],
+    totalTokens: 0,
+    generatedContent: "# No git repository found\n"
+  };
+}
+
+// src/core/explain.ts
+import { resolve as resolve13 } from "path";
+async function explainTier(file, projectPath, thresholds) {
+  const factors = [];
+  const modDate = file.lastModified instanceof Date ? file.lastModified : new Date(file.lastModified);
+  const daysSinceModified = (Date.now() - modDate.getTime()) / (1e3 * 60 * 60 * 24);
+  let recencyImpact = "neutral";
+  if (daysSinceModified <= thresholds.hotDays) recencyImpact = "promotes";
+  else if (daysSinceModified > thresholds.warmDays) recencyImpact = "demotes";
+  factors.push({
+    name: "Recency",
+    value: `Modified ${Math.round(daysSinceModified)}d ago (hot: \u2264${thresholds.hotDays}d, warm: \u2264${thresholds.warmDays}d)`,
+    impact: recencyImpact,
+    weight: 3
+  });
+  const cost = estimateCost(file.tokens, "sonnet");
+  factors.push({
+    name: "Token Cost",
+    value: `${file.tokens.toLocaleString()} tokens (~${cost.formatted}/read)`,
+    impact: "neutral",
+    weight: 1
+  });
+  if (file.isHub !== void 0) {
+    factors.push({
+      name: "Hub Status",
+      value: file.isHub ? `Hub file \u2014 imported by ${file.importedByCount ?? 0} files` : "Not a hub file",
+      impact: file.isHub && (file.importedByCount ?? 0) >= 3 ? "promotes" : "neutral",
+      weight: file.isHub ? 2 : 0
+    });
+  }
+  if (file.complexity !== void 0) {
+    const complexityLevel = file.complexity > 30 ? "High" : file.complexity > 10 ? "Medium" : "Low";
+    factors.push({
+      name: "Complexity",
+      value: `Cyclomatic: ${file.complexity} (${complexityLevel})`,
+      impact: file.complexity > 30 ? "promotes" : "neutral",
+      weight: file.complexity > 30 ? 2 : 1
+    });
+  }
+  const absPath = resolve13(projectPath);
+  if (await isGitRepo(absPath)) {
+    const gitInfo = await getFileGitInfo(absPath, file.relativePath);
+    if (gitInfo) {
+      factors.push({
+        name: "Git Activity",
+        value: `${gitInfo.commitCount} commits, last by ${gitInfo.lastAuthor}`,
+        impact: gitInfo.isInDiff ? "promotes" : gitInfo.commitCount >= 20 ? "promotes" : "neutral",
+        weight: gitInfo.isInDiff ? 3 : 1
+      });
+      if (gitInfo.isInDiff) {
+        factors.push({
+          name: "In Current Diff",
+          value: `${gitInfo.linesChanged} lines changed`,
+          impact: "promotes",
+          weight: 3
+        });
+      }
+      if (gitInfo.isNewFile) {
+        factors.push({
+          name: "New File",
+          value: "Untracked / newly created",
+          impact: "promotes",
+          weight: 3
+        });
+      }
+    }
+  }
+  const coreExts = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "py", "go", "rs", "java"]);
+  const isCore = coreExts.has(file.extension);
+  factors.push({
+    name: "File Type",
+    value: `.${file.extension} \u2014 ${isCore ? "Core source file" : "Supporting file"}`,
+    impact: "neutral",
+    weight: isCore ? 1 : 0
+  });
+  const promotingFactors = factors.filter((f) => f.impact === "promotes");
+  const demotingFactors = factors.filter((f) => f.impact === "demotes");
+  let summary;
+  if (file.tier === "hot") {
+    const reasons = promotingFactors.map((f) => f.name.toLowerCase()).join(", ") || "recent modification";
+    summary = `\u{1F525} Hot \u2014 Read first. Promoted by: ${reasons}.`;
+  } else if (file.tier === "warm") {
+    summary = `\u{1F321}\uFE0F Warm \u2014 Read if needed.`;
+    if (promotingFactors.length > 0) {
+      summary += ` Near hot due to: ${promotingFactors.map((f) => f.name.toLowerCase()).join(", ")}.`;
+    }
+    if (demotingFactors.length > 0) {
+      summary += ` Held back by: ${demotingFactors.map((f) => f.name.toLowerCase()).join(", ")}.`;
+    }
+  } else {
+    const reasons = demotingFactors.map((f) => f.name.toLowerCase()).join(", ") || "inactivity";
+    summary = `\u2744\uFE0F Cold \u2014 Skip unless needed. Reason: ${reasons}.`;
+  }
+  return {
+    file: file.relativePath,
+    tier: file.tier,
+    factors,
+    summary
+  };
+}
+function formatExplanation(explanation) {
+  const lines = [];
+  lines.push(`${explanation.summary}`);
+  lines.push("");
+  lines.push("Factors:");
+  for (const factor of explanation.factors) {
+    const icon = factor.impact === "promotes" ? "\u2191" : factor.impact === "demotes" ? "\u2193" : "\xB7";
+    lines.push(`  ${icon} ${factor.name}: ${factor.value}`);
+  }
+  return lines.join("\n");
+}
+
+// src/core/routing.ts
+var ROUTING_RULES = [
+  // Simple tasks → Haiku (cheapest)
+  { task: "simple-edit", maxComplexity: 10, maxFiles: 3, defaultModel: "haiku" },
+  { task: "docs", maxComplexity: 5, maxFiles: 5, defaultModel: "haiku" },
+  { task: "test", maxComplexity: 20, maxFiles: 10, defaultModel: "haiku" },
+  // Moderate tasks → Sonnet (balanced)
+  { task: "debug", maxComplexity: 30, maxFiles: 10, defaultModel: "sonnet" },
+  { task: "review", maxComplexity: 40, maxFiles: 20, defaultModel: "sonnet" },
+  { task: "refactor", maxComplexity: 30, maxFiles: 15, defaultModel: "sonnet" },
+  // Complex tasks → Opus (best reasoning)
+  { task: "feature", maxComplexity: 50, maxFiles: 30, defaultModel: "sonnet" },
+  { task: "architecture", maxComplexity: 100, maxFiles: 50, defaultModel: "opus" }
+];
+var ALL_TASK_TYPES = [
+  "simple-edit",
+  "docs",
+  "test",
+  "debug",
+  "review",
+  "refactor",
+  "feature",
+  "architecture"
+];
+function recommendModel(task, analysis, targetFiles) {
+  const rule = ROUTING_RULES.find((r) => r.task === task);
+  const relevantFiles = targetFiles ? analysis.files.filter((f) => targetFiles.some((t) => f.relativePath.includes(t))) : analysis.files.filter((f) => f.tier === "hot");
+  const avgComplexity = getAvgComplexity(relevantFiles);
+  const fileCount = relevantFiles.length;
+  const totalTokens = relevantFiles.reduce((s, f) => s + f.tokens, 0);
+  let recommended = rule.defaultModel;
+  if (avgComplexity > rule.maxComplexity || fileCount > rule.maxFiles) {
+    recommended = upgradeModel(recommended);
+  }
+  if (avgComplexity < rule.maxComplexity * 0.3 && fileCount <= 3) {
+    recommended = downgradeModel(recommended);
+  }
+  const cost = estimateCost(totalTokens, recommended);
+  const alternatives = buildAlternatives(recommended, avgComplexity, fileCount, totalTokens);
+  return {
+    task,
+    recommended,
+    reason: buildReason(task, recommended, avgComplexity, fileCount),
+    estimatedTokens: totalTokens,
+    estimatedCost: cost.formatted,
+    alternatives
+  };
+}
+function recommendModelForFiles(files) {
+  const avgComplexity = getAvgComplexity(files);
+  const totalTokens = files.reduce((s, f) => s + f.tokens, 0);
+  if (avgComplexity <= 10 && totalTokens < 5e3) return "haiku";
+  if (avgComplexity <= 30 && totalTokens < 5e4) return "sonnet";
+  return "opus";
+}
+function getTaskDescription(task) {
+  const descriptions = {
+    "simple-edit": "Small change \u2014 rename, fix typo, update config",
+    "docs": "Documentation \u2014 README, comments, JSDoc, guides",
+    "test": "Write or fix tests",
+    "debug": "Find and fix a bug",
+    "review": "Code review \u2014 analyze quality, suggest improvements",
+    "refactor": "Refactor code \u2014 restructure without changing behavior",
+    "feature": "Build a new feature",
+    "architecture": "Architecture decisions \u2014 design patterns, major restructuring"
+  };
+  return descriptions[task];
+}
+function getAvgComplexity(files) {
+  const withComplexity = files.filter((f) => f.complexity !== void 0);
+  if (withComplexity.length === 0) return 10;
+  return withComplexity.reduce((s, f) => s + (f.complexity ?? 0), 0) / withComplexity.length;
+}
+function upgradeModel(model) {
+  if (model === "haiku") return "sonnet";
+  if (model === "sonnet") return "opus";
+  return "opus";
+}
+function downgradeModel(model) {
+  if (model === "opus") return "sonnet";
+  if (model === "sonnet") return "haiku";
+  return "haiku";
+}
+function buildReason(task, model, complexity, files) {
+  const taskLabel = getTaskDescription(task);
+  const complexityLabel = complexity > 30 ? "high" : complexity > 10 ? "moderate" : "low";
+  if (model === "haiku") {
+    return `${taskLabel}. Low complexity (${Math.round(complexity)}) and few files (${files}) \u2192 Haiku is sufficient and cheapest.`;
+  }
+  if (model === "opus") {
+    return `${taskLabel}. ${complexityLabel} complexity (${Math.round(complexity)}) across ${files} files \u2192 Opus recommended for deep reasoning.`;
+  }
+  return `${taskLabel}. ${complexityLabel} complexity (${Math.round(complexity)}) across ${files} files \u2192 Sonnet balances quality and cost.`;
+}
+function buildAlternatives(recommended, complexity, files, tokens) {
+  const alts = [];
+  if (recommended !== "haiku") {
+    const haikuCost = estimateCost(tokens, "haiku");
+    alts.push({ model: "haiku", reason: `Cheapest (${haikuCost.formatted}) \u2014 use if task is straightforward` });
+  }
+  if (recommended !== "sonnet") {
+    const sonnetCost = estimateCost(tokens, "sonnet");
+    alts.push({ model: "sonnet", reason: `Balanced (${sonnetCost.formatted}) \u2014 good for most tasks` });
+  }
+  if (recommended !== "opus") {
+    const opusCost = estimateCost(tokens, "opus");
+    alts.push({ model: "opus", reason: `Best reasoning (${opusCost.formatted}) \u2014 use for complex logic` });
+  }
+  return alts;
+}
+
+// src/core/local-config.ts
+import { join as join9, resolve as resolve14 } from "path";
+import { readFile as readFile8, writeFile as writeFile2, mkdir as mkdir2, access } from "fs/promises";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var LOCAL_CTO_DIR = ".cto";
+var LOCAL_CONFIG_FILE = "config.yaml";
+function getLocalCTOPath(projectPath) {
+  return join9(resolve14(projectPath), LOCAL_CTO_DIR);
+}
+function getLocalConfigPath(projectPath) {
+  return join9(getLocalCTOPath(projectPath), LOCAL_CONFIG_FILE);
+}
+async function hasLocalConfig(projectPath) {
+  try {
+    await access(getLocalConfigPath(projectPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initLocalProject(projectPath, config) {
+  const localDir = getLocalCTOPath(projectPath);
+  await mkdir2(localDir, { recursive: true });
+  const localConfig = {
+    version: CTO_VERSION,
+    autoRouting: true,
+    ...config
+  };
+  const configPath = getLocalConfigPath(projectPath);
+  await writeFile2(configPath, stringify2(localConfig), "utf-8");
+  const gitignorePath = join9(localDir, ".gitignore");
+  const gitignoreContent = [
+    "# CTO local cache (do not commit)",
+    "analysis.json",
+    "sessions/",
+    "",
+    "# Config IS committed (shared with team)",
+    "!config.yaml",
+    "!.gitignore",
+    ""
+  ].join("\n");
+  await writeFile2(gitignorePath, gitignoreContent, "utf-8");
+  return configPath;
+}
+async function loadLocalConfig(projectPath) {
+  try {
+    const content = await readFile8(getLocalConfigPath(projectPath), "utf-8");
+    return parse2(content);
+  } catch {
+    return null;
+  }
+}
+async function saveLocalConfig(projectPath, config) {
+  const localDir = getLocalCTOPath(projectPath);
+  await mkdir2(localDir, { recursive: true });
+  await writeFile2(getLocalConfigPath(projectPath), stringify2(config), "utf-8");
+}
+function mergeLocalWithGlobal(globalConfig, localConfig) {
+  return {
+    ...globalConfig,
+    version: localConfig.version ?? globalConfig.version,
+    model: localConfig.model ?? globalConfig.model,
+    tiering: {
+      ...globalConfig.tiering,
+      ...localConfig.tiering
+    },
+    ignoreDirs: localConfig.ignoreDirs ?? globalConfig.ignoreDirs,
+    extensions: {
+      ...globalConfig.extensions,
+      ...localConfig.extensions
+    }
+  };
+}
+async function detectProjectRoot(startPath) {
+  let current = resolve14(startPath);
+  const root = resolve14("/");
+  while (current !== root) {
+    if (await hasLocalConfig(current)) {
+      return current;
+    }
+    for (const marker of ["package.json", "Cargo.toml", "go.mod", "pyproject.toml", "pom.xml", ".git"]) {
+      try {
+        await access(join9(current, marker));
+        return current;
+      } catch {
+      }
+    }
+    current = resolve14(current, "..");
+  }
+  return resolve14(startPath);
+}
+
+// src/core/sdd.ts
+import "ts-morph";
+import { resolve as resolve15, relative as relative8 } from "path";
+function extractSpecs(projectPath, files) {
+  const absPath = resolve15(projectPath);
+  const tsFiles = files.filter((f) => ["ts", "tsx"].includes(f.extension)).map((f) => f.path);
+  const empty = {
+    projectName: projectPath.split("/").pop() ?? "project",
+    extractedAt: /* @__PURE__ */ new Date(),
+    totalSpecs: 0,
+    entries: [],
+    byFile: {},
+    byKind: {}
+  };
+  if (tsFiles.length === 0) return empty;
+  const project = createProject(projectPath, tsFiles);
+  const entries = [];
+  for (const sf of project.getSourceFiles()) {
+    const rel = relative8(absPath, sf.getFilePath());
+    if (rel.startsWith("..") || rel.includes("node_modules")) continue;
+    extractInterfaces(sf, rel, entries);
+    extractTypeAliases(sf, rel, entries);
+    extractEnums(sf, rel, entries);
+    extractFunctionSigs(sf, rel, entries);
+    extractClassSigs(sf, rel, entries);
+  }
+  const byFile = {};
+  const byKind = {};
+  for (const e of entries) {
+    (byFile[e.file] ??= []).push(e);
+    (byKind[e.kind] ??= []).push(e);
+  }
+  return {
+    projectName: projectPath.split("/").pop() ?? "project",
+    extractedAt: /* @__PURE__ */ new Date(),
+    totalSpecs: entries.length,
+    entries,
+    byFile,
+    byKind
+  };
+}
+function generateSpecDocument(map) {
+  const lines = [];
+  lines.push(`# Specification Document \u2014 ${map.projectName}`);
+  lines.push("");
+  lines.push("> **Specification-Driven Development (SDD)**");
+  lines.push("> This document is the single source of truth. All implementations MUST conform to these specs.");
+  lines.push(`> Extracted: ${map.extractedAt.toISOString()} | Total specs: ${map.totalSpecs}`);
+  lines.push("");
+  const kindCounts = Object.entries(map.byKind).map(([k, v]) => `${v.length} ${k}s`);
+  lines.push(`**Specs:** ${kindCounts.join(" \xB7 ")}`);
+  lines.push("");
+  const interfaces = (map.byKind["interface"] ?? []).filter((e) => e.exported);
+  if (interfaces.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Interfaces");
+    lines.push("");
+    lines.push("These are the primary contracts. Implementations MUST satisfy every property.");
+    lines.push("");
+    for (const entry of interfaces) {
+      lines.push(`### \`${entry.name}\``);
+      if (entry.jsdoc) lines.push(`> ${entry.jsdoc}`);
+      lines.push(`\u{1F4CD} \`${entry.file}:${entry.line}\``);
+      if (entry.extends && entry.extends.length > 0) {
+        lines.push(`\u2197\uFE0F Extends: ${entry.extends.map((e) => `\`${e}\``).join(", ")}`);
+      }
+      lines.push("");
+      if (entry.properties && entry.properties.length > 0) {
+        lines.push("| Property | Type | Required |");
+        lines.push("|----------|------|----------|");
+        for (const p of entry.properties) {
+          lines.push(`| \`${p.name}\` | \`${p.type}\` | ${p.optional ? "No" : "**Yes**"} |`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  const types = (map.byKind["type"] ?? []).filter((e) => e.exported);
+  if (types.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Types");
+    lines.push("");
+    for (const entry of types) {
+      lines.push(`- **\`${entry.name}\`** \u2014 \`${entry.signature}\` (\`${entry.file}:${entry.line}\`)`);
+    }
+    lines.push("");
+  }
+  const enums = (map.byKind["enum"] ?? []).filter((e) => e.exported);
+  if (enums.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Enums");
+    lines.push("");
+    for (const entry of enums) {
+      lines.push(`- **\`${entry.name}\`** \u2014 \`${entry.signature}\` (\`${entry.file}:${entry.line}\`)`);
+    }
+    lines.push("");
+  }
+  const fns = (map.byKind["function"] ?? []).filter((e) => e.exported);
+  if (fns.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Functions (Public API)");
+    lines.push("");
+    lines.push("These function signatures are the public API. Do NOT change signatures without updating this spec.");
+    lines.push("");
+    const byFile = {};
+    for (const fn of fns) {
+      (byFile[fn.file] ??= []).push(fn);
+    }
+    for (const [file, fileFns] of Object.entries(byFile)) {
+      lines.push(`#### \`${file}\``);
+      lines.push("```typescript");
+      for (const fn of fileFns) {
+        if (fn.jsdoc) lines.push(`// ${fn.jsdoc}`);
+        lines.push(`export ${fn.signature};`);
+      }
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  const classes = (map.byKind["class"] ?? []).filter((e) => e.exported);
+  if (classes.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Classes");
+    lines.push("");
+    for (const entry of classes) {
+      lines.push(`- **\`${entry.name}\`** (\`${entry.file}:${entry.line}\`)`);
+      if (entry.extends) lines.push(`  - Extends: ${entry.extends.join(", ")}`);
+      lines.push(`  - \`${entry.signature}\``);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## SDD Rules");
+  lines.push("");
+  lines.push("1. **Spec first** \u2014 Define or update interfaces/types BEFORE writing implementation");
+  lines.push("2. **Contract compliance** \u2014 Every function must satisfy its declared return type");
+  lines.push("3. **No implicit any** \u2014 All parameters and returns must be explicitly typed");
+  lines.push("4. **Interface segregation** \u2014 Prefer small, focused interfaces over large ones");
+  lines.push("5. **Backward compatibility** \u2014 Do NOT remove or rename properties from existing interfaces");
+  lines.push("6. **Document changes** \u2014 Update this spec when adding/modifying public API");
+  lines.push("7. **Test against spec** \u2014 Tests should verify contract compliance, not implementation details");
+  lines.push("");
+  return lines.join("\n");
+}
+function validateSpecs(projectPath, files) {
+  const absPath = resolve15(projectPath);
+  const tsFiles = files.filter((f) => ["ts", "tsx"].includes(f.extension)).map((f) => f.path);
+  const errors = [];
+  const warnings = [];
+  let totalFunctions = 0;
+  let withReturnType = 0;
+  let totalInterfaces = 0;
+  let fullyDocumented = 0;
+  let exportedWithoutJSDoc = 0;
+  if (tsFiles.length === 0) {
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      stats: { totalFunctions: 0, withReturnType: 0, totalInterfaces: 0, fullyDocumented: 0, exportedWithoutJSDoc: 0 }
+    };
+  }
+  const project = createProject(projectPath, tsFiles);
+  for (const sf of project.getSourceFiles()) {
+    const rel = relative8(absPath, sf.getFilePath());
+    if (rel.startsWith("..") || rel.includes("node_modules")) continue;
+    for (const fn of sf.getFunctions()) {
+      const name = fn.getName();
+      if (!name) continue;
+      totalFunctions++;
+      const hasExplicitReturn = fn.getReturnTypeNode() !== void 0;
+      if (hasExplicitReturn) withReturnType++;
+      if (fn.isExported()) {
+        if (!hasExplicitReturn) {
+          warnings.push({
+            file: rel,
+            name,
+            line: fn.getStartLineNumber(),
+            message: `Exported function '${name}' has no explicit return type. SDD requires explicit types for public API.`
+          });
+        }
+        const jsDocs = fn.getJsDocs();
+        if (jsDocs.length === 0) {
+          exportedWithoutJSDoc++;
+          warnings.push({
+            file: rel,
+            name,
+            line: fn.getStartLineNumber(),
+            message: `Exported function '${name}' has no JSDoc. SDD recommends documenting all public API.`
+          });
+        }
+        for (const param of fn.getParameters()) {
+          if (!param.getTypeNode()) {
+            errors.push({
+              file: rel,
+              name: `${name}(${param.getName()})`,
+              line: fn.getStartLineNumber(),
+              message: `Parameter '${param.getName()}' in '${name}' has no explicit type annotation.`
+            });
+          }
+        }
+      }
+    }
+    for (const iface of sf.getInterfaces()) {
+      totalInterfaces++;
+      const jsDocs = iface.getJsDocs();
+      if (jsDocs.length > 0) fullyDocumented++;
+      if (iface.isExported() && jsDocs.length === 0) {
+        exportedWithoutJSDoc++;
+      }
+      if (iface.getProperties().length === 0 && iface.getMethods().length === 0) {
+        warnings.push({
+          file: rel,
+          name: iface.getName(),
+          line: iface.getStartLineNumber(),
+          message: `Interface '${iface.getName()}' is empty. Consider removing or adding properties.`
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    stats: {
+      totalFunctions,
+      withReturnType,
+      totalInterfaces,
+      fullyDocumented,
+      exportedWithoutJSDoc
+    }
+  };
+}
+function getJSDoc(node) {
+  const docs = node.getJsDocs();
+  if (docs.length === 0) return void 0;
+  const desc = docs[0].getDescription().trim();
+  return desc || void 0;
+}
+function extractInterfaces(sf, file, out) {
+  for (const iface of sf.getInterfaces()) {
+    const props = iface.getProperties().map((p) => ({
+      name: p.getName(),
+      type: p.getType().getText(p),
+      optional: p.hasQuestionToken()
+    }));
+    const ext = iface.getExtends().map((e) => e.getText());
+    out.push({
+      kind: "interface",
+      name: iface.getName(),
+      file,
+      line: iface.getStartLineNumber(),
+      exported: iface.isExported(),
+      signature: buildInterfaceSig(iface.getName(), props, ext),
+      properties: props,
+      extends: ext.length > 0 ? ext : void 0,
+      jsdoc: getJSDoc(iface)
+    });
+  }
+}
+function extractTypeAliases(sf, file, out) {
+  for (const ta of sf.getTypeAliases()) {
+    out.push({
+      kind: "type",
+      name: ta.getName(),
+      file,
+      line: ta.getStartLineNumber(),
+      exported: ta.isExported(),
+      signature: `type ${ta.getName()} = ${ta.getTypeNode()?.getText() ?? ta.getType().getText(ta)}`,
+      jsdoc: getJSDoc(ta)
+    });
+  }
+}
+function extractEnums(sf, file, out) {
+  for (const en of sf.getEnums()) {
+    const members = en.getMembers().map((m) => m.getName());
+    out.push({
+      kind: "enum",
+      name: en.getName(),
+      file,
+      line: en.getStartLineNumber(),
+      exported: en.isExported(),
+      signature: `enum ${en.getName()} { ${members.join(", ")} }`,
+      jsdoc: getJSDoc(en)
+    });
+  }
+}
+function extractFunctionSigs(sf, file, out) {
+  for (const fn of sf.getFunctions()) {
+    const name = fn.getName();
+    if (!name) continue;
+    const params = fn.getParameters().map((p) => {
+      const typeNode = p.getTypeNode();
+      return `${p.getName()}: ${typeNode?.getText() ?? p.getType().getText(p)}`;
+    });
+    const retNode = fn.getReturnTypeNode();
+    const retType = retNode?.getText() ?? fn.getReturnType().getText(fn);
+    out.push({
+      kind: "function",
+      name,
+      file,
+      line: fn.getStartLineNumber(),
+      exported: fn.isExported(),
+      signature: `function ${name}(${params.join(", ")}): ${retType}`,
+      jsdoc: getJSDoc(fn)
+    });
+  }
+}
+function extractClassSigs(sf, file, out) {
+  for (const cls of sf.getClasses()) {
+    const name = cls.getName();
+    if (!name) continue;
+    const methods = cls.getMethods().map((m) => {
+      const params = m.getParameters().map((p) => `${p.getName()}: ${p.getType().getText(p)}`);
+      const ret = m.getReturnType().getText(m);
+      return `${m.getName()}(${params.join(", ")}): ${ret}`;
+    });
+    const ext = cls.getExtends()?.getText();
+    const impl = cls.getImplements().map((i) => i.getText());
+    out.push({
+      kind: "class",
+      name,
+      file,
+      line: cls.getStartLineNumber(),
+      exported: cls.isExported(),
+      signature: `class ${name}${ext ? ` extends ${ext}` : ""}${impl.length > 0 ? ` implements ${impl.join(", ")}` : ""} { ${methods.join("; ")} }`,
+      extends: ext ? [ext, ...impl] : impl.length > 0 ? impl : void 0,
+      jsdoc: getJSDoc(cls)
+    });
+  }
+}
+function buildInterfaceSig(name, props, ext) {
+  const extStr = ext.length > 0 ? ` extends ${ext.join(", ")}` : "";
+  const propsStr = props.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join("; ");
+  return `interface ${name}${extStr} { ${propsStr} }`;
+}
+
+// src/core/focus.ts
+import { resolve as resolve16, relative as relative9 } from "path";
+function buildFocusContext(analysis, targetPaths, depth = 1) {
+  const absProjectPath = resolve16(analysis.projectPath);
+  const normalizedTargets = targetPaths.map((p) => {
+    if (p.startsWith("/")) return relative9(absProjectPath, p);
+    return p;
+  });
+  const targetFiles = analysis.files.filter(
+    (f) => normalizedTargets.some((t) => f.relativePath === t || f.relativePath.endsWith(t))
+  );
+  if (targetFiles.length === 0) {
+    return {
+      targetFiles: [],
+      dependencies: [],
+      allFiles: [],
+      totalTokens: 0,
+      savedTokens: analysis.totalTokens,
+      savingsPercent: 100
+    };
+  }
+  const depPaths = /* @__PURE__ */ new Set();
+  try {
+    const tsFiles = analysis.files.filter((f) => ["ts", "tsx", "js", "jsx"].includes(f.extension)).map((f) => f.path);
+    if (tsFiles.length > 0) {
+      const project = createProject(analysis.projectPath, tsFiles);
+      const graph = buildDependencyGraph(project, analysis.projectPath);
+      const visited = /* @__PURE__ */ new Set();
+      let frontier = targetFiles.map((f) => f.relativePath);
+      for (let d = 0; d < depth; d++) {
+        const nextFrontier = [];
+        for (const file of frontier) {
+          if (visited.has(file)) continue;
+          visited.add(file);
+          for (const edge of graph.edges) {
+            if (edge.from === file && !visited.has(edge.to)) {
+              depPaths.add(edge.to);
+              nextFrontier.push(edge.to);
+            }
+            if (edge.to === file && !visited.has(edge.from)) {
+              depPaths.add(edge.from);
+              nextFrontier.push(edge.from);
+            }
+          }
+        }
+        frontier = nextFrontier;
+      }
+    }
+  } catch {
+  }
+  const targetRelPaths = new Set(targetFiles.map((f) => f.relativePath));
+  const dependencies = analysis.files.filter(
+    (f) => depPaths.has(f.relativePath) && !targetRelPaths.has(f.relativePath)
+  );
+  const allFiles = [...targetFiles, ...dependencies];
+  const totalTokens = allFiles.reduce((sum, f) => sum + f.tokens, 0);
+  const savedTokens = analysis.totalTokens - totalTokens;
+  const savingsPercent = analysis.totalTokens > 0 ? Math.round(savedTokens / analysis.totalTokens * 100) : 0;
+  return {
+    targetFiles,
+    dependencies,
+    allFiles,
+    totalTokens,
+    savedTokens,
+    savingsPercent
+  };
+}
+function formatFocusDocument(analysis, focus) {
+  const lines = [];
+  lines.push(`# Focus Context \u2014 ${analysis.projectName}`);
+  lines.push("");
+  lines.push("> Focused context for targeted work. Only relevant files included.");
+  lines.push("");
+  lines.push(`| Property | Value |`);
+  lines.push(`|----------|-------|`);
+  lines.push(`| Target files | ${focus.targetFiles.length} |`);
+  lines.push(`| Dependencies | ${focus.dependencies.length} |`);
+  lines.push(`| Total tokens | ~${Math.round(focus.totalTokens / 1e3)}K |`);
+  lines.push(`| Saved | ~${Math.round(focus.savedTokens / 1e3)}K tokens (${focus.savingsPercent}% reduction) |`);
+  lines.push("");
+  lines.push("## Target Files (read these first)");
+  lines.push("");
+  for (const f of focus.targetFiles) {
+    lines.push(`- \`${f.relativePath}\` (~${Math.round(f.tokens / 1e3)}K tokens)`);
+  }
+  lines.push("");
+  if (focus.dependencies.length > 0) {
+    lines.push("## Dependencies (read on demand)");
+    lines.push("");
+    for (const f of focus.dependencies) {
+      lines.push(`- \`${f.relativePath}\` (~${Math.round(f.tokens / 1e3)}K tokens)`);
+    }
+    lines.push("");
+  }
+  lines.push("## Instructions");
+  lines.push("");
+  lines.push("- Focus ONLY on the target files listed above");
+  lines.push("- Read dependencies only when needed to understand imports");
+  lines.push("- Do NOT modify files outside this focus set unless asked");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/core/todo-scanner.ts
+import { readFile as readFile9 } from "fs/promises";
+var TODO_PATTERNS = [
+  { type: "FIXME", regex: /\/\/\s*FIXME[:\s]*(.*)/i },
+  { type: "TODO", regex: /\/\/\s*TODO[:\s]*(.*)/i },
+  { type: "HACK", regex: /\/\/\s*HACK[:\s]*(.*)/i },
+  { type: "XXX", regex: /\/\/\s*XXX[:\s]*(.*)/i },
+  { type: "NOTE", regex: /\/\/\s*NOTE[:\s]*(.*)/i },
+  // Also match # comments (Python, Ruby, YAML)
+  { type: "FIXME", regex: /#\s*FIXME[:\s]*(.*)/i },
+  { type: "TODO", regex: /#\s*TODO[:\s]*(.*)/i },
+  { type: "HACK", regex: /#\s*HACK[:\s]*(.*)/i }
+];
+function getPriority(type, tier) {
+  if (type === "FIXME" || type === "HACK") {
+    return tier === "hot" ? "high" : tier === "warm" ? "high" : "medium";
+  }
+  if (type === "TODO") {
+    return tier === "hot" ? "high" : tier === "warm" ? "medium" : "low";
+  }
+  if (type === "XXX") return tier === "hot" ? "high" : "medium";
+  return "low";
+}
+async function scanTodos(files) {
+  const items = [];
+  for (const file of files) {
+    try {
+      const content = await readFile9(file.path, "utf-8");
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TODO_PATTERNS) {
+          const match = line.match(pattern.regex);
+          if (match) {
+            const text = match[1]?.trim() || "(no description)";
+            items.push({
+              file: file.relativePath,
+              line: i + 1,
+              type: pattern.type,
+              text,
+              tier: file.tier,
+              priority: getPriority(pattern.type, file.tier)
+            });
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const tierOrder = { hot: 0, warm: 1, cold: 2 };
+  const prioOrder = { high: 0, medium: 1, low: 2 };
+  items.sort(
+    (a, b) => prioOrder[a.priority] - prioOrder[b.priority] || tierOrder[a.tier] - tierOrder[b.tier]
+  );
+  const byType = {};
+  const byPriority = {};
+  for (const item of items) {
+    (byType[item.type] ??= []).push(item);
+    (byPriority[item.priority] ??= []).push(item);
+  }
+  return { items, byType, byPriority, totalCount: items.length };
+}
+
+// src/core/gitignore-parser.ts
+import { readFile as readFile10 } from "fs/promises";
+import { join as join10, resolve as resolve17 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var KNOWN_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "vendor",
+  "target",
+  "bin",
+  "obj",
+  ".idea",
+  ".vscode",
+  ".DS_Store",
+  ".turbo",
+  ".vercel",
+  ".output",
+  ".cache",
+  "tmp",
+  ".tmp",
+  ".parcel-cache",
+  ".webpack",
+  ".rollup",
+  ".sass-cache",
+  "bower_components",
+  ".gradle",
+  ".mvn"
+]);
+async function parseGitignore(projectPath) {
+  const absPath = resolve17(projectPath);
+  const gitignorePath = join10(absPath, ".gitignore");
+  if (!existsSync3(gitignorePath)) return null;
+  const content = await readFile10(gitignorePath, "utf-8");
+  const lines = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const ignoreDirs = [];
+  const ignorePatterns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (line.startsWith("!")) continue;
+    const cleaned = line.replace(/\/$/, "").replace(/^\//, "");
+    if (seen.has(cleaned)) continue;
+    seen.add(cleaned);
+    if (isDirPattern(line, cleaned)) {
+      ignoreDirs.push(cleaned);
+    } else if (isFilePattern(line)) {
+      ignorePatterns.push(line);
+    }
+  }
+  return { ignoreDirs, ignorePatterns, raw: lines };
+}
+function isDirPattern(raw, cleaned) {
+  if (raw.endsWith("/")) return true;
+  if (KNOWN_DIRS.has(cleaned)) return true;
+  if (!cleaned.includes(".") && !cleaned.includes("*") && !cleaned.includes("/")) return true;
+  if (cleaned.includes("/") && !cleaned.includes("*") && !cleaned.includes(".")) return true;
+  return false;
+}
+function isFilePattern(line) {
+  if (line.startsWith("*.")) return true;
+  if (line.includes(".") && !line.includes("/") && !line.endsWith("/")) return true;
+  return false;
+}
+function mergeWithDefaults(gitignoreResult, defaultDirs, defaultPatterns) {
+  const dirSet = /* @__PURE__ */ new Set([...defaultDirs, ...gitignoreResult.ignoreDirs]);
+  const patternSet = /* @__PURE__ */ new Set([...defaultPatterns, ...gitignoreResult.ignorePatterns]);
+  return {
+    ignoreDirs: Array.from(dirSet).sort(),
+    ignorePatterns: Array.from(patternSet).sort()
+  };
+}
+export {
+  AI_ADAPTERS,
+  ALL_AI_TARGETS,
+  ALL_TASK_TYPES,
+  DEFAULT_SECURITY_CONFIG,
+  MODEL_PRICING,
+  ProjectWatcher,
+  ROUTING_RULES,
+  analyzeAllComplexity,
+  analyzeFileComplexity,
+  analyzeProject,
+  applyArtifact,
+  buildAntiHallucination,
+  buildChainOfThought,
+  buildConstraints,
+  buildDependencyGraph,
+  buildEnhancedPrompt,
+  buildFilePriority,
+  buildFocusContext,
+  buildIntegrityManifest,
+  buildOutputFormat,
+  buildRolePriming,
+  buildTierSummary,
+  classifyFile,
+  classifyFileWithAST,
+  classifyFileWithGit,
+  cleanProject,
+  countTokensChars4,
+  countTokensTiktoken,
+  createProject,
+  detectProjectRoot,
+  detectStack,
+  detectTestFramework,
+  diffArtifact,
+  endSession,
+  enrichFilesWithAST,
+  enrichFilesWithGit,
+  estimateCost,
+  estimateFileTokens,
+  estimateMonthlySavings,
+  estimateSessionCost,
+  estimateTokens2 as estimateTokens,
+  estimateWeeklyCost,
+  explainTier,
+  exportMetrics,
+  extractSpecs,
+  formatExplanation,
+  formatFocusDocument,
+  freeEncoder,
+  generateClaudeMd,
+  generateClaudeignore,
+  generateForAllTargets,
+  generateForTarget,
+  generatePRContext,
+  generateProjectReport,
+  generateSpecDocument,
+  generateWeeklyReport,
+  getActiveDevelopers,
+  getAuditEntries,
+  getChangedFiles,
+  getCurrentBranch,
+  getCurrentSession,
+  getDashboardData,
+  getFileGitInfo,
+  getGitContext,
+  getLocalCTOPath,
+  getModelPricingTable,
+  getPromptById,
+  getPromptTemplates,
+  getPruneLevelForTier,
+  getSessionMetrics,
+  getTaskDescription,
+  getTaskPromptBlock,
+  getTierFiles,
+  getTodaySessions,
+  getTokenSavings,
+  hasGlobalConfig,
+  hasLocalConfig,
+  hashContent,
+  hashFile,
+  initCTODir,
+  initLocalProject,
+  isGitRepo,
+  listBackups,
+  listPromptCategories,
+  listSessions,
+  loadAnalysis,
+  loadGeneratedArtifact,
+  loadGlobalConfig,
+  loadLocalConfig,
+  loadProjectConfig,
+  logAudit,
+  logFileRead,
+  mergeLocalWithGlobal,
+  mergeWithDefaults,
+  optimizeBudget,
+  parseGitignore,
+  pruneFile,
+  pruneProject,
+  purgeOldAuditEntries,
+  purgeOldData,
+  recommendModel,
+  recommendModelForFiles,
+  renderDashboard,
+  renderPrompt,
+  renderWeeklyReport,
+  revertArtifact,
+  sanitizeContent,
+  saveGlobalConfig,
+  saveLocalConfig,
+  saveProjectConfig,
+  scanContentForSecrets,
+  scanFileForSecrets,
+  scanProjectForSecrets,
+  scanTodos,
+  secureFilePermissions,
+  startSession,
+  validateSpecs,
+  verifyAuditEntry,
+  verifyAuditIntegrity,
+  verifyIntegrity
+};
+//# sourceMappingURL=index.js.map