@rely-ai/caliber 0.9.1 → 1.1.0

package/README.md

@@ -1,10 +1,14 @@
-# Caliber
+<p align="center">
+  <img src="assets/social-preview.svg" alt="Caliber" width="640">
+</p>
 
-[![npm version](https://img.shields.io/npm/v/@rely-ai/caliber)](https://www.npmjs.com/package/@rely-ai/caliber)
-[![license](https://img.shields.io/npm/l/@rely-ai/caliber)](./LICENSE)
-[![node](https://img.shields.io/node/v/@rely-ai/caliber)](https://nodejs.org)
+<p align="center">
+  <a href="https://www.npmjs.com/package/@rely-ai/caliber"><img src="https://img.shields.io/npm/v/@rely-ai/caliber" alt="npm version"></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/npm/l/@rely-ai/caliber" alt="license"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/@rely-ai/caliber" alt="node"></a>
+</p>
 
-**Analyze your codebase. Generate optimized AI agent configs. One command.**
+<p align="center"><strong>Analyze your codebase. Generate optimized AI agent configs. One command.</strong></p>
 
 Caliber scans your project — languages, frameworks, dependencies, file structure — and generates tailored config files for Claude Code and Cursor. If configs already exist, it audits them and suggests improvements.
 
@@ -13,7 +17,7 @@ Caliber scans your project — languages, frameworks, dependencies, file structu
 ## Quick Start
 
 ```bash
-npx @rely-ai/caliber init
+npx @rely-ai/caliber onboard
 ```
 
 That's it. On first run, Caliber walks you through provider setup interactively.
@@ -22,19 +26,19 @@ Or install globally:
 
 ```bash
 npm install -g @rely-ai/caliber
-caliber init
+caliber onboard
 ```
 
 > **Already have an API key?** Skip the interactive setup:
 > ```bash
 > export ANTHROPIC_API_KEY=sk-ant-...
-> npx @rely-ai/caliber init
+> npx @rely-ai/caliber onboard
 > ```
 
 ## How It Works
 
 ```
-caliber init
+caliber onboard
 │
 ├─ 1. Scan        Analyze languages, frameworks, dependencies, file structure,
 │                  and existing agent configs in your project
@@ -64,16 +68,16 @@ If these files already exist, Caliber audits them against your actual codebase a
 
 | Command | Description |
 |---------|-------------|
-| `caliber init` | Scan project, generate/audit agent configs, review and apply |
+| `caliber onboard` | Onboard your project for AI-assisted development |
 | `caliber score` | Score your config quality (deterministic, no LLM needed) |
 | `caliber recommend` | Discover and install skills from [skills.sh](https://skills.sh) |
 | `caliber config` | Configure LLM provider, API key, and model |
 
 ```bash
-caliber init --agent claude      # Target Claude Code only
-caliber init --agent cursor      # Target Cursor only
-caliber init --agent both        # Target both
-caliber init --dry-run           # Preview without writing files
+caliber onboard --agent claude      # Target Claude Code only
+caliber onboard --agent cursor      # Target Cursor only
+caliber onboard --agent both        # Target both
+caliber onboard --dry-run           # Preview without writing files
 caliber score --json             # Machine-readable output
 ```
 

package/dist/bin.js

@@ -51,16 +51,16 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs24 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path22 from "path";
 import { fileURLToPath } from "url";
 
-// src/commands/init.ts
+// src/commands/onboard.ts
 import chalk4 from "chalk";
 import ora from "ora";
 import readline3 from "readline";
 import select2 from "@inquirer/select";
-import fs17 from "fs";
+import fs18 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
@@ -2127,16 +2127,25 @@ import path12 from "path";
 var STAGED_DIR = path12.join(CALIBER_DIR, "staged");
 var PROPOSED_DIR = path12.join(STAGED_DIR, "proposed");
 var CURRENT_DIR = path12.join(STAGED_DIR, "current");
+function normalizeContent(content) {
+  return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function stageFiles(files, projectDir) {
   cleanupStaging();
   let newFiles = 0;
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
+    const originalPath = path12.join(projectDir, file.path);
+    if (fs13.existsSync(originalPath)) {
+      const existing = fs13.readFileSync(originalPath, "utf-8");
+      if (normalizeContent(existing) === normalizeContent(file.content)) {
+        continue;
+      }
+    }
     const proposedPath = path12.join(PROPOSED_DIR, file.path);
     fs13.mkdirSync(path12.dirname(proposedPath), { recursive: true });
     fs13.writeFileSync(proposedPath, file.content);
-    const originalPath = path12.join(projectDir, file.path);
     if (fs13.existsSync(originalPath)) {
       const currentPath = path12.join(CURRENT_DIR, file.path);
       fs13.mkdirSync(path12.dirname(currentPath), { recursive: true });
@@ -2194,7 +2203,7 @@ function openDiffsInEditor(editor, files) {
   }
 }
 
-// src/commands/init.ts
+// src/commands/onboard.ts
 import { createTwoFilesPatch } from "diff";
 
 // src/lib/hooks.ts
@@ -2715,15 +2724,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path23) {
+function readFileOrNull(path24) {
   try {
-    return readFileSync(path23, "utf-8");
+    return readFileSync(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path23) {
-  const content = readFileOrNull(path23);
+function readJsonOrNull(path24) {
+  const content = readFileOrNull(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3079,9 +3088,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path23) {
+function readFileOrNull2(path24) {
   try {
-    return readFileSync3(path23, "utf-8");
+    return readFileSync3(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3232,15 +3241,15 @@ function checkQuality(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import { join as join4 } from "path";
-function readFileOrNull3(path23) {
+function readFileOrNull3(path24) {
   try {
-    return readFileSync4(path23, "utf-8");
+    return readFileSync4(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path23) {
-  const content = readFileOrNull3(path23);
+function readJsonOrNull2(path24) {
+  const content = readFileOrNull3(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3423,9 +3432,9 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-function readFileOrNull4(path23) {
+function readFileOrNull4(path24) {
   try {
-    return readFileSync5(path23, "utf-8");
+    return readFileSync5(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3535,9 +3544,9 @@ function checkFreshness(dir) {
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
 import { execSync as execSync7 } from "child_process";
 import { join as join6 } from "path";
-function readFileOrNull5(path23) {
+function readFileOrNull5(path24) {
   try {
-    return readFileSync6(path23, "utf-8");
+    return readFileSync6(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3630,6 +3639,29 @@ function checkBonus(dir) {
   return checks;
 }
 
+// src/scoring/dismissed.ts
+init_constants();
+import fs17 from "fs";
+import path16 from "path";
+var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+function readDismissedChecks() {
+  try {
+    if (!fs17.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs17.readFileSync(DISMISSED_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeDismissedChecks(checks) {
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  }
+  fs17.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+}
+function getDismissedIds() {
+  return new Set(readDismissedChecks().map((c) => c.id));
+}
+
 // src/scoring/index.ts
 function sumCategory(checks, category) {
   const categoryChecks = checks.filter((c) => c.category === category);
@@ -3666,7 +3698,8 @@ function computeLocalScore(dir, targetAgent) {
     ...checkFreshness(dir),
     ...checkBonus(dir)
   ];
-  const checks = filterChecksForTarget(allChecks, target);
+  const dismissed = getDismissedIds();
+  const checks = filterChecksForTarget(allChecks, target).filter((c) => !dismissed.has(c.id));
   const maxPossible = checks.reduce((s, c) => s + c.maxPoints, 0);
   const earned = checks.reduce((s, c) => s + c.earnedPoints, 0);
   const score = maxPossible > 0 ? Math.min(100, Math.max(0, Math.round(earned / maxPossible * 100))) : 0;
@@ -3772,7 +3805,7 @@ function displayScoreSummary(result) {
     const remaining = failing.length - shown.length;
     const moreText = remaining > 0 ? ` (+${remaining} more)` : "";
     console.log(chalk3.dim(`
-  Run ${chalk3.reset("caliber score")} for details.${moreText}`));
+  Run ${chalk3.hex("#83D1EB")("caliber score")} for details.${moreText}`));
   }
   console.log("");
 }
@@ -3820,7 +3853,7 @@ function displayScoreDelta(before, after) {
   }
 }
 
-// src/commands/init.ts
+// src/commands/onboard.ts
 async function initCommand(options) {
   const brand = chalk4.hex("#EB9D83");
   const title = chalk4.hex("#83D1EB");
@@ -3832,18 +3865,16 @@ async function initCommand(options) {
   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
   `));
-  console.log(chalk4.dim("  Configure your coding agent environment\n"));
-  console.log(title.bold("  What is Caliber?\n"));
-  console.log(chalk4.dim("  Caliber audits your AI agent configurations and suggests targeted"));
-  console.log(chalk4.dim("  improvements. It analyzes CLAUDE.md, .cursorrules, and skills"));
-  console.log(chalk4.dim("  against your actual codebase \u2014 keeping what works, fixing"));
-  console.log(chalk4.dim("  what's stale, and adding what's missing.\n"));
-  console.log(title.bold("  How it works:\n"));
-  console.log(chalk4.dim("  1. Scan      Analyze your code, dependencies, and existing configs"));
-  console.log(chalk4.dim("  2. Generate  AI creates or improves config files for your project"));
-  console.log(chalk4.dim("  3. Review    You accept, refine, or decline the proposed changes"));
-  console.log(chalk4.dim("  4. Apply     Config files are written with backups\n"));
-  console.log(title.bold("  Step 1/4 \u2014 How do you want to use Caliber?\n"));
+  console.log(chalk4.dim("  Onboard your project for AI-assisted development\n"));
+  console.log(title.bold("  Welcome to Caliber\n"));
+  console.log(chalk4.dim("  Caliber analyzes your codebase and creates tailored config files"));
+  console.log(chalk4.dim("  so your AI coding agents understand your project from day one.\n"));
+  console.log(title.bold("  How onboarding works:\n"));
+  console.log(chalk4.dim("  1. Connect   Set up your LLM provider"));
+  console.log(chalk4.dim("  2. Discover  Analyze your code, dependencies, and structure"));
+  console.log(chalk4.dim("  3. Generate  Create config files tailored to your project"));
+  console.log(chalk4.dim("  4. Review    Preview, refine, and apply the changes\n"));
+  console.log(title.bold("  Step 1/4 \u2014 Connect your LLM\n"));
   let config = loadConfig();
   if (!config) {
     console.log(chalk4.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
@@ -3860,14 +3891,14 @@ async function initCommand(options) {
       console.log(chalk4.red("  Setup was cancelled or failed.\n"));
       throw new Error("__exit__");
     }
-    console.log(chalk4.green("  \u2713 Provider saved. Continuing with init.\n"));
+    console.log(chalk4.green("  \u2713 Provider saved. Let's continue.\n"));
   }
   const displayModel = config.model === "default" && config.provider === "claude-cli" ? process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)" : config.model;
   const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
   const modelLine = fastModel ? `  Provider: ${config.provider} | Model: ${displayModel} | Scan: ${fastModel}` : `  Provider: ${config.provider} | Model: ${displayModel}`;
   console.log(chalk4.dim(modelLine + "\n"));
-  console.log(title.bold("  Step 2/4 \u2014 Scan project\n"));
-  console.log(chalk4.dim("  Detecting languages, dependencies, file structure, and existing configs.\n"));
+  console.log(title.bold("  Step 2/4 \u2014 Discover your project\n"));
+  console.log(chalk4.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
   const spinner = ora("Analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   await enrichFingerprintWithLLM(fingerprint, process.cwd());
@@ -3876,12 +3907,23 @@ async function initCommand(options) {
   console.log(chalk4.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   const targetAgent = options.agent || await promptAgent();
+  const preScore = computeLocalScore(process.cwd(), targetAgent);
+  const failingForDismissal = preScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+  if (failingForDismissal.length > 0) {
+    const newDismissals = await evaluateDismissals(failingForDismissal, fingerprint);
+    if (newDismissals.length > 0) {
+      const existing = readDismissedChecks();
+      const existingIds = new Set(existing.map((d) => d.id));
+      const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
+      writeDismissedChecks(merged);
+    }
+  }
   const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreSummary(baselineScore);
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
   if (hasExistingConfig && baselineScore.score === 100) {
     console.log(chalk4.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk4.dim("  Run `caliber init --force` to regenerate anyway.\n"));
+    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const isEmpty = fingerprint.fileTree.length < 3;
@@ -3896,8 +3938,8 @@ async function initCommand(options) {
     passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
     currentScore = baselineScore.score;
     if (failingChecks.length > 0) {
-      console.log(title.bold("  Step 3/4 \u2014 Targeted fixes\n"));
-      console.log(chalk4.dim(`  Score is ${baselineScore.score}/100 \u2014 only fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
+      console.log(title.bold("  Step 3/4 \u2014 Fine-tuning\n"));
+      console.log(chalk4.dim(`  Your setup scores ${baselineScore.score}/100 \u2014 fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
 `));
       for (const check of failingChecks) {
         console.log(chalk4.dim(`    \u2022 ${check.name}`));
@@ -3905,12 +3947,12 @@ async function initCommand(options) {
       console.log("");
     }
   } else if (hasExistingConfig) {
-    console.log(title.bold("  Step 3/4 \u2014 Auditing your configs\n"));
-    console.log(chalk4.dim("  AI is reviewing your existing configs against your codebase"));
-    console.log(chalk4.dim("  and suggesting improvements.\n"));
+    console.log(title.bold("  Step 3/4 \u2014 Improve your setup\n"));
+    console.log(chalk4.dim("  Reviewing your existing configs against your codebase"));
+    console.log(chalk4.dim("  and preparing improvements.\n"));
   } else {
-    console.log(title.bold("  Step 3/4 \u2014 Generating configs\n"));
-    console.log(chalk4.dim("  AI is creating agent config files tailored to your project.\n"));
+    console.log(title.bold("  Step 3/4 \u2014 Build your agent setup\n"));
+    console.log(chalk4.dim("  Creating config files tailored to your project.\n"));
   }
   console.log(chalk4.dim("  This can take a couple of minutes depending on your model and provider.\n"));
   const genStartTime = Date.now();
@@ -3970,7 +4012,7 @@ async function initCommand(options) {
     role: "assistant",
     content: summarizeSetup("Initial generation", generatedSetup)
   });
-  console.log(title.bold("  Step 4/4 \u2014 Review\n"));
+  console.log(title.bold("  Step 4/4 \u2014 Review and apply\n"));
   const setupFiles = collectSetupFiles(generatedSetup);
   const staged = stageFiles(setupFiles, process.cwd());
   console.log(chalk4.dim(`  ${chalk4.green(`${staged.newFiles} new`)} / ${chalk4.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
@@ -4029,11 +4071,6 @@ async function initCommand(options) {
     console.error(chalk4.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
-  if (!fs17.existsSync("AGENTS.md")) {
-    const agentsContent = "# AGENTS.md\n\nThis project uses AI coding agents. See CLAUDE.md for Claude Code configuration and .cursor/rules/ for Cursor rules.\n";
-    fs17.writeFileSync("AGENTS.md", agentsContent);
-    console.log(`  ${chalk4.green("\u2713")} AGENTS.md`);
-  }
   ensurePermissions();
   const sha = getCurrentHeadSha();
   writeState({
@@ -4041,19 +4078,22 @@ async function initCommand(options) {
     lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     targetAgent
   });
+  console.log("");
+  console.log(title.bold("  Keep your configs fresh\n"));
+  console.log(chalk4.dim("  Caliber can automatically update your agent configs when your code changes.\n"));
   const hookChoice = await promptHookType(targetAgent);
   if (hookChoice === "claude" || hookChoice === "both") {
     const hookResult = installHook();
     if (hookResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-      console.log(chalk4.dim("    Run `caliber hooks remove` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove") + chalk4.dim(" to disable"));
     } else if (hookResult.alreadyInstalled) {
       console.log(chalk4.dim("  Claude Code hook already installed"));
     }
     const learnResult = installLearningHooks();
     if (learnResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
-      console.log(chalk4.dim("    Run `caliber learn remove` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber learn remove") + chalk4.dim(" to disable"));
     } else if (learnResult.alreadyInstalled) {
       console.log(chalk4.dim("  Learning hooks already installed"));
     }
@@ -4062,7 +4102,7 @@ async function initCommand(options) {
     const precommitResult = installPreCommitHook();
     if (precommitResult.installed) {
       console.log(`  ${chalk4.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk4.dim("    Run `caliber hooks remove-precommit` to disable"));
+      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove-precommit") + chalk4.dim(" to disable"));
     } else if (precommitResult.alreadyInstalled) {
       console.log(chalk4.dim("  Pre-commit hook already installed"));
     } else {
@@ -4070,7 +4110,7 @@ async function initCommand(options) {
     }
   }
   if (hookChoice === "skip") {
-    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run `caliber hooks install` later to enable."));
+    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run ") + chalk4.hex("#83D1EB")("caliber hooks install") + chalk4.dim(" later to enable."));
   }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
@@ -4083,13 +4123,15 @@ async function initCommand(options) {
       }
     } catch {
     }
-    console.log(chalk4.dim("  Run `caliber init --force` to override.\n"));
+    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
-  console.log(chalk4.bold.green("  Setup complete! Your coding agent is now configured."));
-  console.log(chalk4.dim("  Run `caliber undo` to revert changes.\n"));
+  console.log(chalk4.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
+  console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber undo") + chalk4.dim(" to revert changes.\n"));
   console.log(chalk4.bold("  Next steps:\n"));
+  console.log(`    ${title("caliber score")}        See your full config breakdown`);
+  console.log(`    ${title("caliber recommend")}    Discover community skills for your stack`);
   console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
   console.log("");
 }
@@ -4136,7 +4178,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path23, desc]) => `  ${path23}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path24, desc]) => `  ${path24}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -4157,6 +4199,36 @@ Return {"valid": true} or {"valid": false}. Nothing else.`,
     return true;
   }
 }
+async function evaluateDismissals(failingChecks, fingerprint) {
+  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const checkList = failingChecks.map((c) => ({
+    id: c.id,
+    name: c.name,
+    suggestion: c.suggestion
+  }));
+  try {
+    const result = await llmJsonCall({
+      system: `You evaluate whether scoring checks are applicable to a project.
+Given the project's languages/frameworks and a list of failing checks, return which checks are NOT applicable.
+
+Only dismiss checks that truly don't apply \u2014 e.g. "Build/test/lint commands" for a pure Terraform/HCL repo with no build system.
+Do NOT dismiss checks that could reasonably apply even if the project doesn't use them yet.
+
+Return {"dismissed": [{"id": "check_id", "reason": "brief reason"}]} or {"dismissed": []} if all apply.`,
+      prompt: `Languages: ${fingerprint.languages.join(", ") || "none"}
+Frameworks: ${fingerprint.frameworks.join(", ") || "none"}
+
+Failing checks:
+${JSON.stringify(checkList, null, 2)}`,
+      maxTokens: 200,
+      ...fastModel ? { model: fastModel } : {}
+    });
+    if (!Array.isArray(result.dismissed)) return [];
+    return result.dismissed.filter((d) => d.id && d.reason && failingChecks.some((c) => c.id === d.id)).map((d) => ({ id: d.id, reason: d.reason, dismissedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  } catch {
+    return [];
+  }
+}
 function promptInput2(question) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
@@ -4226,8 +4298,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs17.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs17.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs18.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs18.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -4410,7 +4482,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs17.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk4.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk4.dim(`    ${desc}`));
@@ -4420,7 +4492,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
         console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
@@ -4430,7 +4502,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs17.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk4.bold(".cursorrules")}`);
       if (desc) console.log(chalk4.dim(`    ${desc}`));
