@rely-ai/caliber 1.26.1 → 1.27.0

package/dist/bin.js

@@ -180,7 +180,7 @@ __export(resolve_caliber_exports, {
   isCaliberCommand: () => isCaliberCommand,
   resolveCaliber: () => resolveCaliber
 });
-import fs19 from "fs";
+import fs20 from "fs";
 import { execSync as execSync6 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
@@ -202,7 +202,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs19.existsSync(binPath)) {
+  if (binPath && fs20.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -228,7 +228,7 @@ var init_resolve_caliber = __esm({
 import { execSync as execSync12, spawn as spawn3 } from "child_process";
 import fs26 from "fs";
 import path22 from "path";
-import os5 from "os";
+import os6 from "os";
 function getEmptyFilePath(proposedPath) {
   fs26.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
   const tempPath = path22.join(DIFF_TEMP_DIR, path22.basename(proposedPath));
@@ -272,7 +272,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path22.join(os5.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path22.join(os6.tmpdir(), "caliber-diff");
   }
 });
 
@@ -499,7 +499,7 @@ __export(lock_exports, {
 });
 import fs36 from "fs";
 import path28 from "path";
-import os7 from "os";
+import os8 from "os";
 function isCaliberRunning() {
   try {
     if (!fs36.existsSync(LOCK_FILE)) return false;
@@ -532,7 +532,7 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path28.join(os7.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path28.join(os8.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
@@ -2913,9 +2913,180 @@ async function enrichWithLLM(fingerprint) {
   }
 }
 
-// src/fingerprint/sources.ts
+// src/scanner/index.ts
 import fs8 from "fs";
 import path8 from "path";
+import crypto2 from "crypto";
+import os4 from "os";
+function detectPlatforms() {
+  const home = os4.homedir();
+  return {
+    claude: fs8.existsSync(path8.join(home, ".claude")),
+    cursor: fs8.existsSync(getCursorConfigDir()),
+    codex: fs8.existsSync(path8.join(home, ".codex"))
+  };
+}
+function scanLocalState(dir) {
+  const items = [];
+  const claudeMdPath = path8.join(dir, "CLAUDE.md");
+  if (fs8.existsSync(claudeMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "claude",
+      name: "CLAUDE.md",
+      contentHash: hashFile(claudeMdPath),
+      path: claudeMdPath
+    });
+  }
+  const skillsDir = path8.join(dir, ".claude", "skills");
+  if (fs8.existsSync(skillsDir)) {
+    for (const file of fs8.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path8.join(skillsDir, file);
+      items.push({
+        type: "skill",
+        platform: "claude",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const mcpJsonPath = path8.join(dir, ".mcp.json");
+  if (fs8.existsSync(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "claude",
+            name,
+            contentHash: hashJson(mcpJson.mcpServers[name]),
+            path: mcpJsonPath
+          });
+        }
+      }
+    } catch (error) {
+      warnScanSkip(".mcp.json", error);
+    }
+  }
+  const agentsMdPath = path8.join(dir, "AGENTS.md");
+  if (fs8.existsSync(agentsMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "codex",
+      name: "AGENTS.md",
+      contentHash: hashFile(agentsMdPath),
+      path: agentsMdPath
+    });
+  }
+  const codexSkillsDir = path8.join(dir, ".agents", "skills");
+  if (fs8.existsSync(codexSkillsDir)) {
+    try {
+      for (const name of fs8.readdirSync(codexSkillsDir)) {
+        const skillFile = path8.join(codexSkillsDir, name, "SKILL.md");
+        if (fs8.existsSync(skillFile)) {
+          items.push({
+            type: "skill",
+            platform: "codex",
+            name: `${name}/SKILL.md`,
+            contentHash: hashFile(skillFile),
+            path: skillFile
+          });
+        }
+      }
+    } catch (error) {
+      warnScanSkip(".agents/skills", error);
+    }
+  }
+  const cursorrulesPath = path8.join(dir, ".cursorrules");
+  if (fs8.existsSync(cursorrulesPath)) {
+    items.push({
+      type: "rule",
+      platform: "cursor",
+      name: ".cursorrules",
+      contentHash: hashFile(cursorrulesPath),
+      path: cursorrulesPath
+    });
+  }
+  const cursorRulesDir = path8.join(dir, ".cursor", "rules");
+  if (fs8.existsSync(cursorRulesDir)) {
+    for (const file of fs8.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path8.join(cursorRulesDir, file);
+      items.push({
+        type: "rule",
+        platform: "cursor",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const cursorSkillsDir = path8.join(dir, ".cursor", "skills");
+  if (fs8.existsSync(cursorSkillsDir)) {
+    try {
+      for (const name of fs8.readdirSync(cursorSkillsDir)) {
+        const skillFile = path8.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs8.existsSync(skillFile)) {
+          items.push({
+            type: "skill",
+            platform: "cursor",
+            name: `${name}/SKILL.md`,
+            contentHash: hashFile(skillFile),
+            path: skillFile
+          });
+        }
+      }
+    } catch (error) {
+      warnScanSkip(".cursor/skills", error);
+    }
+  }
+  const cursorMcpPath = path8.join(dir, ".cursor", "mcp.json");
+  if (fs8.existsSync(cursorMcpPath)) {
+    try {
+      const mcpJson = JSON.parse(fs8.readFileSync(cursorMcpPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "cursor",
+            name,
+            contentHash: hashJson(mcpJson.mcpServers[name]),
+            path: cursorMcpPath
+          });
+        }
+      }
+    } catch (error) {
+      warnScanSkip(".cursor/mcp.json", error);
+    }
+  }
+  return items;
+}
+function hashFile(filePath) {
+  const text = fs8.readFileSync(filePath, "utf-8");
+  return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
+}
+function hashJson(obj) {
+  return crypto2.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
+}
+function warnScanSkip(target, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`Warning: ${target} scan skipped (${message})`);
+}
+function getCursorConfigDir() {
+  const home = os4.homedir();
+  if (process.platform === "darwin") {
+    return path8.join(home, "Library", "Application Support", "Cursor");
+  }
+  if (process.platform === "win32") {
+    return path8.join(home, "AppData", "Roaming", "Cursor");
+  }
+  return path8.join(home, ".config", "Cursor");
+}
+
+// src/fingerprint/sources.ts
+import fs9 from "fs";
+import path9 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
@@ -3194,7 +3365,7 @@ var SOURCE_CONTENT_LIMIT = 2e3;
 var README_CONTENT_LIMIT = 1e3;
 var ORIGIN_PRIORITY = { cli: 0, config: 1, workspace: 2 };
 function loadSourcesConfig(dir) {
-  const configPath = path8.join(dir, ".caliber", "sources.json");
+  const configPath = path9.join(dir, ".caliber", "sources.json");
   const content = readFileOrNull(configPath);
   if (!content) return [];
   try {
@@ -3212,29 +3383,29 @@ function loadSourcesConfig(dir) {
   }
 }
 function writeSourcesConfig(dir, sources2) {
-  const configDir = path8.join(dir, ".caliber");
-  if (!fs8.existsSync(configDir)) {
-    fs8.mkdirSync(configDir, { recursive: true });
+  const configDir = path9.join(dir, ".caliber");
+  if (!fs9.existsSync(configDir)) {
+    fs9.mkdirSync(configDir, { recursive: true });
   }
-  const configPath = path8.join(configDir, "sources.json");
-  fs8.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  const configPath = path9.join(configDir, "sources.json");
+  fs9.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs8.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs9.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
 }
 function isInsideDir(childPath, parentDir) {
-  const relative2 = path8.relative(parentDir, childPath);
-  return !relative2.startsWith("..") && !path8.isAbsolute(relative2);
+  const relative2 = path9.relative(parentDir, childPath);
+  return !relative2.startsWith("..") && !path9.isAbsolute(relative2);
 }
 function resolveAllSources(dir, cliSources, workspaces) {
   const seen = /* @__PURE__ */ new Map();
-  const projectRoot = path8.resolve(dir);
+  const projectRoot = path9.resolve(dir);
   for (const src of cliSources) {
-    const absPath = path8.resolve(dir, src);
+    const absPath = path9.resolve(dir, src);
     if (seen.has(absPath)) continue;
     const type = detectSourceType(absPath);
     seen.set(absPath, {
@@ -3247,12 +3418,12 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const cfg of configSources) {
     if (cfg.type === "url") continue;
     if (!cfg.path) continue;
-    const absPath = path8.resolve(dir, cfg.path);
+    const absPath = path9.resolve(dir, cfg.path);
     if (seen.has(absPath)) continue;
     seen.set(absPath, { absPath, config: cfg, origin: "config" });
   }
   for (const ws of workspaces) {
-    const absPath = path8.resolve(dir, ws);
+    const absPath = path9.resolve(dir, ws);
     if (seen.has(absPath)) continue;
     if (!isInsideDir(absPath, projectRoot)) continue;
     seen.set(absPath, {
@@ -3265,7 +3436,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs8.statSync(absPath);
+      stat = fs9.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -3294,13 +3465,13 @@ function collectSourceSummary(resolved, projectDir) {
   if (config.type === "file") {
     return collectFileSummary(resolved, projectDir);
   }
-  const summaryPath = path8.join(absPath, ".caliber", "summary.json");
+  const summaryPath = path9.join(absPath, ".caliber", "summary.json");
   const summaryContent = readFileOrNull(summaryPath);
   if (summaryContent) {
     try {
       const published = JSON.parse(summaryContent);
       return {
-        name: published.name || path8.basename(absPath),
+        name: published.name || path9.basename(absPath),
         type: "repo",
         role: config.role || published.role || "related-repo",
         description: config.description || published.description || "",
@@ -3320,18 +3491,18 @@ function collectRepoSummary(resolved, projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs8.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs9.readdirSync(absPath, { withFileTypes: true });
     topLevelDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, 20);
     keyFiles = entries.filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => e.name).slice(0, 15);
   } catch {
   }
-  const claudeMdContent = readFileOrNull(path8.join(absPath, "CLAUDE.md"));
+  const claudeMdContent = readFileOrNull(path9.join(absPath, "CLAUDE.md"));
   const existingClaudeMd = claudeMdContent ? claudeMdContent.slice(0, SOURCE_CONTENT_LIMIT) : void 0;
-  const readmeContent = readFileOrNull(path8.join(absPath, "README.md"));
+  const readmeContent = readFileOrNull(path9.join(absPath, "README.md"));
   const readmeExcerpt = readmeContent ? readmeContent.slice(0, README_CONTENT_LIMIT) : void 0;
   const gitRemoteUrl = getGitRemoteUrl(absPath);
   return {
-    name: packageName || path8.basename(absPath),
+    name: packageName || path9.basename(absPath),
     type: "repo",
     role: config.role || "related-repo",
     description: config.description || "",
@@ -3348,7 +3519,7 @@ function collectFileSummary(resolved, projectDir) {
   const { config, origin, absPath } = resolved;
   const content = readFileOrNull(absPath);
   return {
-    name: path8.basename(absPath),
+    name: path9.basename(absPath),
     type: "file",
     role: config.role || "reference-doc",
     description: config.description || content?.slice(0, 100).split("\n")[0] || "",
@@ -3987,11 +4158,11 @@ ${f.content}
 }
 
 // src/writers/index.ts
-import fs16 from "fs";
+import fs17 from "fs";
 
 // src/writers/claude/index.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/writers/pre-commit-block.ts
 var BLOCK_START = "<!-- caliber:managed:pre-commit -->";
@@ -4057,13 +4228,13 @@ function getCursorLearningsRule() {
 // src/writers/claude/index.ts
 function writeClaudeConfig(config) {
   const written = [];
-  fs9.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
+  fs10.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path9.join(".claude", "skills", skill.name);
-      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path9.join(skillDir, "SKILL.md");
+      const skillDir = path10.join(".claude", "skills", skill.name);
+      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path10.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4071,50 +4242,50 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs9.writeFileSync(skillPath, frontmatter + skill.content);
+      fs10.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs9.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs9.readFileSync(".mcp.json", "utf-8"));
+      if (fs10.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs10.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs9.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs10.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs10.writeFileSync(".cursorrules", config.cursorrules);
+    fs11.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
   const learningsRule = getCursorLearningsRule();
   const allRules = [...config.rules || [], preCommitRule, learningsRule];
-  const rulesDir = path10.join(".cursor", "rules");
-  if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
+  const rulesDir = path11.join(".cursor", "rules");
+  if (!fs11.existsSync(rulesDir)) fs11.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
-    const rulePath = path10.join(rulesDir, rule.filename);
-    fs10.writeFileSync(rulePath, rule.content);
+    const rulePath = path11.join(rulesDir, rule.filename);
+    fs11.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path10.join(".cursor", "skills", skill.name);
-      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path10.join(skillDir, "SKILL.md");
+      const skillDir = path11.join(".cursor", "skills", skill.name);
+      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path11.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4122,41 +4293,41 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs10.writeFileSync(skillPath, frontmatter + skill.content);
+      fs11.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs10.existsSync(cursorDir)) fs10.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path10.join(cursorDir, "mcp.json");
+    if (!fs11.existsSync(cursorDir)) fs11.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path11.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs10.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
+      if (fs11.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs10.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs11.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
 }
 
 // src/writers/codex/index.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs11.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  fs12.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path11.join(".agents", "skills", skill.name);
-      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path11.join(skillDir, "SKILL.md");
+      const skillDir = path12.join(".agents", "skills", skill.name);
+      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4164,7 +4335,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs11.writeFileSync(skillPath, frontmatter + skill.content);
+      fs12.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -4172,20 +4343,20 @@ function writeCodexConfig(config) {
 }
 
 // src/writers/github-copilot/index.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs12.mkdirSync(".github", { recursive: true });
-    fs12.writeFileSync(path12.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
+    fs13.mkdirSync(".github", { recursive: true });
+    fs13.writeFileSync(path13.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
-    const instructionsDir = path12.join(".github", "instructions");
-    fs12.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path13.join(".github", "instructions");
+    fs13.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs12.writeFileSync(path12.join(instructionsDir, file.filename), file.content);
+      fs13.writeFileSync(path13.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -4193,36 +4364,36 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path13.join(BACKUPS_DIR, timestamp);
+  const backupDir = path14.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs13.existsSync(file)) continue;
-    const dest = path13.join(backupDir, file);
-    const destDir = path13.dirname(dest);
-    if (!fs13.existsSync(destDir)) {
-      fs13.mkdirSync(destDir, { recursive: true });
+    if (!fs14.existsSync(file)) continue;
+    const dest = path14.join(backupDir, file);
+    const destDir = path14.dirname(dest);
+    if (!fs14.existsSync(destDir)) {
+      fs14.mkdirSync(destDir, { recursive: true });
     }
-    fs13.copyFileSync(file, dest);
+    fs14.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path13.join(backupDir, file);
-  if (!fs13.existsSync(backupFile)) return false;
-  const destDir = path13.dirname(file);
-  if (!fs13.existsSync(destDir)) {
-    fs13.mkdirSync(destDir, { recursive: true });
+  const backupFile = path14.join(backupDir, file);
+  if (!fs14.existsSync(backupFile)) return false;
+  const destDir = path14.dirname(file);
+  if (!fs14.existsSync(destDir)) {
+    fs14.mkdirSync(destDir, { recursive: true });
   }
-  fs13.copyFileSync(backupFile, file);
+  fs14.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/lib/builtin-skills.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -4348,19 +4519,19 @@ User: "never use any in TypeScript, use unknown instead"
 };
 var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL];
 var PLATFORM_CONFIGS = [
-  { platformDir: ".claude", skillsDir: path14.join(".claude", "skills") },
-  { platformDir: ".cursor", skillsDir: path14.join(".cursor", "skills") },
-  { platformDir: ".agents", skillsDir: path14.join(".agents", "skills") }
+  { platformDir: ".claude", skillsDir: path15.join(".claude", "skills") },
+  { platformDir: ".cursor", skillsDir: path15.join(".cursor", "skills") },
+  { platformDir: ".agents", skillsDir: path15.join(".agents", "skills") }
 ];
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs14.existsSync(platformDir)) continue;
+    if (!fs15.existsSync(platformDir)) continue;
     for (const skill of BUILTIN_SKILLS) {
-      const skillPath = path14.join(skillsDir, skill.name, "SKILL.md");
-      if (fs14.existsSync(skillPath)) continue;
-      fs14.mkdirSync(path14.dirname(skillPath), { recursive: true });
-      fs14.writeFileSync(skillPath, buildSkillContent(skill));
+      const skillPath = path15.join(skillsDir, skill.name, "SKILL.md");
+      if (fs15.existsSync(skillPath)) continue;
+      fs15.mkdirSync(path15.dirname(skillPath), { recursive: true });
+      fs15.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -4368,33 +4539,33 @@ function ensureBuiltinSkills() {
 }
 
 // src/writers/manifest.ts
-import fs15 from "fs";
-import crypto2 from "crypto";
+import fs16 from "fs";
+import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs15.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs15.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs16.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs16.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs15.existsSync(CALIBER_DIR)) {
-    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs16.existsSync(CALIBER_DIR)) {
+    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs15.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs16.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs15.readFileSync(filePath);
-  return crypto2.createHash("sha256").update(content).digest("hex");
+  const content = fs16.readFileSync(filePath);
+  return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs16.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs17.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs16.existsSync(f)),
+    ...filesToWrite.filter((f) => fs17.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -4413,7 +4584,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs16.unlinkSync(filePath);
+    fs17.unlinkSync(filePath);
     deleted.push(filePath);
   }
   written.push(...ensureBuiltinSkills());
@@ -4444,8 +4615,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs16.existsSync(entry.path)) {
-        fs16.unlinkSync(entry.path);
+      if (fs17.existsSync(entry.path)) {
+        fs17.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -4454,8 +4625,8 @@ function undoSetup() {
       }
     }
   }
-  if (fs16.existsSync(MANIFEST_FILE)) {
-    fs16.unlinkSync(MANIFEST_FILE);
+  if (fs17.existsSync(MANIFEST_FILE)) {
+    fs17.unlinkSync(MANIFEST_FILE);
   }
   return { restored, removed };
 }
@@ -4496,22 +4667,22 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs16.existsSync(gitignorePath)) {
-    const content = fs16.readFileSync(gitignorePath, "utf-8");
+  if (fs17.existsSync(gitignorePath)) {
+    const content = fs17.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs16.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs17.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs16.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs17.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
-import fs17 from "fs";
-import path15 from "path";
-var STAGED_DIR = path15.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path15.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path15.join(STAGED_DIR, "current");
+import fs18 from "fs";
+import path16 from "path";
+var STAGED_DIR = path16.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path16.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path16.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4521,20 +4692,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path15.join(projectDir, file.path);
-    if (fs17.existsSync(originalPath)) {
-      const existing = fs17.readFileSync(originalPath, "utf-8");
+    const originalPath = path16.join(projectDir, file.path);
+    if (fs18.existsSync(originalPath)) {
+      const existing = fs18.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path15.join(PROPOSED_DIR, file.path);
-    fs17.mkdirSync(path15.dirname(proposedPath), { recursive: true });
-    fs17.writeFileSync(proposedPath, file.content);
-    if (fs17.existsSync(originalPath)) {
-      const currentPath = path15.join(CURRENT_DIR, file.path);
-      fs17.mkdirSync(path15.dirname(currentPath), { recursive: true });
-      fs17.copyFileSync(originalPath, currentPath);
+    const proposedPath = path16.join(PROPOSED_DIR, file.path);
+    fs18.mkdirSync(path16.dirname(proposedPath), { recursive: true });
+    fs18.writeFileSync(proposedPath, file.content);
+    if (fs18.existsSync(originalPath)) {
+      const currentPath = path16.join(CURRENT_DIR, file.path);
+      fs18.mkdirSync(path16.dirname(currentPath), { recursive: true });
+      fs18.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -4545,13 +4716,13 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs17.existsSync(STAGED_DIR)) {
-    fs17.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs18.existsSync(STAGED_DIR)) {
+    fs18.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs18 from "fs";
+import fs19 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -4610,7 +4781,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs18.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs19.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -4628,9 +4799,9 @@ ${agentRefs.join(" ")}
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs20 from "fs";
-import path16 from "path";
-var SETTINGS_PATH = path16.join(".claude", "settings.json");
+import fs21 from "fs";
+import path17 from "path";
+var SETTINGS_PATH = path17.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -4647,17 +4818,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings() {
-  if (!fs20.existsSync(SETTINGS_PATH)) return {};
+  if (!fs21.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs20.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs21.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path16.dirname(SETTINGS_PATH);
-  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-  fs20.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path17.dirname(SETTINGS_PATH);
+  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
+  fs21.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -4691,7 +4862,7 @@ function installLearningHooks() {
   writeSettings(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path16.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path17.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -4699,17 +4870,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs21.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs20.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs21.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path16.dirname(CURSOR_HOOKS_PATH);
-  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-  fs20.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path17.dirname(CURSOR_HOOKS_PATH);
+  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
+  fs21.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -4778,10 +4949,10 @@ function removeLearningHooks() {
 }
 
 // src/lib/state.ts
-import fs21 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path18 from "path";
 import { execSync as execSync7 } from "child_process";
-var STATE_FILE = path17.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path18.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -4792,8 +4963,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs21.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs21.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs22.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs22.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -4801,10 +4972,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs21.existsSync(CALIBER_DIR)) {
-    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs22.existsSync(CALIBER_DIR)) {
+    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs21.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs22.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -5862,22 +6033,22 @@ function checkSources(dir) {
 }
 
 // src/scoring/dismissed.ts
-import fs22 from "fs";
-import path18 from "path";
-var DISMISSED_FILE = path18.join(CALIBER_DIR, "dismissed-checks.json");
+import fs23 from "fs";
+import path19 from "path";
+var DISMISSED_FILE = path19.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs22.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs22.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs23.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs23.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs22.existsSync(CALIBER_DIR)) {
-    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs23.existsSync(CALIBER_DIR)) {
+    fs23.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs22.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs23.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -6123,160 +6294,6 @@ import ora from "ora";
 import select3 from "@inquirer/select";
 import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4, existsSync as existsSync8, writeFileSync } from "fs";
 import { join as join10, dirname as dirname2 } from "path";
-
-// src/scanner/index.ts
-import fs23 from "fs";
-import path19 from "path";
-import crypto3 from "crypto";
-function scanLocalState(dir) {
-  const items = [];
-  const claudeMdPath = path19.join(dir, "CLAUDE.md");
-  if (fs23.existsSync(claudeMdPath)) {
-    items.push({
-      type: "rule",
-      platform: "claude",
-      name: "CLAUDE.md",
-      contentHash: hashFile(claudeMdPath),
-      path: claudeMdPath
-    });
-  }
-  const skillsDir = path19.join(dir, ".claude", "skills");
-  if (fs23.existsSync(skillsDir)) {
-    for (const file of fs23.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path19.join(skillsDir, file);
-      items.push({
-        type: "skill",
-        platform: "claude",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const mcpJsonPath = path19.join(dir, ".mcp.json");
-  if (fs23.existsSync(mcpJsonPath)) {
-    try {
-      const mcpJson = JSON.parse(fs23.readFileSync(mcpJsonPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "claude",
-            name,
-            contentHash: hashJson(mcpJson.mcpServers[name]),
-            path: mcpJsonPath
-          });
-        }
-      }
-    } catch (error) {
-      warnScanSkip(".mcp.json", error);
-    }
-  }
-  const agentsMdPath = path19.join(dir, "AGENTS.md");
-  if (fs23.existsSync(agentsMdPath)) {
-    items.push({
-      type: "rule",
-      platform: "codex",
-      name: "AGENTS.md",
-      contentHash: hashFile(agentsMdPath),
-      path: agentsMdPath
-    });
-  }
-  const codexSkillsDir = path19.join(dir, ".agents", "skills");
-  if (fs23.existsSync(codexSkillsDir)) {
-    try {
-      for (const name of fs23.readdirSync(codexSkillsDir)) {
-        const skillFile = path19.join(codexSkillsDir, name, "SKILL.md");
-        if (fs23.existsSync(skillFile)) {
-          items.push({
-            type: "skill",
-            platform: "codex",
-            name: `${name}/SKILL.md`,
-            contentHash: hashFile(skillFile),
-            path: skillFile
-          });
-        }
-      }
-    } catch (error) {
-      warnScanSkip(".agents/skills", error);
-    }
-  }
-  const cursorrulesPath = path19.join(dir, ".cursorrules");
-  if (fs23.existsSync(cursorrulesPath)) {
-    items.push({
-      type: "rule",
-      platform: "cursor",
-      name: ".cursorrules",
-      contentHash: hashFile(cursorrulesPath),
-      path: cursorrulesPath
-    });
-  }
-  const cursorRulesDir = path19.join(dir, ".cursor", "rules");
-  if (fs23.existsSync(cursorRulesDir)) {
-    for (const file of fs23.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path19.join(cursorRulesDir, file);
-      items.push({
-        type: "rule",
-        platform: "cursor",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
-  if (fs23.existsSync(cursorSkillsDir)) {
-    try {
-      for (const name of fs23.readdirSync(cursorSkillsDir)) {
-        const skillFile = path19.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs23.existsSync(skillFile)) {
-          items.push({
-            type: "skill",
-            platform: "cursor",
-            name: `${name}/SKILL.md`,
-            contentHash: hashFile(skillFile),
-            path: skillFile
-          });
-        }
-      }
-    } catch (error) {
-      warnScanSkip(".cursor/skills", error);
-    }
-  }
-  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
-  if (fs23.existsSync(cursorMcpPath)) {
-    try {
-      const mcpJson = JSON.parse(fs23.readFileSync(cursorMcpPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "cursor",
-            name,
-            contentHash: hashJson(mcpJson.mcpServers[name]),
-            path: cursorMcpPath
-          });
-        }
-      }
-    } catch (error) {
-      warnScanSkip(".cursor/mcp.json", error);
-    }
-  }
-  return items;
-}
-function hashFile(filePath) {
-  const text = fs23.readFileSync(filePath, "utf-8");
-  return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
-}
-function hashJson(obj) {
-  return crypto3.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
-}
-function warnScanSkip(target, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.warn(`Warning: ${target} scan skipped (${message})`);
-}
-
-// src/commands/recommend.ts
 init_config();
 
 // src/telemetry/index.ts
@@ -6286,10 +6303,10 @@ import chalk5 from "chalk";
 // src/telemetry/config.ts
 import fs24 from "fs";
 import path20 from "path";
-import os4 from "os";
+import os5 from "os";
 import crypto4 from "crypto";
 import { execSync as execSync11 } from "child_process";
-var CONFIG_DIR2 = path20.join(os4.homedir(), ".caliber");
+var CONFIG_DIR2 = path20.join(os5.homedir(), ".caliber");
 var CONFIG_FILE2 = path20.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
@@ -8569,6 +8586,11 @@ async function initCommand(options) {
   } else {
     console.log(brand.bold("\n  CALIBER") + chalk14.dim("  \u2014 regenerating config\n"));
   }
+  const platforms = detectPlatforms();
+  if (!platforms.claude && !platforms.cursor && !platforms.codex) {
+    console.log(chalk14.yellow("  \u26A0 No supported AI platforms detected (Claude, Cursor, Codex)."));
+    console.log(chalk14.yellow("    Caliber will still generate config files, but they won't be auto-installed.\n"));
+  }
   const report = options.debugReport ? new DebugReport() : null;
   console.log(title.bold("  Step 1/4 \u2014 Setup\n"));
   let config = loadConfig();
@@ -9304,7 +9326,7 @@ async function regenerateCommand(options) {
 
 // src/commands/score.ts
 import fs33 from "fs";
-import os6 from "os";
+import os7 from "os";
 import path25 from "path";
 import { execFileSync } from "child_process";
 import chalk18 from "chalk";
@@ -9312,7 +9334,7 @@ var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs33.mkdtempSync(path25.join(os6.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs33.mkdtempSync(path25.join(os7.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.26.1",
+  "version": "1.27.0",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {