@caliber-ai/cli 0.2.0 → 0.3.0

package/dist/bin.js

@@ -32,8 +32,8 @@ __export(constants_exports, {
   FRONTEND_URL: () => FRONTEND_URL,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
-import path from "path";
-import os from "os";
+import path2 from "path";
+import os2 from "os";
 var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR;
 var init_constants = __esm({
   "src/constants.ts"() {
@@ -41,39 +41,65 @@ var init_constants = __esm({
     API_URL = process.env.CALIBER_API_URL || "https://caliber-backend.up.railway.app";
     FRONTEND_URL = process.env.CALIBER_FRONTEND_URL || "https://caliber-app.up.railway.app";
     CLI_CALLBACK_PORT = 19284;
-    AUTH_DIR = path.join(os.homedir(), ".caliber");
-    AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+    AUTH_DIR = path2.join(os2.homedir(), ".caliber");
+    AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
     CALIBER_DIR = ".caliber";
-    MANIFEST_FILE = path.join(CALIBER_DIR, "manifest.json");
-    BACKUPS_DIR = path.join(CALIBER_DIR, "backups");
+    MANIFEST_FILE = path2.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path2.join(CALIBER_DIR, "backups");
   }
 });
 
+// src/lib/sentry.ts
+import * as Sentry from "@sentry/node";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var dsn = process.env.CALIBER_SENTRY_DSN || "https://e988132485fced78d7d60202f97942b3@o4510975175622656.ingest.us.sentry.io/4510975226347520";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "package.json"), "utf-8")
+);
+if (dsn) {
+  Sentry.init({
+    dsn,
+    release: `caliber-cli@${pkg.version}`,
+    environment: process.env.NODE_ENV || "production",
+    tracesSampleRate: 0,
+    beforeSend(event) {
+      event.tags = { ...event.tags, source: "cli", os: os.platform() };
+      return event;
+    }
+  });
+}
+
 // src/cli.ts
 import { Command } from "commander";
-import fs12 from "fs";
+import fs16 from "fs";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
 import chalk2 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
-import path10 from "path";
+import fs13 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
-import fs from "fs";
+import fs2 from "fs";
 function getStoredAuth() {
   try {
-    if (!fs.existsSync(AUTH_FILE)) return null;
-    const data = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+    if (!fs2.existsSync(AUTH_FILE)) return null;
+    const data = JSON.parse(fs2.readFileSync(AUTH_FILE, "utf-8"));
     return data;
   } catch {
     return null;
   }
 }
 function storeAuth(auth2) {
-  if (!fs.existsSync(AUTH_DIR)) {
-    fs.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs2.existsSync(AUTH_DIR)) {
+    fs2.mkdirSync(AUTH_DIR, { recursive: true });
   }
   const data = {
     accessToken: auth2.accessToken,
@@ -82,11 +108,11 @@ function storeAuth(auth2) {
     userId: auth2.user.id,
     email: auth2.user.email
   };
-  fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+  fs2.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
 }
 function clearAuth() {
   try {
-    if (fs.existsSync(AUTH_FILE)) fs.unlinkSync(AUTH_FILE);
+    if (fs2.existsSync(AUTH_FILE)) fs2.unlinkSync(AUTH_FILE);
   } catch {
   }
 }
@@ -113,16 +139,16 @@ function generatePKCE() {
 // src/auth/callback-server.ts
 init_constants();
 import http from "http";
-import { URL as URL2 } from "url";
+import { URL } from "url";
 function startCallbackServer(expectedState) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = http.createServer((req, res) => {
       if (!req.url?.startsWith("/callback")) {
         res.writeHead(404);
         res.end();
         return;
       }
-      const url = new URL2(req.url, `http://127.0.0.1:${CLI_CALLBACK_PORT}`);
+      const url = new URL(req.url, `http://127.0.0.1:${CLI_CALLBACK_PORT}`);
       const error = url.searchParams.get("error");
       if (error) {
         res.writeHead(200, { "Content-Type": "text/html" });
@@ -152,7 +178,7 @@ function startCallbackServer(expectedState) {
         </div>
       </body></html>`);
       server.close();
-      resolve({
+      resolve2({
         accessToken,
         refreshToken,
         expiresIn: parseInt(expiresIn || "3600", 10),
@@ -177,12 +203,13 @@ init_constants();
 // src/telemetry.ts
 init_constants();
 import { PostHog } from "posthog-node";
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
 import { randomUUID } from "crypto";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var POSTHOG_API_KEY = process.env.CALIBER_POSTHOG_KEY || "phc_XXrV0pSX4s2QVxVoOaeuyXDvtlRwPAjovt1ttMGVMPp";
-var DEVICE_ID_FILE = path2.join(AUTH_DIR, "device-id");
+var DEVICE_ID_FILE = path3.join(AUTH_DIR, "device-id");
 var client = null;
 function getClient() {
   if (!client) {
@@ -192,36 +219,37 @@ function getClient() {
 }
 function getDeviceId() {
   try {
-    if (fs2.existsSync(DEVICE_ID_FILE)) {
-      return fs2.readFileSync(DEVICE_ID_FILE, "utf-8").trim();
+    if (fs3.existsSync(DEVICE_ID_FILE)) {
+      return fs3.readFileSync(DEVICE_ID_FILE, "utf-8").trim();
     }
   } catch {
   }
   const id = randomUUID();
   try {
-    if (!fs2.existsSync(AUTH_DIR)) {
-      fs2.mkdirSync(AUTH_DIR, { recursive: true });
+    if (!fs3.existsSync(AUTH_DIR)) {
+      fs3.mkdirSync(AUTH_DIR, { recursive: true });
     }
-    fs2.writeFileSync(DEVICE_ID_FILE, id, { mode: 384 });
+    fs3.writeFileSync(DEVICE_ID_FILE, id, { mode: 384 });
   } catch {
   }
   return id;
 }
 function isFirstRun() {
-  return !fs2.existsSync(DEVICE_ID_FILE);
+  return !fs3.existsSync(DEVICE_ID_FILE);
 }
 function getDistinctId() {
   const auth2 = getStoredAuth();
   return auth2?.userId || getDeviceId();
 }
-var pkg = JSON.parse(
-  fs2.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+var __dirname_telemetry = path3.dirname(fileURLToPath2(import.meta.url));
+var pkg2 = JSON.parse(
+  fs3.readFileSync(path3.resolve(__dirname_telemetry, "..", "package.json"), "utf-8")
 );
 function baseProperties() {
   return {
     source: "cli",
-    cli_version: pkg.version,
-    os: os2.platform()
+    cli_version: pkg2.version,
+    os: os3.platform()
   };
 }
 function trackEvent(event, properties = {}) {
@@ -245,29 +273,11 @@ function identifyUser(userId, email) {
   } catch {
   }
 }
-function countSuggestedFiles(setup) {
-  let count = 0;
-  const claude = setup.claude;
-  const cursor = setup.cursor;
-  if (claude) {
-    if (claude.claudeMd) count++;
-    if (claude.settings) count++;
-    if (claude.settingsLocal) count++;
-    if (Array.isArray(claude.skills)) count += claude.skills.length;
-    if (claude.mcpServers && Object.keys(claude.mcpServers).length > 0) count++;
-  }
-  if (cursor) {
-    if (cursor.cursorrules) count++;
-    if (Array.isArray(cursor.rules)) count += cursor.rules.length;
-    if (cursor.mcpServers && Object.keys(cursor.mcpServers).length > 0) count++;
-  }
-  return count;
-}
 async function shutdownTelemetry() {
   try {
     await Promise.race([
       client?.shutdown(),
-      new Promise((resolve) => setTimeout(resolve, 2e3))
+      new Promise((resolve2) => setTimeout(resolve2, 2e3))
     ]);
   } catch {
   }
@@ -303,8 +313,9 @@ ${authUrl}
     trackEvent("signin", { method: "cli_pkce" });
     spinner.succeed(chalk.green(`Logged in as ${result.user.email}`));
   } catch (err) {
+    trackEvent("error_occurred", { error_type: "auth_failed", error_message: err instanceof Error ? err.message : "Unknown error", command: "login" });
     spinner.fail(chalk.red(`Authentication failed: ${err instanceof Error ? err.message : "Unknown error"}`));
-    process.exit(1);
+    throw new Error("__exit__");
   }
 }
 
@@ -313,7 +324,19 @@ import crypto2 from "crypto";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { resolve, dirname } from "path";
+function isInsideGitRepo() {
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync(resolve(dir, ".git"))) return true;
+    const parent = dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
 function getGitRemoteUrl() {
+  if (!isInsideGitRepo()) return void 0;
   try {
     return execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
@@ -322,8 +345,8 @@ function getGitRemoteUrl() {
 }
 
 // src/fingerprint/package-json.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { globSync } from "glob";
 var NODE_FRAMEWORK_DEPS = {
   react: "React",
@@ -374,8 +397,8 @@ var WORKSPACE_GLOBS = [
 ];
 function detectNodeFrameworks(pkgPath) {
   try {
-    const pkg4 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-    const allDeps = { ...pkg4.dependencies, ...pkg4.devDependencies };
+    const pkg5 = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+    const allDeps = { ...pkg5.dependencies, ...pkg5.devDependencies };
     const frameworks = [];
     for (const [dep, framework] of Object.entries(NODE_FRAMEWORK_DEPS)) {
       if (allDeps[dep]) frameworks.push(framework);
@@ -388,16 +411,16 @@ function detectNodeFrameworks(pkgPath) {
 function detectPythonFrameworks(dir) {
   const frameworks = [];
   const candidates = [
-    path3.join(dir, "pyproject.toml"),
-    path3.join(dir, "requirements.txt"),
+    path4.join(dir, "pyproject.toml"),
+    path4.join(dir, "requirements.txt"),
     ...globSync("apps/*/pyproject.toml", { cwd: dir, absolute: true }),
     ...globSync("apps/*/requirements.txt", { cwd: dir, absolute: true }),
     ...globSync("services/*/pyproject.toml", { cwd: dir, absolute: true })
   ];
   for (const filePath of candidates) {
-    if (!fs3.existsSync(filePath)) continue;
+    if (!fs4.existsSync(filePath)) continue;
     try {
-      const content = fs3.readFileSync(filePath, "utf-8").toLowerCase();
+      const content = fs4.readFileSync(filePath, "utf-8").toLowerCase();
       for (const [dep, framework] of Object.entries(PYTHON_FRAMEWORK_DEPS)) {
         if (content.includes(dep)) frameworks.push(framework);
       }
@@ -407,15 +430,15 @@ function detectPythonFrameworks(dir) {
   return frameworks;
 }
 function analyzePackageJson(dir) {
-  const rootPkgPath = path3.join(dir, "package.json");
+  const rootPkgPath = path4.join(dir, "package.json");
   let name;
   const allFrameworks = [];
   const languages = [];
-  if (fs3.existsSync(rootPkgPath)) {
+  if (fs4.existsSync(rootPkgPath)) {
     try {
-      const pkg4 = JSON.parse(fs3.readFileSync(rootPkgPath, "utf-8"));
-      name = pkg4.name;
-      const allDeps = { ...pkg4.dependencies, ...pkg4.devDependencies };
+      const pkg5 = JSON.parse(fs4.readFileSync(rootPkgPath, "utf-8"));
+      name = pkg5.name;
+      const allDeps = { ...pkg5.dependencies, ...pkg5.devDependencies };
       allFrameworks.push(...detectNodeFrameworks(rootPkgPath));
       if (allDeps.typescript || allDeps["@types/node"]) {
         languages.push("TypeScript");
@@ -429,8 +452,8 @@ function analyzePackageJson(dir) {
     for (const pkgPath of matches) {
       allFrameworks.push(...detectNodeFrameworks(pkgPath));
       try {
-        const pkg4 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-        const deps = { ...pkg4.dependencies, ...pkg4.devDependencies };
+        const pkg5 = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        const deps = { ...pkg5.dependencies, ...pkg5.devDependencies };
         if (deps.typescript || deps["@types/node"]) {
           languages.push("TypeScript");
         }
@@ -447,8 +470,8 @@ function analyzePackageJson(dir) {
 }
 
 // src/fingerprint/file-tree.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -471,10 +494,10 @@ function getFileTree(dir, maxDepth = 3) {
 }
 function scan(base, rel, depth, maxDepth, result) {
   if (depth > maxDepth) return;
-  const fullPath = path4.join(base, rel);
+  const fullPath = path5.join(base, rel);
   let entries;
   try {
-    entries = fs4.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs5.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -492,7 +515,7 @@ function scan(base, rel, depth, maxDepth, result) {
 }
 
 // src/fingerprint/languages.ts
-import path5 from "path";
+import path6 from "path";
 var EXT_TO_LANG = {
   ".ts": "TypeScript",
   ".tsx": "TypeScript",
@@ -518,7 +541,7 @@ var EXT_TO_LANG = {
 function detectLanguages(fileTree) {
   const langs = /* @__PURE__ */ new Set();
   for (const file of fileTree) {
-    const ext = path5.extname(file).toLowerCase();
+    const ext = path6.extname(file).toLowerCase();
     if (EXT_TO_LANG[ext]) {
       langs.add(EXT_TO_LANG[ext]);
     }
@@ -527,43 +550,43 @@ function detectLanguages(fileTree) {
 }
 
 // src/fingerprint/existing-config.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function readExistingConfigs(dir) {
   const configs = {};
-  const claudeMdPath = path6.join(dir, "CLAUDE.md");
-  if (fs5.existsSync(claudeMdPath)) {
-    configs.claudeMd = fs5.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path7.join(dir, "CLAUDE.md");
+  if (fs6.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs6.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path6.join(dir, ".claude", "settings.json");
-  if (fs5.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = path7.join(dir, ".claude", "settings.json");
+  if (fs6.existsSync(claudeSettingsPath)) {
     try {
-      configs.claudeSettings = JSON.parse(fs5.readFileSync(claudeSettingsPath, "utf-8"));
+      configs.claudeSettings = JSON.parse(fs6.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path6.join(dir, ".claude", "skills");
-  if (fs5.existsSync(skillsDir)) {
+  const skillsDir = path7.join(dir, ".claude", "skills");
+  if (fs6.existsSync(skillsDir)) {
     try {
-      const files = fs5.readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
+      const files = fs6.readdirSync(skillsDir).filter((f) => f.endsWith(".md"));
       configs.claudeSkills = files.map((f) => ({
         filename: f,
-        content: fs5.readFileSync(path6.join(skillsDir, f), "utf-8")
+        content: fs6.readFileSync(path7.join(skillsDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorrulesPath = path6.join(dir, ".cursorrules");
-  if (fs5.existsSync(cursorrulesPath)) {
-    configs.cursorrules = fs5.readFileSync(cursorrulesPath, "utf-8");
+  const cursorrulesPath = path7.join(dir, ".cursorrules");
+  if (fs6.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs6.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path6.join(dir, ".cursor", "rules");
-  if (fs5.existsSync(cursorRulesDir)) {
+  const cursorRulesDir = path7.join(dir, ".cursor", "rules");
+  if (fs6.existsSync(cursorRulesDir)) {
     try {
-      const files = fs5.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
+      const files = fs6.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs5.readFileSync(path6.join(cursorRulesDir, f), "utf-8")
+        content: fs6.readFileSync(path7.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
@@ -571,6 +594,277 @@ function readExistingConfigs(dir) {
   return configs;
 }
 
+// src/fingerprint/code-analysis.ts
+import fs7 from "fs";
+import path8 from "path";
+var IGNORE_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  ".turbo",
+  "coverage",
+  ".caliber",
+  "__pycache__",
+  ".venv",
+  "vendor",
+  "target"
+]);
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".py"]);
+var CONFIG_FILE_NAMES = /* @__PURE__ */ new Set([
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "Makefile",
+  "tsconfig.json",
+  "pyproject.toml",
+  "turbo.json",
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "drizzle.config.ts",
+  "drizzle.config.js",
+  "jest.config.ts",
+  "jest.config.js",
+  "jest.config.mjs",
+  "vitest.config.ts",
+  "vitest.config.js",
+  "vitest.config.mts",
+  "alembic.ini",
+  "setup.cfg",
+  "tox.ini"
+]);
+var CONFIG_GLOBS_DIRS = [
+  { dir: ".github/workflows", pattern: /\.ya?ml$/ }
+];
+var TOTAL_BUDGET = 5e4;
+var CONFIG_BUDGET = Math.floor(TOTAL_BUDGET * 0.3);
+var SOURCE_BUDGET = Math.floor(TOTAL_BUDGET * 0.7);
+function analyzeCode(dir) {
+  const sourceFiles = [];
+  const configFiles = [];
+  walkDir(dir, "", 0, 10, sourceFiles, configFiles, dir);
+  sortByPriority(sourceFiles);
+  let configChars = 0;
+  const trimmedConfigs = [];
+  for (const cfg of configFiles) {
+    const size = cfg.path.length + cfg.content.length;
+    if (configChars + size > CONFIG_BUDGET) break;
+    trimmedConfigs.push(cfg);
+    configChars += size;
+  }
+  let sourceChars = 0;
+  let truncated = false;
+  const fileSummaries = [];
+  for (const relPath of sourceFiles) {
+    const fullPath = path8.join(dir, relPath);
+    let content;
+    try {
+      content = fs7.readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lineCount = content.split("\n").length;
+    if (lineCount > 500) continue;
+    const ext = path8.extname(relPath);
+    const language = resolveLanguage(ext);
+    if (!language) continue;
+    const summary = language === "py" ? extractPython(relPath, content) : extractTypeScriptJavaScript(relPath, content, language);
+    const summarySize = estimateSummarySize(summary);
+    if (sourceChars + summarySize > SOURCE_BUDGET) {
+      truncated = true;
+      break;
+    }
+    fileSummaries.push(summary);
+    sourceChars += summarySize;
+  }
+  return { fileSummaries, configFiles: trimmedConfigs, truncated };
+}
+function walkDir(base, rel, depth, maxDepth, sourceFiles, configFiles, rootDir) {
+  if (depth > maxDepth) return;
+  const fullPath = path8.join(base, rel);
+  let entries;
+  try {
+    entries = fs7.readdirSync(fullPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (IGNORE_DIRS2.has(entry.name)) continue;
+    if (entry.name.startsWith(".") && depth === 0 && entry.isDirectory()) continue;
+    const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      const matchedGlobDir = CONFIG_GLOBS_DIRS.find(
+        (g) => relPath === g.dir || relPath.endsWith(`/${g.dir}`)
+      );
+      if (matchedGlobDir) {
+        collectConfigsFromDir(base, relPath, matchedGlobDir.pattern, configFiles);
+      }
+      walkDir(base, relPath, depth + 1, maxDepth, sourceFiles, configFiles, rootDir);
+    } else {
+      if (CONFIG_FILE_NAMES.has(entry.name)) {
+        try {
+          const content = fs7.readFileSync(path8.join(base, relPath), "utf-8");
+          configFiles.push({ path: relPath, content });
+        } catch {
+        }
+      }
+      const ext = path8.extname(entry.name);
+      if (SOURCE_EXTENSIONS.has(ext) && !entry.name.endsWith(".d.ts")) {
+        sourceFiles.push(relPath);
+      }
+    }
+  }
+}
+function collectConfigsFromDir(base, relDir, pattern, configFiles) {
+  const fullDir = path8.join(base, relDir);
+  let entries;
+  try {
+    entries = fs7.readdirSync(fullDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && pattern.test(entry.name)) {
+      const relPath = `${relDir}/${entry.name}`;
+      try {
+        const content = fs7.readFileSync(path8.join(base, relPath), "utf-8");
+        configFiles.push({ path: relPath, content });
+      } catch {
+      }
+    }
+  }
+}
+function sortByPriority(files) {
+  const entryPointNames = /* @__PURE__ */ new Set(["index.ts", "index.js", "main.py", "app.ts", "app.js", "server.ts", "server.js"]);
+  const routePattern = /(route|api|controller)/i;
+  const schemaPattern = /(types|schema|models)/i;
+  const servicePattern = /(service|lib|utils)/i;
+  const testPattern = /(test|spec|__tests__)/i;
+  function priority(filePath) {
+    const base = path8.basename(filePath);
+    if (entryPointNames.has(base)) return 0;
+    if (routePattern.test(filePath)) return 1;
+    if (schemaPattern.test(filePath)) return 2;
+    if (servicePattern.test(filePath)) return 3;
+    if (testPattern.test(filePath)) return 5;
+    return 4;
+  }
+  files.sort((a, b) => priority(a) - priority(b));
+}
+function resolveLanguage(ext) {
+  if (ext === ".ts" || ext === ".tsx") return "ts";
+  if (ext === ".js" || ext === ".jsx") return "js";
+  if (ext === ".py") return "py";
+  return null;
+}
+function extractTypeScriptJavaScript(filePath, content, language) {
+  const lines = content.split("\n");
+  const imports = [];
+  const exports = [];
+  const functions = [];
+  const classes = [];
+  const types = [];
+  const routes = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^import\s+/.test(trimmed)) {
+      imports.push(trimmed);
+      continue;
+    }
+    const exportMatch = trimmed.match(
+      /^export\s+(?:default\s+)?(?:async\s+)?(function|const|class|interface|type|enum)\s+(\w+)/
+    );
+    if (exportMatch) {
+      exports.push(`${exportMatch[1]} ${exportMatch[2]}`);
+      if (exportMatch[1] === "class") classes.push(exportMatch[2]);
+      if (exportMatch[1] === "interface" || exportMatch[1] === "type") types.push(exportMatch[2]);
+      if (exportMatch[1] === "function") functions.push(exportMatch[2]);
+      continue;
+    }
+    const fnMatch = trimmed.match(/^(?:async\s+)?function\s+(\w+)/);
+    if (fnMatch && !trimmed.startsWith("export")) {
+      functions.push(fnMatch[1]);
+      continue;
+    }
+    const arrowMatch = trimmed.match(/^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\(/);
+    if (arrowMatch && !exports.some((e) => e.endsWith(arrowMatch[1]))) {
+      functions.push(arrowMatch[1]);
+    }
+    const classMatch = trimmed.match(/^class\s+(\w+)/);
+    if (classMatch && !trimmed.startsWith("export")) {
+      classes.push(classMatch[1]);
+      continue;
+    }
+    const ifaceMatch = trimmed.match(/^(?:interface|type)\s+(\w+)/);
+    if (ifaceMatch && !trimmed.startsWith("export")) {
+      types.push(ifaceMatch[1]);
+      continue;
+    }
+    const routeMatch = trimmed.match(
+      /(?:router|app|server)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/
+    );
+    if (routeMatch) {
+      routes.push(`${routeMatch[1].toUpperCase()} ${routeMatch[2]}`);
+    }
+  }
+  return { path: filePath, language, imports, exports, functions, classes, types, routes };
+}
+function extractPython(filePath, content) {
+  const lines = content.split("\n");
+  const imports = [];
+  const functions = [];
+  const classes = [];
+  const routes = [];
+  let prevLine = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^import\s+/.test(trimmed) || /^from\s+/.test(trimmed)) {
+      imports.push(trimmed);
+      continue;
+    }
+    const defMatch = trimmed.match(/^def\s+(\w+)\s*\(([^)]*)\)/);
+    if (defMatch) {
+      functions.push(`${defMatch[1]}(${defMatch[2]})`);
+    }
+    const classMatch = trimmed.match(/^class\s+(\w+)/);
+    if (classMatch) {
+      classes.push(classMatch[1]);
+    }
+    const decoratorRoute = prevLine.match(
+      /@(?:app|router)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"]([^'"]+)['"]/
+    );
+    if (decoratorRoute && defMatch) {
+      routes.push(`${decoratorRoute[1].toUpperCase()} ${decoratorRoute[2]}`);
+    }
+    const includeRouter = trimmed.match(
+      /include_router\s*\([^,]+,\s*prefix\s*=\s*['"]([^'"]+)['"]/
+    );
+    if (includeRouter) {
+      routes.push(`ROUTER ${includeRouter[1]}`);
+    }
+    prevLine = trimmed;
+  }
+  return {
+    path: filePath,
+    language: "py",
+    imports,
+    exports: [],
+    functions,
+    classes,
+    types: [],
+    routes
+  };
+}
+function estimateSummarySize(summary) {
+  return summary.path.length + summary.imports.reduce((s, i) => s + i.length, 0) + summary.exports.reduce((s, e) => s + e.length, 0) + summary.functions.reduce((s, f) => s + f.length, 0) + summary.classes.reduce((s, c) => s + c.length, 0) + summary.types.reduce((s, t) => s + t.length, 0) + summary.routes.reduce((s, r) => s + r.length, 0);
+}
+
 // src/fingerprint/index.ts
 function collectFingerprint(dir) {
   const gitRemoteUrl = getGitRemoteUrl();
@@ -578,6 +872,7 @@ function collectFingerprint(dir) {
   const fileTree = getFileTree(dir);
   const fileLangs = detectLanguages(fileTree);
   const existingConfigs = readExistingConfigs(dir);
+  const codeAnalysis = analyzeCode(dir);
   const languages = [.../* @__PURE__ */ new Set([...pkgInfo.languages, ...fileLangs])];
   return {
     gitRemoteUrl,
@@ -585,7 +880,8 @@ function collectFingerprint(dir) {
     languages,
     frameworks: pkgInfo.frameworks,
     fileTree,
-    existingConfigs
+    existingConfigs,
+    codeAnalysis
   };
 }
 function computeFingerprintHash(fingerprint) {
@@ -598,10 +894,9 @@ function computeFingerprintHash(fingerprint) {
 
 // src/api/client.ts
 init_constants();
-async function refreshTokenIfNeeded() {
+async function forceRefreshToken() {
   const auth2 = getStoredAuth();
   if (!auth2) return null;
-  if (!isTokenExpired()) return auth2.accessToken;
   try {
     const resp = await fetch(`${API_URL}/api/auth/refresh`, {
       method: "POST",
@@ -621,12 +916,21 @@ async function refreshTokenIfNeeded() {
     return null;
   }
 }
-async function apiRequest(path11, options = {}) {
-  const token = await refreshTokenIfNeeded();
-  if (!token) {
+async function getValidToken() {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
     throw new Error("Not authenticated. Run `caliber login` first.");
   }
-  const resp = await fetch(`${API_URL}${path11}`, {
+  if (!isTokenExpired()) return auth2.accessToken;
+  const refreshed = await forceRefreshToken();
+  if (!refreshed) {
+    throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+  }
+  return refreshed;
+}
+async function apiRequest(path15, options = {}) {
+  let token = await getValidToken();
+  let resp = await fetch(`${API_URL}${path15}`, {
     method: options.method || "GET",
     headers: {
       "Content-Type": "application/json",
@@ -634,6 +938,21 @@ async function apiRequest(path11, options = {}) {
     },
     body: options.body ? JSON.stringify(options.body) : void 0
   });
+  if (resp.status === 401) {
+    const refreshed = await forceRefreshToken();
+    if (!refreshed) {
+      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+    }
+    token = refreshed;
+    resp = await fetch(`${API_URL}${path15}`, {
+      method: options.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+  }
   if (!resp.ok) {
     const error = await resp.json().catch(() => ({ error: resp.statusText }));
     throw new Error(error.error || `API error: ${resp.status}`);
@@ -641,12 +960,9 @@ async function apiRequest(path11, options = {}) {
   const json = await resp.json();
   return json.data;
 }
-async function apiStream(path11, body, onChunk, onComplete, onError, onStatus) {
-  const token = await refreshTokenIfNeeded();
-  if (!token) {
-    throw new Error("Not authenticated. Run `caliber login` first.");
-  }
-  const resp = await fetch(`${API_URL}${path11}`, {
+async function apiStream(path15, body, onChunk, onComplete, onError, onStatus) {
+  let token = await getValidToken();
+  let resp = await fetch(`${API_URL}${path15}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -654,6 +970,21 @@ async function apiStream(path11, body, onChunk, onComplete, onError, onStatus) {
     },
     body: JSON.stringify(body)
   });
+  if (resp.status === 401) {
+    const refreshed = await forceRefreshToken();
+    if (!refreshed) {
+      throw new Error("Session expired. Run `caliber login` to re-authenticate.");
+    }
+    token = refreshed;
+    resp = await fetch(`${API_URL}${path15}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    });
+  }
   if (!resp.ok || !resp.body) {
     throw new Error(`API error: ${resp.status}`);
   }
@@ -674,7 +1005,7 @@ async function apiStream(path11, body, onChunk, onComplete, onError, onStatus) {
         const parsed = JSON.parse(data);
         if (parsed.type === "chunk") onChunk(parsed.content);
         else if (parsed.type === "status" && onStatus) onStatus(parsed.message);
-        else if (parsed.type === "complete") onComplete({ setup: parsed.setup, explanation: parsed.explanation });
+        else if (parsed.type === "complete") onComplete({ setup: parsed.setup, explanation: parsed.explanation, raw: parsed.raw });
         else if (parsed.type === "error") onError(parsed.message);
       } catch {
       }
@@ -683,132 +1014,132 @@ async function apiStream(path11, body, onChunk, onComplete, onError, onStatus) {
 }
 
 // src/writers/index.ts
-import fs10 from "fs";
+import fs12 from "fs";
 
 // src/writers/claude/index.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path9 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs6.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs8.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   const claudeDir = ".claude";
-  if (!fs6.existsSync(claudeDir)) fs6.mkdirSync(claudeDir, { recursive: true });
-  fs6.writeFileSync(
-    path7.join(claudeDir, "settings.json"),
+  if (!fs8.existsSync(claudeDir)) fs8.mkdirSync(claudeDir, { recursive: true });
+  fs8.writeFileSync(
+    path9.join(claudeDir, "settings.json"),
     JSON.stringify(config.settings, null, 2)
   );
-  written.push(path7.join(claudeDir, "settings.json"));
-  fs6.writeFileSync(
-    path7.join(claudeDir, "settings.local.json"),
+  written.push(path9.join(claudeDir, "settings.json"));
+  fs8.writeFileSync(
+    path9.join(claudeDir, "settings.local.json"),
     JSON.stringify(config.settingsLocal, null, 2)
   );
-  written.push(path7.join(claudeDir, "settings.local.json"));
+  written.push(path9.join(claudeDir, "settings.local.json"));
   if (config.skills?.length) {
-    const skillsDir = path7.join(claudeDir, "skills");
-    if (!fs6.existsSync(skillsDir)) fs6.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path9.join(claudeDir, "skills");
+    if (!fs8.existsSync(skillsDir)) fs8.mkdirSync(skillsDir, { recursive: true });
     for (const skill of config.skills) {
       const filename = `${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
-      const skillPath = path7.join(skillsDir, filename);
-      fs6.writeFileSync(skillPath, skill.content);
+      const skillPath = path9.join(skillsDir, filename);
+      fs8.writeFileSync(skillPath, skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const mcpConfig = { mcpServers: config.mcpServers };
-    fs6.writeFileSync(".mcp.json", JSON.stringify(mcpConfig, null, 2));
+    fs8.writeFileSync(".mcp.json", JSON.stringify(mcpConfig, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs7.writeFileSync(".cursorrules", config.cursorrules);
+    fs9.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path8.join(".cursor", "rules");
-    if (!fs7.existsSync(rulesDir)) fs7.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path10.join(".cursor", "rules");
+    if (!fs9.existsSync(rulesDir)) fs9.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path8.join(rulesDir, rule.filename);
-      fs7.writeFileSync(rulePath, rule.content);
+      const rulePath = path10.join(rulesDir, rule.filename);
+      fs9.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs7.existsSync(cursorDir)) fs7.mkdirSync(cursorDir, { recursive: true });
+    if (!fs9.existsSync(cursorDir)) fs9.mkdirSync(cursorDir, { recursive: true });
     const mcpConfig = { mcpServers: config.mcpServers };
-    fs7.writeFileSync(
-      path8.join(cursorDir, "mcp.json"),
+    fs9.writeFileSync(
+      path10.join(cursorDir, "mcp.json"),
       JSON.stringify(mcpConfig, null, 2)
     );
-    written.push(path8.join(cursorDir, "mcp.json"));
+    written.push(path10.join(cursorDir, "mcp.json"));
   }
   return written;
 }
 
 // src/writers/backup.ts
 init_constants();
-import fs8 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path9.join(BACKUPS_DIR, timestamp);
+  const backupDir = path11.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs8.existsSync(file)) continue;
-    const dest = path9.join(backupDir, file);
-    const destDir = path9.dirname(dest);
-    if (!fs8.existsSync(destDir)) {
-      fs8.mkdirSync(destDir, { recursive: true });
+    if (!fs10.existsSync(file)) continue;
+    const dest = path11.join(backupDir, file);
+    const destDir = path11.dirname(dest);
+    if (!fs10.existsSync(destDir)) {
+      fs10.mkdirSync(destDir, { recursive: true });
     }
-    fs8.copyFileSync(file, dest);
+    fs10.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path9.join(backupDir, file);
-  if (!fs8.existsSync(backupFile)) return false;
-  const destDir = path9.dirname(file);
-  if (!fs8.existsSync(destDir)) {
-    fs8.mkdirSync(destDir, { recursive: true });
+  const backupFile = path11.join(backupDir, file);
+  if (!fs10.existsSync(backupFile)) return false;
+  const destDir = path11.dirname(file);
+  if (!fs10.existsSync(destDir)) {
+    fs10.mkdirSync(destDir, { recursive: true });
   }
-  fs8.copyFileSync(backupFile, file);
+  fs10.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs9 from "fs";
+import fs11 from "fs";
 import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs9.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs9.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs11.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs11.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs9.existsSync(CALIBER_DIR)) {
-    fs9.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs11.existsSync(CALIBER_DIR)) {
+    fs11.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs9.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs11.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs9.readFileSync(filePath);
+  const content = fs11.readFileSync(filePath);
   return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const existingFiles = filesToWrite.filter((f) => fs10.existsSync(f));
+  const existingFiles = filesToWrite.filter((f) => fs12.existsSync(f));
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
   const written = [];
   if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
@@ -836,8 +1167,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs10.existsSync(entry.path)) {
-        fs10.unlinkSync(entry.path);
+      if (fs12.existsSync(entry.path)) {
+        fs12.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if (entry.action === "modified" && manifest.backupDir) {
@@ -847,8 +1178,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs10.existsSync(MANIFEST_FILE2)) {
-    fs10.unlinkSync(MANIFEST_FILE2);
+  if (fs12.existsSync(MANIFEST_FILE2)) {
+    fs12.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -874,13 +1205,13 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs10.existsSync(gitignorePath)) {
-    const content = fs10.readFileSync(gitignorePath, "utf-8");
+  if (fs12.existsSync(gitignorePath)) {
+    const content = fs12.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs10.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs12.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs10.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs12.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
@@ -958,7 +1289,7 @@ async function initCommand(options) {
     auth2 = getStoredAuth();
     if (!auth2) {
       console.log(chalk2.red("Authentication required. Exiting."));
-      process.exit(1);
+      throw new Error("__exit__");
     }
   }
   console.log(chalk2.dim(`Authenticated as ${auth2.email}
@@ -984,14 +1315,23 @@ async function initCommand(options) {
 `));
   const matchSpinner = ora2("Checking for existing setup...").start();
   let existingSetup = null;
+  let existingProjectId = null;
   try {
     const match = await apiRequest("/api/projects/match", {
       method: "POST",
       body: { fingerprintHash: hash }
     });
+    if (match.project) {
+      existingProjectId = match.project.id;
+    }
     if (match.setup) {
       existingSetup = match.setup;
-      trackEvent("existing_config_detected");
+      trackEvent("existing_config_detected", {
+        has_claude_md: !!fingerprint.existingConfigs.claudeMd,
+        has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
+        has_cursor_rules: (fingerprint.existingConfigs.cursorRules?.length ?? 0) > 0,
+        has_skills: (fingerprint.existingConfigs.claudeSkills?.length ?? 0) > 0
+      });
       matchSpinner.succeed("Found existing setup");
     } else {
       matchSpinner.info("No existing setup found");
@@ -1007,55 +1347,63 @@ async function initCommand(options) {
   }
   let generatedSetup = null;
   let setupExplanation;
+  let rawOutput;
   trackEvent("generation_started", { target_agent: targetAgent });
-  const generationStart = Date.now();
   const genSpinner = ora2("Generating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES);
   genMessages.start();
-  await apiStream(
-    "/api/setups/generate",
-    {
-      fingerprint,
-      targetAgent,
-      prompt: fingerprint.description
-    },
-    () => {
-    },
-    (payload) => {
-      generatedSetup = payload.setup;
-      setupExplanation = payload.explanation;
-    },
-    (error) => {
-      genMessages.stop();
-      trackEvent("error_occurred", { error_type: "generation_failed", error_message: error });
-      genSpinner.fail(`Generation error: ${error}`);
-    },
-    (status) => {
-      genMessages.handleServerStatus(status);
-    }
-  );
+  try {
+    await apiStream(
+      "/api/setups/generate",
+      {
+        fingerprint,
+        targetAgent,
+        prompt: fingerprint.description
+      },
+      () => {
+      },
+      (payload) => {
+        generatedSetup = payload.setup;
+        setupExplanation = payload.explanation;
+        rawOutput = payload.raw;
+      },
+      (error) => {
+        genMessages.stop();
+        trackEvent("error_occurred", { error_type: "generation_failed", error_message: error, command: "init" });
+        genSpinner.fail(`Generation error: ${error}`);
+      },
+      (status) => {
+        genMessages.handleServerStatus(status);
+      }
+    );
+  } catch (err) {
+    genMessages.stop();
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    trackEvent("error_occurred", { error_type: "generation_request_failed", error_message: msg, command: "init" });
+    genSpinner.fail(`Generation failed: ${msg}`);
+    throw new Error("__exit__");
+  }
   genMessages.stop();
   if (!generatedSetup) {
     genSpinner.fail("Failed to generate setup.");
-    process.exit(1);
+    if (rawOutput) {
+      console.log(chalk2.dim("\nRaw LLM output (JSON parse failed):"));
+      console.log(chalk2.dim(rawOutput.slice(0, 500)));
+    }
+    throw new Error("__exit__");
   }
-  trackEvent("generation_completed", {
-    target_agent: targetAgent,
-    duration_ms: Date.now() - generationStart,
-    files_suggested: countSuggestedFiles(generatedSetup)
-  });
   genSpinner.succeed("Setup generated");
   printSetupSummary(generatedSetup);
-  let action = await promptAction();
+  let explained = false;
+  let action = await promptAction(explained);
   while (action === "explain") {
     if (setupExplanation) {
-      console.log(chalk2.bold("\nWhy this setup?\n"));
-      console.log(chalk2.dim(setupExplanation));
-      console.log("");
+      printExplanation(setupExplanation);
     } else {
       console.log(chalk2.dim("\nNo explanation available for this setup.\n"));
     }
-    action = await promptAction();
+    explained = true;
+    action = await promptAction(explained);
   }
   if (action === "decline") {
     trackEvent("setup_declined");
@@ -1065,7 +1413,7 @@ async function initCommand(options) {
   if (action === "refine") {
     generatedSetup = await refineLoop(generatedSetup, targetAgent);
     if (!generatedSetup) {
-      trackEvent("generation_cancelled");
+      trackEvent("refinement_cancelled");
       console.log(chalk2.dim("Refinement cancelled. No files were modified."));
       return;
     }
@@ -1080,9 +1428,6 @@ async function initCommand(options) {
     const result = writeSetup(generatedSetup);
     writeSpinner.succeed("Config files written");
     trackEvent("setup_applied", { files_written: result.written.length, target_agent: targetAgent });
-    for (const file of result.written) {
-      trackEvent("config_file_written", { file_type: path10.extname(file) || path10.basename(file) });
-    }
     console.log(chalk2.bold("\nFiles created/updated:"));
     for (const file of result.written) {
       console.log(`  ${chalk2.green("\u2713")} ${file}`);
@@ -1094,20 +1439,23 @@ async function initCommand(options) {
   } catch (err) {
     writeSpinner.fail("Failed to write files");
     console.error(chalk2.red(err instanceof Error ? err.message : "Unknown error"));
-    process.exit(1);
+    throw new Error("__exit__");
   }
   try {
-    const project = await apiRequest("/api/projects", {
-      method: "POST",
-      body: {
-        fingerprintHash: hash,
-        name: fingerprint.packageName || "untitled",
-        gitRemoteUrl: fingerprint.gitRemoteUrl,
-        description: fingerprint.description
-      }
-    });
-    trackEvent("project_created", { project_name: fingerprint.packageName || "untitled" });
-    await apiRequest(`/api/setups/project/${project.id}`, {
+    let projectId = existingProjectId;
+    if (!projectId) {
+      const project = await apiRequest("/api/projects", {
+        method: "POST",
+        body: {
+          fingerprintHash: hash,
+          name: fingerprint.packageName || "untitled",
+          gitRemoteUrl: fingerprint.gitRemoteUrl,
+          description: fingerprint.description
+        }
+      });
+      projectId = project.id;
+    }
+    await apiRequest(`/api/setups/project/${projectId}`, {
       method: "POST",
       body: {
         targetAgent,
@@ -1171,15 +1519,15 @@ async function refineLoop(currentSetup, _targetAgent) {
 }
 function promptInput(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(chalk2.cyan(`${question} `), (answer) => {
       rl.close();
-      resolve(answer.trim());
+      resolve2(answer.trim());
     });
   });
 }
 function promptAgent() {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log(chalk2.bold("Which coding agent are you using?"));
     console.log("  1. Claude Code");
@@ -1188,81 +1536,123 @@ function promptAgent() {
     rl.question(chalk2.cyan("\nChoose (1-3): "), (answer) => {
       rl.close();
       const map = { "1": "claude", "2": "cursor", "3": "both" };
-      resolve(map[answer.trim()] || "claude");
+      resolve2(map[answer.trim()] || "claude");
     });
   });
 }
-function promptAction() {
-  return new Promise((resolve) => {
+function promptAction(explained) {
+  return new Promise((resolve2) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log(chalk2.bold("What would you like to do?"));
-    console.log("  1. Accept and apply");
-    console.log("  2. Refine via chat");
-    console.log("  3. Explain recommendations");
-    console.log("  4. Decline");
-    rl.question(chalk2.cyan("\nChoose (1-4): "), (answer) => {
-      rl.close();
-      const map = {
-        "1": "accept",
-        "2": "refine",
-        "3": "explain",
-        "4": "decline"
-      };
-      resolve(map[answer.trim()] || "accept");
-    });
+    if (explained) {
+      console.log("  1. Accept and apply");
+      console.log("  2. Refine via chat");
+      console.log("  3. Decline");
+      rl.question(chalk2.cyan("\nChoose (1-3): "), (answer) => {
+        rl.close();
+        const map = {
+          "1": "accept",
+          "2": "refine",
+          "3": "decline"
+        };
+        resolve2(map[answer.trim()] || "accept");
+      });
+    } else {
+      console.log("  1. Accept and apply");
+      console.log("  2. Refine via chat");
+      console.log("  3. Explain recommendations");
+      console.log("  4. Decline");
+      rl.question(chalk2.cyan("\nChoose (1-4): "), (answer) => {
+        rl.close();
+        const map = {
+          "1": "accept",
+          "2": "refine",
+          "3": "explain",
+          "4": "decline"
+        };
+        resolve2(map[answer.trim()] || "accept");
+      });
+    }
   });
 }
+function fileEntry(filePath, desc) {
+  const icon = fs13.existsSync(filePath) ? chalk2.yellow("~") : chalk2.green("+");
+  const description = desc ? chalk2.dim(`\u2014 ${desc}`) : "";
+  return `  ${icon} ${filePath} ${description}`;
+}
 function printSetupSummary(setup) {
   const claude = setup.claude;
   const cursor = setup.cursor;
+  const descriptions = setup.fileDescriptions || {};
   console.log("");
   if (claude) {
     if (claude.claudeMd) {
-      console.log(`  ${chalk2.green("+")} CLAUDE.md ${chalk2.dim("\u2014 project guidelines, commands, conventions")}`);
+      console.log(fileEntry("CLAUDE.md", descriptions["CLAUDE.md"]));
     }
     if (claude.settings) {
-      console.log(`  ${chalk2.green("+")} .claude/settings.json ${chalk2.dim("\u2014 tool permissions & hooks")}`);
+      console.log(fileEntry(".claude/settings.json", descriptions[".claude/settings.json"]));
     }
     if (claude.settingsLocal) {
-      console.log(`  ${chalk2.green("+")} .claude/settings.local.json ${chalk2.dim("\u2014 local dev permissions")}`);
+      console.log(fileEntry(".claude/settings.local.json", descriptions[".claude/settings.local.json"]));
     }
     const skills = claude.skills;
     if (Array.isArray(skills) && skills.length > 0) {
-      console.log(`  ${chalk2.green("+")} ${skills.length} skill${skills.length > 1 ? "s" : ""}:`);
       for (const skill of skills) {
-        console.log(`    ${chalk2.dim("\u2022")} ${skill.name}`);
+        const skillPath = `.claude/skills/${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
+        console.log(fileEntry(skillPath, descriptions[skillPath] || skill.name));
       }
     }
     const mcpServers = claude.mcpServers;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const names = Object.keys(mcpServers);
-      console.log(`  ${chalk2.green("+")} ${names.length} MCP server${names.length > 1 ? "s" : ""}:`);
-      for (const name of names) {
-        console.log(`    ${chalk2.dim("\u2022")} ${name}`);
-      }
+      console.log(fileEntry(".mcp.json", descriptions[".mcp.json"] || Object.keys(mcpServers).join(", ")));
     }
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      console.log(`  ${chalk2.green("+")} .cursorrules ${chalk2.dim("\u2014 coding rules for Cursor")}`);
+      console.log(fileEntry(".cursorrules", descriptions[".cursorrules"]));
     }
     const rules = cursor.rules;
     if (Array.isArray(rules) && rules.length > 0) {
-      console.log(`  ${chalk2.green("+")} ${rules.length} Cursor rule${rules.length > 1 ? "s" : ""}:`);
       for (const rule of rules) {
-        console.log(`    ${chalk2.dim("\u2022")} ${rule.filename}`);
+        const rulePath = `.cursor/rules/${rule.filename}`;
+        console.log(fileEntry(rulePath, descriptions[rulePath]));
       }
     }
     const mcpServers = cursor.mcpServers;
     if (mcpServers && Object.keys(mcpServers).length > 0) {
-      const names = Object.keys(mcpServers);
-      console.log(`  ${chalk2.green("+")} ${names.length} MCP server${names.length > 1 ? "s" : ""}:`);
-      for (const name of names) {
-        console.log(`    ${chalk2.dim("\u2022")} ${name}`);
-      }
+      console.log(fileEntry(".cursor/mcp.json", descriptions[".cursor/mcp.json"] || Object.keys(mcpServers).join(", ")));
     }
   }
   console.log("");
+  console.log(`  ${chalk2.green("+")} ${chalk2.dim("new")}  ${chalk2.yellow("~")} ${chalk2.dim("modified")}`);
+  console.log("");
+}
+function printExplanation(explanation) {
+  console.log(chalk2.bold("\n  Why this setup?\n"));
+  const lines = explanation.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const headerMatch = trimmed.match(/^\[(.+)\]$/);
+    if (headerMatch) {
+      console.log(`  ${chalk2.bold.hex("#6366f1")(headerMatch[1])}`);
+      continue;
+    }
+    const itemMatch = trimmed.match(/^-\s+\*\*(.+?)\*\*[:\s]*(.*)$/);
+    if (itemMatch) {
+      const name = itemMatch[1];
+      const desc = itemMatch[2].replace(/^\s*[-—:]\s*/, "");
+      console.log(`    ${chalk2.dim("\u25B8")} ${chalk2.white(name)}  ${chalk2.dim(desc)}`);
+      continue;
+    }
+    const plainMatch = trimmed.match(/^-\s+(.*)$/);
+    if (plainMatch) {
+      console.log(`    ${chalk2.dim("\u25B8")} ${chalk2.dim(plainMatch[1])}`);
+      continue;
+    }
+    console.log(`  ${chalk2.dim(trimmed)}`);
+  }
+  console.log("");
 }
 
 // src/commands/undo.ts
@@ -1293,14 +1683,150 @@ function undoCommand() {
     console.log("");
   } catch (err) {
     spinner.fail(chalk3.red(err instanceof Error ? err.message : "Undo failed"));
-    process.exit(1);
+    throw new Error("__exit__");
   }
 }
 
 // src/commands/status.ts
 import chalk4 from "chalk";
-import fs11 from "fs";
-function statusCommand(options) {
+import fs15 from "fs";
+
+// src/scanner/index.ts
+import fs14 from "fs";
+import path12 from "path";
+import crypto4 from "crypto";
+function scanLocalState(dir) {
+  const items = [];
+  const claudeMdPath = path12.join(dir, "CLAUDE.md");
+  if (fs14.existsSync(claudeMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "claude",
+      name: "CLAUDE.md",
+      contentHash: hashFile(claudeMdPath),
+      path: claudeMdPath
+    });
+  }
+  const settingsPath = path12.join(dir, ".claude", "settings.json");
+  if (fs14.existsSync(settingsPath)) {
+    items.push({
+      type: "config",
+      platform: "claude",
+      name: "settings.json",
+      contentHash: hashFile(settingsPath),
+      path: settingsPath
+    });
+  }
+  const skillsDir = path12.join(dir, ".claude", "skills");
+  if (fs14.existsSync(skillsDir)) {
+    for (const file of fs14.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path12.join(skillsDir, file);
+      items.push({
+        type: "skill",
+        platform: "claude",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const mcpJsonPath = path12.join(dir, ".mcp.json");
+  if (fs14.existsSync(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "claude",
+            name,
+            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
+            path: mcpJsonPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const cursorrulesPath = path12.join(dir, ".cursorrules");
+  if (fs14.existsSync(cursorrulesPath)) {
+    items.push({
+      type: "rule",
+      platform: "cursor",
+      name: ".cursorrules",
+      contentHash: hashFile(cursorrulesPath),
+      path: cursorrulesPath
+    });
+  }
+  const cursorRulesDir = path12.join(dir, ".cursor", "rules");
+  if (fs14.existsSync(cursorRulesDir)) {
+    for (const file of fs14.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path12.join(cursorRulesDir, file);
+      items.push({
+        type: "rule",
+        platform: "cursor",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const cursorMcpPath = path12.join(dir, ".cursor", "mcp.json");
+  if (fs14.existsSync(cursorMcpPath)) {
+    try {
+      const mcpJson = JSON.parse(fs14.readFileSync(cursorMcpPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "cursor",
+            name,
+            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
+            path: cursorMcpPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return items;
+}
+function compareState(serverItems, localItems) {
+  const installed = [];
+  const missing = [];
+  const outdated = [];
+  const extra = [];
+  const localMap = /* @__PURE__ */ new Map();
+  for (const item of localItems) {
+    localMap.set(`${item.type}:${item.platform}:${item.name}`, item);
+  }
+  for (const server of serverItems) {
+    const key = `${server.type}:${server.platform}:${server.name}`;
+    const local = localMap.get(key);
+    localMap.delete(key);
+    if (!local) {
+      missing.push(server);
+    } else if (local.contentHash !== server.content_hash) {
+      outdated.push({ server, local });
+    } else {
+      installed.push({ server, local });
+    }
+  }
+  for (const local of localMap.values()) {
+    extra.push(local);
+  }
+  return { installed, missing, outdated, extra };
+}
+function hashFile(filePath) {
+  const content = fs14.readFileSync(filePath);
+  return crypto4.createHash("sha256").update(content).digest("hex");
+}
+function hashContent(content) {
+  return crypto4.createHash("sha256").update(JSON.stringify({ text: content })).digest("hex");
+}
+
+// src/commands/status.ts
+async function statusCommand(options) {
   const auth2 = getStoredAuth();
   const manifest = readManifest();
   if (options.json) {
@@ -1324,10 +1850,34 @@ function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk4.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs11.existsSync(entry.path);
+    const exists = fs15.existsSync(entry.path);
     const icon = exists ? chalk4.green("\u2713") : chalk4.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
+  if (auth2) {
+    try {
+      const fingerprint = collectFingerprint(process.cwd());
+      const hash = computeFingerprintHash(fingerprint);
+      const match = await apiRequest(
+        "/api/projects/match",
+        { method: "POST", body: { fingerprintHash: hash } }
+      );
+      if (match?.project) {
+        const serverItems = await apiRequest(
+          `/api/sync/project/${match.project.id}/items`
+        );
+        if (serverItems?.length) {
+          const localItems = scanLocalState(process.cwd());
+          const diff = compareState(serverItems, localItems);
+          console.log(chalk4.bold("\n  Sync"));
+          console.log(`    ${chalk4.green("\u2713")} Installed: ${diff.installed.length}`);
+          if (diff.missing.length) console.log(`    ${chalk4.red("\u2717")} Missing: ${diff.missing.length}`);
+          if (diff.outdated.length) console.log(`    ${chalk4.yellow("~")} Outdated: ${diff.outdated.length}`);
+        }
+      }
+    } catch {
+    }
+  }
   console.log("");
 }
 
@@ -1339,12 +1889,12 @@ async function updateCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
     console.log(chalk5.red("Not logged in. Run `caliber login` first."));
-    process.exit(1);
+    throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
     console.log(chalk5.yellow("No existing setup found. Run `caliber init` first."));
-    process.exit(1);
+    throw new Error("__exit__");
   }
   const spinner = ora4("Re-analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
@@ -1362,53 +1912,55 @@ async function updateCommand(options) {
   });
   let generatedSetup = null;
   trackEvent("generation_started", { target_agent: "both" });
-  const generationStart = Date.now();
   const genSpinner = ora4("Regenerating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES);
   genMessages.start();
-  await apiStream(
-    "/api/setups/generate",
-    {
-      fingerprint,
-      targetAgent: "both"
-    },
-    () => {
-    },
-    (payload) => {
-      generatedSetup = payload.setup;
-    },
-    (error) => {
-      genMessages.stop();
-      trackEvent("error_occurred", { error_type: "generation_failed", error_message: error });
-      genSpinner.fail(`Generation error: ${error}`);
-    },
-    (status) => {
-      genMessages.handleServerStatus(status);
-    }
-  );
+  try {
+    await apiStream(
+      "/api/setups/generate",
+      {
+        fingerprint,
+        targetAgent: "both"
+      },
+      () => {
+      },
+      (payload) => {
+        generatedSetup = payload.setup;
+      },
+      (error) => {
+        genMessages.stop();
+        trackEvent("error_occurred", { error_type: "generation_failed", error_message: error, command: "update" });
+        genSpinner.fail(`Generation error: ${error}`);
+      },
+      (status) => {
+        genMessages.handleServerStatus(status);
+      }
+    );
+  } catch (err) {
+    genMessages.stop();
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    trackEvent("error_occurred", { error_type: "generation_request_failed", error_message: msg, command: "update" });
+    genSpinner.fail(`Regeneration failed: ${msg}`);
+    throw new Error("__exit__");
+  }
   genMessages.stop();
   if (!generatedSetup) {
     genSpinner.fail("Failed to regenerate setup.");
-    process.exit(1);
+    throw new Error("__exit__");
   }
   genSpinner.succeed("Setup regenerated");
-  trackEvent("generation_completed", {
-    target_agent: "both",
-    duration_ms: Date.now() - generationStart,
-    files_suggested: countSuggestedFiles(generatedSetup)
-  });
   if (options.dryRun) {
     console.log(chalk5.yellow("\n[Dry run] Would write:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve) => {
-    rl.question(chalk5.cyan("\n\nApply updated setup? (y/n): "), resolve);
+  const answer = await new Promise((resolve2) => {
+    rl.question(chalk5.cyan("\n\nApply updated setup? (y/n): "), resolve2);
   });
   rl.close();
   if (answer.trim().toLowerCase() !== "y") {
-    trackEvent("generation_cancelled");
+    trackEvent("update_declined");
     console.log(chalk5.dim("Update cancelled."));
     return;
   }
@@ -1435,35 +1987,457 @@ function logoutCommand() {
   console.log(chalk6.green("Logged out successfully."));
 }
 
+// src/commands/recommend.ts
+import chalk7 from "chalk";
+import ora5 from "ora";
+async function recommendCommand(options) {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk7.red("Not authenticated. Run `caliber login` first."));
+    throw new Error("__exit__");
+  }
+  const fingerprint = collectFingerprint(process.cwd());
+  const hash = computeFingerprintHash(fingerprint);
+  const match = await apiRequest(
+    "/api/projects/match",
+    { method: "POST", body: { fingerprintHash: hash } }
+  );
+  if (!match?.project) {
+    console.log(chalk7.yellow("No project found. Run `caliber init` first."));
+    throw new Error("__exit__");
+  }
+  const projectId = match.project.id;
+  if (options.generate) {
+    const spinner = ora5("Detecting technologies and searching for skills...").start();
+    try {
+      const recs2 = await apiRequest(
+        `/api/recommendations/project/${projectId}/generate`,
+        { method: "POST" }
+      );
+      spinner.succeed(`Found ${recs2?.length || 0} recommendations`);
+      if (recs2?.length) {
+        console.log("");
+        printRecommendations(recs2);
+      }
+    } catch (err) {
+      spinner.fail("Failed to generate recommendations");
+      throw err;
+    }
+    return;
+  }
+  const statusFilter = options.status || "pending";
+  const recs = await apiRequest(
+    `/api/recommendations/project/${projectId}?status=${statusFilter}`
+  );
+  if (!recs?.length) {
+    console.log(chalk7.dim(`
+No ${statusFilter} recommendations. Run \`caliber recommend --generate\` to discover skills.
+`));
+    return;
+  }
+  printRecommendations(recs);
+}
+function printRecommendations(recs) {
+  console.log(chalk7.bold("\n  Skill Recommendations\n"));
+  console.log(
+    `  ${chalk7.dim("Name".padEnd(30))} ${chalk7.dim("Score".padEnd(8))} ${chalk7.dim("Technology".padEnd(15))} ${chalk7.dim("Status")}`
+  );
+  console.log(chalk7.dim("  " + "\u2500".repeat(70)));
+  for (const rec of recs) {
+    const scoreColor = rec.score >= 90 ? chalk7.green : rec.score >= 70 ? chalk7.blue : chalk7.yellow;
+    console.log(
+      `  ${rec.skill_name.padEnd(30)} ${scoreColor(`${rec.score}%`.padEnd(8))} ${rec.detected_technology.padEnd(15)} ${rec.status}`
+    );
+    if (rec.reason) {
+      console.log(`  ${chalk7.dim(rec.reason)}`);
+    }
+  }
+  console.log("");
+}
+
+// src/commands/health.ts
+import chalk8 from "chalk";
+import ora6 from "ora";
+async function healthCommand(options) {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk8.red("Not authenticated. Run `caliber login` first."));
+    throw new Error("__exit__");
+  }
+  const fingerprint = collectFingerprint(process.cwd());
+  const hash = computeFingerprintHash(fingerprint);
+  const match = await apiRequest(
+    "/api/projects/match",
+    { method: "POST", body: { fingerprintHash: hash } }
+  );
+  if (!match?.project) {
+    console.log(chalk8.yellow("No project found. Run `caliber init` first."));
+    throw new Error("__exit__");
+  }
+  const projectId = match.project.id;
+  const spinner = ora6("Analyzing context health...").start();
+  let report;
+  try {
+    report = await apiRequest(
+      `/api/context/project/${projectId}/analyze`,
+      { method: "POST" }
+    );
+    spinner.succeed("Analysis complete");
+  } catch (err) {
+    spinner.fail("Analysis failed");
+    throw err;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  printReport(report);
+  if (options.fix) {
+    console.log(chalk8.bold("\nGenerating fix plan..."));
+    const plan = await apiRequest(
+      `/api/context/reports/${report.id}/fix-plan`,
+      { method: "POST", body: { projectId } }
+    );
+    if (!plan?.actions.length) {
+      console.log(chalk8.dim("No fixes needed."));
+      return;
+    }
+    console.log(chalk8.bold("\nProposed actions:"));
+    for (const action of plan.actions) {
+      const icon = action.type === "remove" ? chalk8.red("- ") : action.type === "add" ? chalk8.green("+ ") : chalk8.yellow("~ ");
+      console.log(`  ${icon}${action.type}: ${action.items.join(", ")}`);
+    }
+    console.log(chalk8.dim(`
+Estimated improvement: +${plan.estimatedScoreImprovement} points`));
+    const fixSpinner = ora6("Executing fix plan...").start();
+    try {
+      const result = await apiRequest(
+        `/api/context/reports/${report.id}/fix-execute`,
+        { method: "POST", body: { projectId } }
+      );
+      fixSpinner.succeed("Fix applied");
+      console.log("");
+      console.log(`  Score: ${result.scoreBefore} \u2192 ${chalk8.green(String(result.scoreAfter))} (${chalk8.green(`+${result.improvement}`)})`);
+      if (result.itemsRemoved) console.log(`  Removed: ${result.itemsRemoved} items`);
+      if (result.itemsConsolidated) console.log(`  Consolidated: ${result.itemsConsolidated} items`);
+      if (result.itemsAdded) console.log(`  Added: ${result.itemsAdded} items`);
+      console.log("");
+    } catch (err) {
+      fixSpinner.fail("Fix execution failed");
+      throw err;
+    }
+  }
+}
+function printReport(report) {
+  const gradeColors = {
+    A: chalk8.green,
+    B: chalk8.blue,
+    C: chalk8.yellow,
+    D: chalk8.hex("#FFA500"),
+    F: chalk8.red
+  };
+  const gradeColor = gradeColors[report.grade] || chalk8.white;
+  console.log(chalk8.bold("\n  Context Health Report\n"));
+  console.log(`  Grade: ${gradeColor(report.grade)}  Score: ${gradeColor(String(report.score))}/100
+`);
+  if (Object.keys(report.category_breakdown).length) {
+    console.log(chalk8.dim("  Category Breakdown:"));
+    const categories = Object.entries(report.category_breakdown);
+    const maxCount = Math.max(...categories.map(([, v]) => v.count));
+    for (const [name, data] of categories) {
+      const barLen = maxCount > 0 ? Math.round(data.count / maxCount * 20) : 0;
+      const bar = "\u2588".repeat(barLen) + "\u2591".repeat(20 - barLen);
+      console.log(`    ${name.padEnd(12)} ${bar} ${data.count} items (${data.tokens} tokens)`);
+    }
+    console.log("");
+  }
+  if (report.recommendations.length) {
+    console.log(chalk8.dim("  Recommendations:"));
+    for (const rec of report.recommendations) {
+      const icon = rec.priority === "high" ? chalk8.red("!") : rec.priority === "medium" ? chalk8.yellow("~") : chalk8.dim("-");
+      console.log(`    ${icon} ${rec.description}`);
+    }
+    console.log("");
+  }
+}
+
+// src/commands/sync.ts
+import chalk9 from "chalk";
+import ora7 from "ora";
+async function syncCommand(options) {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk9.red("Not authenticated. Run `caliber login` first."));
+    throw new Error("__exit__");
+  }
+  const fingerprint = collectFingerprint(process.cwd());
+  const hash = computeFingerprintHash(fingerprint);
+  const match = await apiRequest(
+    "/api/projects/match",
+    { method: "POST", body: { fingerprintHash: hash } }
+  );
+  if (!match?.project) {
+    console.log(chalk9.yellow("No project found. Run `caliber init` first."));
+    throw new Error("__exit__");
+  }
+  const projectId = match.project.id;
+  const spinner = ora7("Scanning local state...").start();
+  const localItems = scanLocalState(process.cwd());
+  spinner.text = "Fetching server items...";
+  const serverItems = await apiRequest(
+    `/api/sync/project/${projectId}/items`
+  );
+  spinner.succeed(`Found ${localItems.length} local items, ${serverItems?.length || 0} server items`);
+  if (!serverItems?.length) {
+    console.log(chalk9.dim("\nNo items configured on server. Run `caliber init` to set up your project.\n"));
+    return;
+  }
+  const platformFilter = options.platform;
+  const filteredServer = platformFilter ? serverItems.filter((i) => i.platform === platformFilter || i.platform === "both") : serverItems;
+  const filteredLocal = platformFilter ? localItems.filter((i) => i.platform === platformFilter) : localItems;
+  const diff = compareState(filteredServer, filteredLocal);
+  printDiff(diff);
+  if (diff.missing.length === 0 && diff.outdated.length === 0) {
+    console.log(chalk9.green("\nAll items synced.\n"));
+    await reportToServer(projectId, filteredServer, diff);
+    return;
+  }
+  if (options.dryRun) {
+    console.log(chalk9.dim("\nDry run \u2014 no changes made.\n"));
+    return;
+  }
+  const installSpinner = ora7("Installing missing and outdated items...").start();
+  try {
+    const setup = buildSetupFromItems([...diff.missing, ...diff.outdated.map((o) => o.server)]);
+    if (setup) {
+      writeSetup(setup);
+    }
+    installSpinner.succeed("Items synced successfully");
+  } catch (err) {
+    installSpinner.fail("Sync failed");
+    throw err;
+  }
+  await reportToServer(projectId, filteredServer, diff);
+}
+async function reportToServer(projectId, serverItems, diff) {
+  const items = [
+    ...diff.installed.map((i) => ({
+      itemId: i.server.id,
+      state: "installed",
+      localHash: i.local.contentHash
+    })),
+    ...diff.missing.map((i) => ({
+      itemId: i.id,
+      state: "missing"
+    })),
+    ...diff.outdated.map((i) => ({
+      itemId: i.server.id,
+      state: "outdated",
+      localHash: i.local.contentHash
+    })),
+    ...diff.extra.map((i) => ({
+      itemId: i.name,
+      state: "extra",
+      localHash: i.contentHash
+    }))
+  ];
+  const platforms = new Set(serverItems.map((i) => i.platform));
+  for (const platform of platforms) {
+    try {
+      await apiRequest(`/api/sync/project/${projectId}/report`, {
+        method: "POST",
+        body: {
+          platform,
+          items: items.filter((i) => {
+            const match = serverItems.find((s) => s.id === i.itemId);
+            return match?.platform === platform;
+          })
+        }
+      });
+    } catch {
+    }
+  }
+}
+function printDiff(diff) {
+  console.log(chalk9.bold("\n  Sync Status\n"));
+  if (diff.installed.length) {
+    console.log(`  ${chalk9.green("\u2713")} Installed: ${diff.installed.length}`);
+  }
+  if (diff.missing.length) {
+    console.log(`  ${chalk9.red("\u2717")} Missing: ${diff.missing.length}`);
+    for (const item of diff.missing) {
+      console.log(`    ${chalk9.red("-")} ${item.name} (${item.type}/${item.platform})`);
+    }
+  }
+  if (diff.outdated.length) {
+    console.log(`  ${chalk9.yellow("~")} Outdated: ${diff.outdated.length}`);
+    for (const item of diff.outdated) {
+      console.log(`    ${chalk9.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
+    }
+  }
+  if (diff.extra.length) {
+    console.log(`  ${chalk9.dim("+")} Extra (local only): ${diff.extra.length}`);
+    for (const item of diff.extra) {
+      console.log(`    ${chalk9.dim("+")} ${item.name} (${item.type}/${item.platform})`);
+    }
+  }
+  console.log("");
+}
+function buildSetupFromItems(items) {
+  if (!items.length) return null;
+  const claude = {};
+  const cursor = {};
+  let hasAny = false;
+  for (const item of items) {
+    const content = item.content;
+    if (item.platform === "claude" || item.platform === "both") {
+      if (item.type === "rule" && item.name === "CLAUDE.md") {
+        claude.claudeMd = content.text;
+        hasAny = true;
+      } else if (item.type === "config" && item.name === "settings.json") {
+        claude.settings = content;
+        hasAny = true;
+      } else if (item.type === "skill") {
+        if (!claude.skills) claude.skills = [];
+        claude.skills.push({
+          name: item.name,
+          content: content.text || ""
+        });
+        hasAny = true;
+      } else if (item.type === "mcp") {
+        if (!claude.mcpServers) claude.mcpServers = {};
+        claude.mcpServers[item.name] = content;
+        hasAny = true;
+      }
+    }
+    if (item.platform === "cursor" || item.platform === "both") {
+      if (item.type === "rule" && item.name === ".cursorrules") {
+        cursor.cursorrules = content.text;
+        hasAny = true;
+      } else if (item.type === "rule") {
+        if (!cursor.rules) cursor.rules = [];
+        cursor.rules.push({
+          filename: item.name,
+          content: content.text || ""
+        });
+        hasAny = true;
+      } else if (item.type === "mcp") {
+        if (!cursor.mcpServers) cursor.mcpServers = {};
+        cursor.mcpServers[item.name] = content;
+        hasAny = true;
+      }
+    }
+  }
+  if (!hasAny) return null;
+  const hasClaude = Object.keys(claude).length > 0;
+  const hasCursor = Object.keys(cursor).length > 0;
+  return {
+    targetAgent: hasClaude && hasCursor ? "both" : hasClaude ? "claude" : "cursor",
+    ...hasClaude ? { claude } : {},
+    ...hasCursor ? { cursor } : {}
+  };
+}
+
+// src/commands/diff.ts
+import chalk10 from "chalk";
+import ora8 from "ora";
+async function diffCommand(options) {
+  const auth2 = getStoredAuth();
+  if (!auth2) {
+    console.log(chalk10.red("Not authenticated. Run `caliber login` first."));
+    throw new Error("__exit__");
+  }
+  const fingerprint = collectFingerprint(process.cwd());
+  const hash = computeFingerprintHash(fingerprint);
+  const match = await apiRequest(
+    "/api/projects/match",
+    { method: "POST", body: { fingerprintHash: hash } }
+  );
+  if (!match?.project) {
+    console.log(chalk10.yellow("No project found. Run `caliber init` first."));
+    throw new Error("__exit__");
+  }
+  const projectId = match.project.id;
+  const spinner = ora8("Comparing local and server state...").start();
+  const localItems = scanLocalState(process.cwd());
+  const serverItems = await apiRequest(
+    `/api/sync/project/${projectId}/items`
+  );
+  spinner.stop();
+  if (!serverItems?.length) {
+    console.log(chalk10.dim("\nNo items configured on server.\n"));
+    return;
+  }
+  const platformFilter = options.platform;
+  const filteredServer = platformFilter ? serverItems.filter((i) => i.platform === platformFilter || i.platform === "both") : serverItems;
+  const filteredLocal = platformFilter ? localItems.filter((i) => i.platform === platformFilter) : localItems;
+  const diff = compareState(filteredServer, filteredLocal);
+  console.log(chalk10.bold("\n  Config Diff\n"));
+  if (diff.installed.length) {
+    console.log(`  ${chalk10.green("\u2713")} In sync: ${diff.installed.length}`);
+  }
+  if (diff.missing.length) {
+    console.log(`  ${chalk10.red("\u2717")} Missing locally: ${diff.missing.length}`);
+    for (const item of diff.missing) {
+      console.log(`    ${chalk10.red("-")} ${item.name} (${item.type}/${item.platform})`);
+    }
+  }
+  if (diff.outdated.length) {
+    console.log(`  ${chalk10.yellow("~")} Outdated: ${diff.outdated.length}`);
+    for (const item of diff.outdated) {
+      console.log(`    ${chalk10.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
+    }
+  }
+  if (diff.extra.length) {
+    console.log(`  ${chalk10.dim("+")} Local only: ${diff.extra.length}`);
+    for (const item of diff.extra) {
+      console.log(`    ${chalk10.dim("+")} ${item.name} (${item.type}/${item.platform})`);
+    }
+  }
+  if (diff.missing.length === 0 && diff.outdated.length === 0) {
+    console.log(chalk10.green("\n  Everything is in sync.\n"));
+  } else {
+    console.log(chalk10.dim("\n  Run `caliber sync` to apply changes.\n"));
+  }
+}
+
 // src/cli.ts
-var pkg2 = JSON.parse(
-  fs12.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+var __dirname2 = path13.dirname(fileURLToPath3(import.meta.url));
+var pkg3 = JSON.parse(
+  fs16.readFileSync(path13.resolve(__dirname2, "..", "package.json"), "utf-8")
 );
 var program = new Command();
-program.name("caliber").description("Configure your coding agent environment").version(pkg2.version);
+program.name("caliber").description("Configure your coding agent environment").version(pkg3.version);
 program.command("init").description("Initialize coding agent setup for this project").option("--agent <type>", "Target agent: claude, cursor, or both").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").action(initCommand);
 program.command("undo").description("Revert all config changes made by Caliber").action(undoCommand);
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(statusCommand);
 program.command("update").description("Re-analyze project and update setup").option("--dry-run", "Preview changes without writing files").action(updateCommand);
 program.command("login").description("Authenticate with Caliber").action(loginCommand);
 program.command("logout").description("Clear stored credentials").action(logoutCommand);
+program.command("recommend").description("Discover and manage skill recommendations").option("--generate", "Generate new recommendations").option("--status <status>", "Filter by status: pending, accepted, dismissed").action(recommendCommand);
+program.command("health").description("Analyze context health and quality").option("--fix", "Generate and execute a fix plan").option("--json", "Output as JSON").action(healthCommand);
+program.command("sync").description("Sync local config with server state").option("--platform <platform>", "Target platform: claude, cursor, or both").option("--dry-run", "Preview changes without writing files").action(syncCommand);
+program.command("diff").description("Compare local config with server state").option("--platform <platform>", "Target platform: claude, cursor, or both").action(diffCommand);
 
 // src/utils/version-check.ts
-import fs13 from "fs";
+import fs17 from "fs";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import readline3 from "readline";
 import { execSync as execSync2 } from "child_process";
-import chalk7 from "chalk";
-import ora5 from "ora";
-var pkg3 = JSON.parse(
-  fs13.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+import chalk11 from "chalk";
+import ora9 from "ora";
+var __dirname_vc = path14.dirname(fileURLToPath4(import.meta.url));
+var pkg4 = JSON.parse(
+  fs17.readFileSync(path14.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function promptYesNo(question) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(chalk7.cyan(`${question} `), (answer) => {
+  return new Promise((resolve2) => {
+    rl.question(chalk11.cyan(`${question} `), (answer) => {
       rl.close();
       const normalized = answer.trim().toLowerCase();
-      resolve(normalized === "" || normalized === "y" || normalized === "yes");
+      resolve2(normalized === "" || normalized === "y" || normalized === "yes");
     });
   });
 }
@@ -1479,22 +2453,22 @@ async function checkForUpdates() {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = pkg3.version;
+    const current = pkg4.version;
     if (current === latest) return;
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk7.yellow(
+        chalk11.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk7.bold("npm install -g @caliber-ai/cli")} to upgrade.
+Run ${chalk11.bold("npm install -g @caliber-ai/cli")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk7.yellow(`
+      chalk11.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await promptYesNo("Would you like to update now? (Y/n)");
@@ -1502,12 +2476,12 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
-    const spinner = ora5("Updating @caliber-ai/cli...").start();
+    const spinner = ora9("Updating @caliber-ai/cli...").start();
     try {
       execSync2("npm install -g @caliber-ai/cli", { stdio: "pipe" });
-      spinner.succeed(chalk7.green(`Updated to ${latest}`));
+      spinner.succeed(chalk11.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk7.dim(`
+      console.log(chalk11.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync2(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -1517,8 +2491,8 @@ Restarting: caliber ${args.join(" ")}
     } catch {
       spinner.fail("Update failed");
       console.log(
-        chalk7.yellow(
-          `Run ${chalk7.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
+        chalk11.yellow(
+          `Run ${chalk11.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
 `
         )
       );
@@ -1536,12 +2510,25 @@ if (firstRun) {
 var auth = getStoredAuth();
 if (auth) {
   identifyUser(auth.userId, auth.email);
+  Sentry.setUser({ id: auth.userId, email: auth.email });
 }
 await checkForUpdates();
-process.on("SIGINT", () => process.exit(130));
-process.on("SIGTERM", () => process.exit(143));
-program.parseAsync().finally(async () => {
-  await shutdownTelemetry();
-  process.exit(0);
-});
+async function gracefulExit(code) {
+  await Promise.all([
+    shutdownTelemetry(),
+    Sentry.flush(2e3)
+  ]);
+  process.exit(code);
+}
+process.on("SIGINT", () => gracefulExit(130));
+process.on("SIGTERM", () => gracefulExit(143));
+program.parseAsync().catch((err) => {
+  const msg = err instanceof Error ? err.message : "Unexpected error";
+  if (msg !== "__exit__") {
+    console.error(msg);
+    Sentry.captureException(err, { tags: { command: process.argv[2] || "unknown" } });
+  }
+  trackEvent("error_occurred", { error_type: "cli_crash", error_message: msg, command: process.argv[2] || "unknown" });
+  process.exitCode = 1;
+}).finally(() => gracefulExit(Number(process.exitCode ?? 0)));
 //# sourceMappingURL=bin.js.map