@@ -4440,7 +4512,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
         console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
@@ -4451,7 +4523,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs17.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk4.bold(rulePath)}`);
         if (desc) {
@@ -4464,6 +4536,11 @@ function printSetupSummary(setup) {
       }
     }
   }
+  if (!fs18.existsSync("AGENTS.md")) {
+    console.log(`  ${chalk4.green("+")} ${chalk4.bold("AGENTS.md")}`);
+    console.log(chalk4.dim("    Cross-agent coordination file"));
+    console.log("");
+  }
   if (Array.isArray(deletions) && deletions.length > 0) {
     for (const del of deletions) {
       console.log(`  ${chalk4.red("-")} ${chalk4.bold(del.filePath)}`);
@@ -4487,8 +4564,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs17.existsSync(settingsPath)) {
-      settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
+    if (fs18.existsSync(settingsPath)) {
+      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -4502,8 +4579,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs17.existsSync(".claude")) fs17.mkdirSync(".claude", { recursive: true });
-  fs17.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs18.existsSync(".claude")) fs18.mkdirSync(".claude", { recursive: true });
+  fs18.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function collectSetupFiles(setup) {
   const files = [];
@@ -4533,6 +4610,21 @@ function collectSetupFiles(setup) {
       }
     }
   }
+  if (!fs18.existsSync("AGENTS.md")) {
+    const agentRefs = [];
+    if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
+    if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
+    if (agentRefs.length === 0) agentRefs.push("See CLAUDE.md and .cursor/rules/ for agent configurations.");
+    files.push({
+      path: "AGENTS.md",
+      content: `# AGENTS.md
+
+This project uses AI coding agents configured by [Caliber](https://github.com/rely-ai-org/caliber).
+
+${agentRefs.join(" ")}
+`
+    });
+  }
   return files;
 }
 
@@ -4569,7 +4661,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk6 from "chalk";
-import fs18 from "fs";
+import fs19 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -4586,16 +4678,16 @@ async function statusCommand(options) {
   if (config) {
     console.log(`  LLM: ${chalk6.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run \`caliber config\``);
+    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run ${chalk6.hex("#83D1EB")("caliber config")}`);
   }
   if (!manifest) {
     console.log(`  Setup: ${chalk6.dim("No setup applied")}`);
-    console.log(chalk6.dim("\n  Run `caliber init` to get started.\n"));
+    console.log(chalk6.dim("\n  Run ") + chalk6.hex("#83D1EB")("caliber onboard") + chalk6.dim(" to get started.\n"));
     return;
   }
   console.log(`  Files managed: ${chalk6.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs18.existsSync(entry.path);
+    const exists = fs19.existsSync(entry.path);
     const icon = exists ? chalk6.green("\u2713") : chalk6.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -4609,12 +4701,12 @@ import confirm from "@inquirer/confirm";
 async function regenerateCommand(options) {
   const config = loadConfig();
   if (!config) {
-    console.log(chalk7.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
+    console.log(chalk7.red("No LLM provider configured. Run ") + chalk7.hex("#83D1EB")("caliber config") + chalk7.red(" (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk7.yellow("No existing setup found. Run `caliber init` first."));
+    console.log(chalk7.yellow("No existing setup found. Run ") + chalk7.hex("#83D1EB")("caliber onboard") + chalk7.yellow(" first."));
     throw new Error("__exit__");
   }
   const spinner = ora3("Re-analyzing project...").start();
@@ -4682,13 +4774,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs20 from "fs";
+import path17 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs19.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs20.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -4697,10 +4789,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs19.existsSync(skillsDir)) {
-    for (const file of fs19.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs20.existsSync(skillsDir)) {
+    for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -4710,10 +4802,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs19.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs20.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4728,8 +4820,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs19.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs20.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4738,10 +4830,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs19.existsSync(cursorRulesDir)) {
-    for (const file of fs19.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs20.existsSync(cursorRulesDir)) {
+    for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -4751,12 +4843,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs19.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs20.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs19.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs19.existsSync(skillFile)) {
+      for (const name of fs20.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs20.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4769,10 +4861,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs19.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs20.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4790,7 +4882,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs19.readFileSync(filePath, "utf-8");
+  const text = fs20.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5356,18 +5448,18 @@ async function scoreCommand(options) {
   const separator = chalk9.gray("  " + "\u2500".repeat(53));
   console.log(separator);
   if (result.score < 40) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber init") + chalk9.gray(" to generate a complete, optimized setup."));
+    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to generate a complete, optimized setup."));
   } else if (result.score < 70) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber init") + chalk9.gray(" to improve your setup."));
+    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to improve your setup."));
   } else {
-    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#f97316")("caliber update") + chalk9.gray(" to keep it fresh."));
+    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#83D1EB")("caliber update") + chalk9.gray(" to keep it fresh."));
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
-import fs21 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path19 from "path";
 import chalk10 from "chalk";
 import ora5 from "ora";
 
@@ -5444,37 +5536,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs20 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path18 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs20.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs21.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs20.writeFileSync("README.md", docs.readmeMd);
+    fs21.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs20.writeFileSync(".cursorrules", docs.cursorrules);
+    fs21.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path17.join(".cursor", "rules");
-    if (!fs20.existsSync(rulesDir)) fs20.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path18.join(".cursor", "rules");
+    if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path17.join(rulesDir, rule.filename);
-      fs20.writeFileSync(filePath, rule.content);
+      const filePath = path18.join(rulesDir, rule.filename);
+      fs21.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path17.join(".claude", "skills");
-    if (!fs20.existsSync(skillsDir)) fs20.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path18.join(".claude", "skills");
+    if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path17.join(skillsDir, skill.filename);
-      fs20.writeFileSync(filePath, skill.content);
+      const filePath = path18.join(skillsDir, skill.filename);
+      fs21.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -5549,11 +5641,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs21.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path18.join(parentDir, entry.name);
-      if (fs21.existsSync(path18.join(childPath, ".git"))) {
+      const childPath = path19.join(parentDir, entry.name);
+      if (fs22.existsSync(path19.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -5631,7 +5723,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk10.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set an API key."));
+      console.log(chalk10.red("No LLM provider configured. Run ") + chalk10.hex("#83D1EB")("caliber config") + chalk10.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     if (isGitRepo()) {
@@ -5648,7 +5740,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path18.basename(repo);
+      const repoName = path19.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -5895,8 +5987,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs22 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path20 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -5904,15 +5996,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs22.existsSync(LEARNING_DIR)) {
-    fs22.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs23.existsSync(LEARNING_DIR)) {
+    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -5923,50 +6015,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs22.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs22.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return [];
-  const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs23.existsSync(filePath)) return [];
+  const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return 0;
-  const content = fs22.readFileSync(filePath, "utf-8");
+  if (!fs23.existsSync(filePath)) return 0;
+  const content = fs23.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs22.existsSync(filePath)) fs22.unlinkSync(filePath);
+  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs22.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs22.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs24 from "fs";
+import path21 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -5986,8 +6078,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs23.existsSync(claudeMdPath)) {
-    existing = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (fs24.existsSync(claudeMdPath)) {
+    existing = fs24.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6001,15 +6093,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs23.writeFileSync(claudeMdPath, updated);
+  fs24.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path20.join(".claude", "skills", skill.name);
-  if (!fs23.existsSync(skillDir)) fs23.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path20.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs23.existsSync(skillPath)) {
-    const existing = fs23.readFileSync(skillPath, "utf-8");
-    fs23.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path21.join(".claude", "skills", skill.name);
+  if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs24.existsSync(skillPath)) {
+    const existing = fs24.readFileSync(skillPath, "utf-8");
+    fs24.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -6018,14 +6110,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs23.writeFileSync(skillPath, frontmatter + skill.content);
+    fs24.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs23.existsSync(claudeMdPath)) return null;
-  const content = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (!fs24.existsSync(claudeMdPath)) return null;
+  const content = fs24.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6209,14 +6301,14 @@ Learned items in CLAUDE.md: ${chalk13.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var __dirname = path22.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs24.readFileSync(path21.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs25.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
 program.name(process.env.CALIBER_LOCAL ? "caloc" : "caliber").description("Configure your coding agent environment").version(displayVersion);
-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("onboard").alias("init").description("Onboard your project for AI-assisted development").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("regenerate").alias("regen").alias("re").alias("update").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(regenerateCommand);
@@ -6233,22 +6325,22 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs25 from "fs";
-import path22 from "path";
+import fs26 from "fs";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
 import chalk14 from "chalk";
 import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs25.readFileSync(path22.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync9("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }

package/package.json

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