@rely-ai/caliber 1.21.0 → 1.22.0-dev.1773744838

package/README.md

@@ -32,26 +32,25 @@ No API key required — works with your existing **Claude Code** or **Cursor** s
 | New team members start with no AI context | `caliber init` gives any contributor a complete setup in seconds |
 | Configs diverge across AI tools | Cross-platform parity — Claude, Cursor, and Codex stay consistent |
 | No idea if your config is actually helping | Score your setup (A–F grade) and see exactly what to improve |
+| AI keeps making the same mistakes | Session learning captures patterns and corrections automatically |
 
 ## ⚙️ How It Works
 
 ```
 caliber init
 │
-├─ 1. 🔌 Connect      Choose your LLM provider — Claude Code seat, Cursor seat,
+├─ 1. 🔌 Setup        Choose your LLM provider — Claude Code seat, Cursor seat,
 │                      or an API key (Anthropic, OpenAI, Vertex AI)
 │
-├─ 2. 🔍 Discover     Fingerprint your project: languages, frameworks, dependencies,
-│                      file structure, and existing agent configs
+├─ 2. 🛠️  Engine       Fingerprint your project, generate configs in parallel,
+│                      search community skills, and auto-refine against
+│                      deterministic scoring checks (up to 2 iterations)
 │
-├─ 3. 🛠️  Generate     Build optimized configs with parallel LLM calls
-│                      (heavy model for docs, fast model for skills)
-│
-├─ 4. 👀 Review       See a diff of every proposed change — accept, refine
+├─ 3. 👀 Review       See a diff of every proposed change — accept, refine
 │                      via chat, or decline. All originals are backed up
 │
-└─ 5. 🧩 Skills       Search community registries and install relevant
-                       skills for your tech stack
+└─ 4. ✅ Finalize     Write files, install auto-refresh hooks, and set up
+                       session learning for continuous improvement
 ```
 
 Already have a setup? If your existing config scores **95+**, Caliber skips full regeneration and applies targeted fixes to the specific checks that are failing.
@@ -60,6 +59,7 @@ Already have a setup? If your existing config scores **95+**, Caliber skips full
 
 **Claude Code**
 - `CLAUDE.md` — Project context, build/test commands, architecture, conventions
+- `CALIBER_LEARNINGS.md` — Patterns learned from your AI coding sessions
 - `.claude/skills/*/SKILL.md` — Reusable skills ([OpenSkills](https://agentskills.io) format)
 - `.mcp.json` — Auto-discovered MCP server configurations
 - `.claude/settings.json` — Permissions and hooks
@@ -126,17 +126,31 @@ Every failing check includes structured fix data — when `caliber init` runs, t
 
 </details>
 
+### 🧠 Session Learning
+Caliber watches your AI coding sessions and learns from them. Hooks capture tool usage, failures, and your corrections — then an LLM distills operational patterns into `CALIBER_LEARNINGS.md`.
+
+```bash
+caliber learn install      # Install hooks for Claude Code and Cursor
+caliber learn status       # View hook status, event count, and ROI summary
+caliber learn finalize     # Manually trigger analysis (auto-runs on session end)
+caliber learn remove       # Remove hooks
+```
+
+Learned items are categorized by type — **[correction]**, **[gotcha]**, **[fix]**, **[pattern]**, **[env]**, **[convention]** — and automatically deduplicated. ROI tracking shows how much time and tokens the learnings save across sessions.
+
 ### 🔄 Auto-Refresh
 Keep configs in sync with your codebase automatically:
 
 | Hook | Trigger | What it does |
 |---|---|---|
-| **Claude Code** | End of each session | Runs `caliber refresh` and updates docs |
 | **Git pre-commit** | Before each commit | Refreshes docs and stages updated files |
+| **Claude Code session end** | End of each session | Runs `caliber refresh` and updates docs |
+| **Learning hooks** | During each session | Captures events for session learning |
 
 ```bash
-caliber hooks --install    # Enable all hooks
-caliber hooks --remove     # Disable all hooks
+caliber hooks --install    # Enable refresh hooks
+caliber hooks --remove     # Disable refresh hooks
+caliber learn install      # Enable learning hooks
 ```
 
 The `refresh` command analyzes your git diff (committed, staged, and unstaged changes) and updates config files to reflect what changed. Works across multiple repos when run from a parent directory.
@@ -152,11 +166,12 @@ Every change Caliber makes can be undone:
 
 | Command | Description |
 |---|---|
-| `caliber init` | Full setup wizard — analyze, generate, review, install skills |
+| `caliber init` | Full setup wizard — analyze, generate, review, install hooks |
 | `caliber score` | Score config quality (deterministic, no LLM) |
 | `caliber regenerate` | Re-analyze and regenerate configs (aliases: `regen`, `re`) |
 | `caliber refresh` | Update docs based on recent code changes |
 | `caliber skills` | Discover and install community skills |
+| `caliber learn` | Session learning — install hooks, view status, finalize analysis |
 | `caliber hooks` | Manage auto-refresh hooks |
 | `caliber config` | Configure LLM provider, API key, and model |
 | `caliber status` | Show current setup status |

package/dist/bin.js

@@ -1856,6 +1856,12 @@ Safety: Never include API keys, tokens, or credentials in config files.
 Note: Permissions, hooks, freshness tracking, and OpenSkills frontmatter are scored automatically by caliber \u2014 do not optimize for them.`;
 var OUTPUT_SIZE_CONSTRAINTS = `OUTPUT SIZE CONSTRAINTS \u2014 these are critical:
 - CLAUDE.md / AGENTS.md: MUST be under 150 lines for maximum score. Aim for 100-140 lines. Be concise \u2014 commands, architecture overview, and key conventions. Use bullet points and tables, not prose.
+
+Pack project references densely in architecture sections \u2014 use inline paths, not prose paragraphs:
+GOOD: **Entry**: \`src/bin.ts\` \u2192 \`src/cli.ts\` \xB7 **LLM** (\`src/llm/\`): \`anthropic.ts\` \xB7 \`vertex.ts\` \xB7 \`openai-compat.ts\`
+BAD: The entry point of the application is located in the src directory. The LLM module handles different providers.
+For command sections, use code blocks with one command per line.
+
 - Each skill content: max 150 lines. Focus on patterns and examples, not exhaustive docs.
 - Cursor rules: max 5 .mdc files.
 - If the project is large, prioritize depth on the 3-4 most critical tools over breadth across everything.`;
@@ -4597,6 +4603,29 @@ function countTreeLines(content) {
   }
   return count;
 }
+function calculateDuplicatePercent(content1, content2) {
+  const lines1 = new Set(content1.split("\n").map((l) => l.trim()).filter((l) => l.length > 10));
+  const lines2 = content2.split("\n").map((l) => l.trim()).filter((l) => l.length > 10);
+  const overlapping = lines2.filter((l) => lines1.has(l)).length;
+  return lines2.length > 0 ? Math.round(overlapping / lines2.length * 100) : 0;
+}
+function calculateDensityPoints(density, maxPoints) {
+  if (density >= 40) return maxPoints;
+  if (density >= 25) return Math.round(maxPoints * 0.75);
+  if (density >= 15) return Math.round(maxPoints * 0.5);
+  if (density >= 5) return Math.round(maxPoints * 0.25);
+  return 0;
+}
+function isEntryMentioned(entry, contentLower) {
+  const entryLower = entry.toLowerCase();
+  const variants = [entryLower, entryLower.replace(/\\/g, "/")];
+  const lastSegment = entry.split("/").pop()?.toLowerCase();
+  if (lastSegment && lastSegment.length > 3) variants.push(lastSegment);
+  return variants.some((v) => {
+    const escaped = v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|[\\s\`/"'\\.,(])${escaped}(?:[\\s\`/"'.,;:!?)\\\\]|$)`, "i").test(contentLower);
+  });
+}
 function classifyLine(line, inCodeBlock) {
   if (inCodeBlock) return "concrete";
   const trimmed = line.trim();
@@ -4706,15 +4735,7 @@ function checkQuality(dir) {
       instruction: "Remove directory tree listings from code blocks. Reference key directories inline instead."
     } : void 0
   });
-  let duplicatePercent = 0;
-  if (claudeMd && cursorrules) {
-    const claudeLines = new Set(
-      claudeMd.split("\n").map((l) => l.trim()).filter((l) => l.length > 10)
-    );
-    const cursorLines = cursorrules.split("\n").map((l) => l.trim()).filter((l) => l.length > 10);
-    const overlapping = cursorLines.filter((l) => claudeLines.has(l)).length;
-    duplicatePercent = cursorLines.length > 0 ? Math.round(overlapping / cursorLines.length * 100) : 0;
-  }
+  const duplicatePercent = claudeMd && cursorrules ? calculateDuplicatePercent(claudeMd, cursorrules) : 0;
   const hasDuplicates = duplicatePercent > 50;
   checks.push({
     id: "no_duplicate_content",
@@ -4764,20 +4785,7 @@ function checkGrounding(dir) {
   const mentioned = [];
   const notMentioned = [];
   for (const entry of meaningfulEntries) {
-    const entryLower = entry.toLowerCase();
-    const variants = [
-      entryLower,
-      entryLower.replace(/\\/g, "/")
-    ];
-    const lastSegment = entry.split("/").pop()?.toLowerCase();
-    if (lastSegment && lastSegment.length > 3) {
-      variants.push(lastSegment);
-    }
-    const ismentioned = variants.some((v) => {
-      const escaped = v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      return new RegExp(`(?:^|[\\s\`/"'\\.,(])${escaped}(?:[\\s\`/"'.,;:!?)\\\\]|$)`, "i").test(configLower);
-    });
-    if (ismentioned) {
+    if (isEntryMentioned(entry, configLower)) {
       mentioned.push(entry);
     } else {
       notMentioned.push(entry);
@@ -4787,12 +4795,8 @@ function checkGrounding(dir) {
   const groundingThreshold = GROUNDING_THRESHOLDS.find((t) => groundingRatio >= t.minRatio);
   const groundingPoints = meaningfulEntries.length === 0 ? 0 : groundingThreshold?.points ?? 0;
   const topDirs = projectStructure.dirs.filter((d) => !d.includes("/")).filter((d) => d.length > 2);
-  const matchesConfig = (name) => {
-    const escaped = name.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`(?:^|[\\s\`/"'\\.,(])${escaped}(?:[\\s\`/"'.,;:!?)\\\\]|$)`, "i").test(configLower);
-  };
-  const unmentionedTopDirs = topDirs.filter((d) => !matchesConfig(d));
-  const mentionedTopDirs = topDirs.filter((d) => matchesConfig(d));
+  const unmentionedTopDirs = topDirs.filter((d) => !isEntryMentioned(d, configLower));
+  const mentionedTopDirs = topDirs.filter((d) => isEntryMentioned(d, configLower));
   checks.push({
     id: "project_grounding",
     name: "Project grounding",
@@ -4817,18 +4821,7 @@ function checkGrounding(dir) {
   const mdStructure = analyzeMarkdownStructure(configContent);
   const totalSpecificRefs = refs.length + mdStructure.inlineCodeCount;
   const density = mdStructure.nonEmptyLines > 0 ? totalSpecificRefs / mdStructure.nonEmptyLines * 100 : 0;
-  let densityPoints = 0;
-  if (configContent.length === 0) {
-    densityPoints = 0;
-  } else if (density >= 40) {
-    densityPoints = POINTS_REFERENCE_DENSITY;
-  } else if (density >= 25) {
-    densityPoints = Math.round(POINTS_REFERENCE_DENSITY * 0.75);
-  } else if (density >= 15) {
-    densityPoints = Math.round(POINTS_REFERENCE_DENSITY * 0.5);
-  } else if (density >= 5) {
-    densityPoints = Math.round(POINTS_REFERENCE_DENSITY * 0.25);
-  }
+  const densityPoints = configContent.length === 0 ? 0 : calculateDensityPoints(density, POINTS_REFERENCE_DENSITY);
   checks.push({
     id: "reference_density",
     name: "Reference density",
@@ -6449,14 +6442,46 @@ var MAX_REFINE_ITERATIONS = 2;
 function extractConfigContent(setup) {
   const claude = setup.claude;
   const codex = setup.codex;
+  const cursor = setup.cursor;
+  let cursorrules = null;
+  if (typeof cursor?.cursorrules === "string" && cursor.cursorrules.length > 0) {
+    cursorrules = cursor.cursorrules;
+  }
+  const skills = [];
+  for (const [platform, obj] of [["claude", claude], ["codex", codex], ["cursor", cursor]]) {
+    const platformSkills = obj?.skills;
+    if (Array.isArray(platformSkills)) {
+      for (const skill of platformSkills) {
+        if (typeof skill.content === "string" && skill.content.length > 0) {
+          skills.push({ name: skill.name, content: skill.content, platform });
+        }
+      }
+    }
+  }
   return {
     claudeMd: claude?.claudeMd ?? null,
-    agentsMd: codex?.agentsMd ?? null
+    agentsMd: codex?.agentsMd ?? null,
+    cursorrules,
+    skills
   };
 }
-function validateSetup(setup, dir, checkExists = existsSync9) {
+function buildGroundingFixInstruction(unmentionedTopDirs, projectStructure) {
+  const dirDescriptions = unmentionedTopDirs.slice(0, 8).map((dir) => {
+    const subdirs = projectStructure.dirs.filter((d) => d.startsWith(`${dir}/`) && !d.includes("/", dir.length + 1));
+    const files = projectStructure.files.filter((f) => f.startsWith(`${dir}/`) && !f.includes("/", dir.length + 1));
+    const children = [...subdirs.slice(0, 4), ...files.slice(0, 2)];
+    const childList = children.map((c) => c.split("/").pop()).join(", ");
+    return childList ? `- \`${dir}/\` (contains: ${childList})` : `- \`${dir}/\``;
+  });
+  return [
+    "Reference these project directories with descriptions of their contents:",
+    ...dirDescriptions,
+    "Mention them naturally in architecture descriptions using dense inline references."
+  ].join("\n");
+}
+function validateSetup(setup, dir, checkExists = existsSync9, projectStructure) {
   const issues = [];
-  const { claudeMd, agentsMd } = extractConfigContent(setup);
+  const { claudeMd, agentsMd, cursorrules, skills } = extractConfigContent(setup);
   const primaryContent = [claudeMd, agentsMd].filter(Boolean).join("\n");
   if (!primaryContent) return issues;
   const refs = validateFileReferences(primaryContent, dir, checkExists);
@@ -6487,15 +6512,15 @@ function validateSetup(setup, dir, checkExists = existsSync9) {
   }
   const content = claudeMd ?? agentsMd ?? "";
   if (content) {
-    const structure = analyzeMarkdownStructure(content);
-    const blockThreshold = CODE_BLOCK_THRESHOLDS.find((t) => structure.codeBlockCount >= t.minBlocks);
+    const structure2 = analyzeMarkdownStructure(content);
+    const blockThreshold = CODE_BLOCK_THRESHOLDS.find((t) => structure2.codeBlockCount >= t.minBlocks);
     const blockPoints = blockThreshold?.points ?? 0;
     const maxBlockPoints = CODE_BLOCK_THRESHOLDS[0].points;
-    if (blockPoints < maxBlockPoints && structure.codeBlockCount < CODE_BLOCK_THRESHOLDS[0].minBlocks) {
+    if (blockPoints < maxBlockPoints && structure2.codeBlockCount < CODE_BLOCK_THRESHOLDS[0].minBlocks) {
       issues.push({
         check: "Executable content",
-        detail: `${structure.codeBlockCount} code block${structure.codeBlockCount === 1 ? "" : "s"} (need \u2265${CODE_BLOCK_THRESHOLDS[0].minBlocks} for full points)`,
-        fixInstruction: `Add ${CODE_BLOCK_THRESHOLDS[0].minBlocks - structure.codeBlockCount} more code blocks with actual project commands (build, test, lint, deploy).`,
+        detail: `${structure2.codeBlockCount} code block${structure2.codeBlockCount === 1 ? "" : "s"} (need \u2265${CODE_BLOCK_THRESHOLDS[0].minBlocks} for full points)`,
+        fixInstruction: `Add ${CODE_BLOCK_THRESHOLDS[0].minBlocks - structure2.codeBlockCount} more code blocks with actual project commands (build, test, lint, deploy).`,
         pointsLost: maxBlockPoints - blockPoints
       });
     }
@@ -6522,15 +6547,86 @@ function validateSetup(setup, dir, checkExists = existsSync9) {
         pointsLost: POINTS_NO_DIR_TREE
       });
     }
-    if (structure.h2Count < 3 || structure.listItemCount < 3) {
+    if (structure2.h2Count < 3 || structure2.listItemCount < 3) {
       const parts = [];
-      if (structure.h2Count < 3) parts.push(`add ${3 - structure.h2Count} more ## sections`);
-      if (structure.listItemCount < 3) parts.push("use bullet lists for multi-item instructions");
+      if (structure2.h2Count < 3) parts.push(`add ${3 - structure2.h2Count} more ## sections`);
+      if (structure2.listItemCount < 3) parts.push("use bullet lists for multi-item instructions");
       issues.push({
         check: "Structured with headings",
-        detail: `${structure.h2Count} sections, ${structure.listItemCount} list items`,
+        detail: `${structure2.h2Count} sections, ${structure2.listItemCount} list items`,
         fixInstruction: `Improve structure: ${parts.join(" and ")}.`,
-        pointsLost: POINTS_HAS_STRUCTURE - ((structure.h2Count >= 3 ? 1 : 0) + (structure.listItemCount >= 3 ? 1 : 0))
+        pointsLost: POINTS_HAS_STRUCTURE - ((structure2.h2Count >= 3 ? 1 : 0) + (structure2.listItemCount >= 3 ? 1 : 0))
+      });
+    }
+  }
+  const structure = projectStructure ?? collectProjectStructure(dir);
+  const allEntries = [...structure.dirs, ...structure.files].filter((e) => e.length > 2);
+  if (allEntries.length > 0) {
+    const contentLower = primaryContent.toLowerCase();
+    const mentionedEntries = allEntries.filter((e) => isEntryMentioned(e, contentLower));
+    const groundingRatio = mentionedEntries.length / allEntries.length;
+    const groundingThreshold = GROUNDING_THRESHOLDS.find((t) => groundingRatio >= t.minRatio);
+    const groundingPoints = groundingThreshold?.points ?? 0;
+    const groundingLost = POINTS_PROJECT_GROUNDING - groundingPoints;
+    if (groundingLost > 0) {
+      const topDirs = structure.dirs.filter((d) => !d.includes("/") && d.length > 2);
+      const unmentionedTopDirs = topDirs.filter((d) => !isEntryMentioned(d, contentLower));
+      if (unmentionedTopDirs.length > 0) {
+        issues.push({
+          check: "Project grounding",
+          detail: `${mentionedEntries.length}/${allEntries.length} project entries referenced (${Math.round(groundingRatio * 100)}%)`,
+          fixInstruction: buildGroundingFixInstruction(unmentionedTopDirs, structure),
+          pointsLost: groundingLost
+        });
+      }
+    }
+  }
+  const allRefs = extractReferences(primaryContent);
+  const primaryStructure = analyzeMarkdownStructure(primaryContent);
+  const totalSpecificRefs = allRefs.length + primaryStructure.inlineCodeCount;
+  const density = primaryStructure.nonEmptyLines > 0 ? totalSpecificRefs / primaryStructure.nonEmptyLines * 100 : 0;
+  const densityPoints = calculateDensityPoints(density, POINTS_REFERENCE_DENSITY);
+  const densityLost = POINTS_REFERENCE_DENSITY - densityPoints;
+  if (densityLost > 0) {
+    issues.push({
+      check: "Reference density",
+      detail: `${totalSpecificRefs} references across ${primaryStructure.nonEmptyLines} lines (${Math.round(density)}% density, need \u226540% for full points)`,
+      fixInstruction: `Add more backtick references around file paths, commands, and identifiers. Use the dense reference style: \`src/api/\` routes \xB7 \`src/models/\` data. Current density: ${Math.round(density)}%, target: \u226540%.`,
+      pointsLost: densityLost
+    });
+  }
+  if (claudeMd && cursorrules) {
+    const duplicatePercent = calculateDuplicatePercent(claudeMd, cursorrules);
+    if (duplicatePercent > 50) {
+      issues.push({
+        check: "No duplicate content",
+        detail: `${duplicatePercent}% overlap between CLAUDE.md and .cursorrules`,
+        fixInstruction: "Deduplicate content. Keep shared instructions in CLAUDE.md only. Make .cursorrules contain only Cursor-specific settings and platform differences.",
+        pointsLost: POINTS_NO_DUPLICATES
+      });
+    }
+  }
+  for (const skill of skills) {
+    const skillIssues = [];
+    const skillRefs = validateFileReferences(skill.content, dir, checkExists);
+    if (skillRefs.invalid.length > 0) {
+      skillIssues.push(`invalid refs: ${skillRefs.invalid.slice(0, 3).join(", ")}`);
+    }
+    const skillStructure = analyzeMarkdownStructure(skill.content);
+    if (skillStructure.codeBlockCount === 0 && skill.content.length > 200) {
+      skillIssues.push("no code blocks");
+    }
+    const { concrete, abstract } = countConcreteness(skill.content);
+    const total = concrete + abstract;
+    if (total > 3 && concrete / total < 0.3) {
+      skillIssues.push("low concreteness");
+    }
+    if (skillIssues.length > 0) {
+      issues.push({
+        check: `Skill quality: ${skill.name}`,
+        detail: skillIssues.join("; "),
+        fixInstruction: `Fix skill "${skill.name}": ${skillIssues.join(", ")}.${skillRefs.invalid.length > 0 ? ` Remove invalid paths: ${skillRefs.invalid.join(", ")}.` : ""} Add code blocks and specific file references.`,
+        pointsLost: 0
       });
     }
   }
@@ -6560,23 +6656,25 @@ async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
     existsCache.set(path29, result);
     return result;
   };
+  const projectStructure = collectProjectStructure(dir);
   let currentSetup = setup;
   let bestSetup = setup;
   let bestLostPoints = Infinity;
   for (let iteration = 0; iteration < MAX_REFINE_ITERATIONS; iteration++) {
-    const issues = validateSetup(currentSetup, dir, cachedExists);
+    const issues = validateSetup(currentSetup, dir, cachedExists, projectStructure);
     const lostPoints = countIssuePoints(issues);
     if (lostPoints < bestLostPoints) {
       bestSetup = currentSetup;
       bestLostPoints = lostPoints;
     }
-    if (issues.length === 0) {
+    if (lostPoints === 0) {
       if (callbacks?.onStatus) callbacks.onStatus("Setup passes all scoring checks");
       return bestSetup;
     }
+    const pointIssues = issues.filter((i) => i.pointsLost > 0);
+    const pointIssueNames = pointIssues.map((i) => i.check).join(", ");
     if (callbacks?.onStatus) {
-      const issueNames = issues.map((i) => i.check).join(", ");
-      callbacks.onStatus(`Fixing ${issues.length} scoring issue${issues.length === 1 ? "" : "s"}: ${issueNames}...`);
+      callbacks.onStatus(`Fixing ${pointIssues.length} scoring issue${pointIssues.length === 1 ? "" : "s"}: ${pointIssueNames}...`);
     }
     const refined = await applyTargetedFixes(currentSetup, issues);
     if (!refined) {
@@ -6585,15 +6683,15 @@ async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
     }
     sessionHistory.push({
       role: "user",
-      content: `Fix scoring issues: ${issues.map((i) => i.check).join(", ")}`
+      content: `Fix scoring issues: ${pointIssueNames}`
     });
     sessionHistory.push({
       role: "assistant",
-      content: `Applied scoring fixes for: ${issues.map((i) => i.check).join(", ")}`
+      content: `Applied scoring fixes for: ${pointIssueNames}`
     });
     currentSetup = refined;
   }
-  const finalIssues = validateSetup(currentSetup, dir, cachedExists);
+  const finalIssues = validateSetup(currentSetup, dir, cachedExists, projectStructure);
   const finalLostPoints = countIssuePoints(finalIssues);
   if (finalLostPoints < bestLostPoints) {
     bestSetup = currentSetup;
@@ -6601,10 +6699,19 @@ async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   return bestSetup;
 }
 async function applyTargetedFixes(setup, issues) {
-  const { claudeMd, agentsMd } = extractConfigContent(setup);
+  const { claudeMd, agentsMd, cursorrules, skills } = extractConfigContent(setup);
   const targets = [];
   if (claudeMd) targets.push({ key: "claudeMd", label: "CLAUDE.md", content: claudeMd });
   if (agentsMd) targets.push({ key: "agentsMd", label: "AGENTS.md", content: agentsMd });
+  const failingChecks = new Set(issues.map((i) => i.check));
+  if (cursorrules && failingChecks.has("No duplicate content")) {
+    targets.push({ key: "cursorrules", label: ".cursorrules", content: cursorrules });
+  }
+  for (const skill of skills) {
+    if (failingChecks.has(`Skill quality: ${skill.name}`)) {
+      targets.push({ key: `skill:${skill.name}`, label: `Skill: ${skill.name}`, content: skill.content });
+    }
+  }
   if (targets.length === 0) return null;
   const feedbackMessage = buildFeedbackMessage(issues);
   const contentBlock = targets.map(
@@ -6621,11 +6728,12 @@ ${t.content}
     `
 Return ONLY the fixed content as a JSON object with keys ${targets.map((t) => `"${t.key}"`).join(", ")}. Each value is the fixed markdown string. No code fences, no explanations.`
   ].join("\n");
+  const maxTokens = Math.min(12e3, 4e3 + targets.length * 2e3);
   try {
     const raw = await llmCall({
-      system: "You fix scoring issues in AI agent configuration files. Return only a JSON object with the fixed content \u2014 no explanations, no code fences.",
+      system: "You fix scoring issues in AI agent configuration files. You may receive CLAUDE.md, AGENTS.md, .cursorrules, and/or skill files. Return only a JSON object with the fixed content \u2014 no explanations, no code fences.",
       prompt,
-      maxTokens: 8e3
+      maxTokens
     });
     const cleaned = stripMarkdownFences(raw);
     const jsonStart = cleaned.indexOf("{");
@@ -6633,9 +6741,28 @@ Return ONLY the fixed content as a JSON object with keys ${targets.map((t) => `"
     const fixes = JSON.parse(jsonToParse);
     const patched = structuredClone(setup);
     for (const target of targets) {
-      if (typeof fixes[target.key] === "string" && fixes[target.key].length > 50) {
-        const parent = target.key === "claudeMd" ? patched.claude : patched.codex;
-        if (parent) parent[target.key] = fixes[target.key];
+      const fixedValue = fixes[target.key];
+      if (typeof fixedValue !== "string" || fixedValue.length < 50) continue;
+      if (target.key === "claudeMd") {
+        const parent = patched.claude;
+        if (parent) parent.claudeMd = fixedValue;
+      } else if (target.key === "agentsMd") {
+        const parent = patched.codex;
+        if (parent) parent.agentsMd = fixedValue;
+      } else if (target.key === "cursorrules") {
+        const parent = patched.cursor;
+        if (parent) parent.cursorrules = fixedValue;
+      } else if (target.key.startsWith("skill:")) {
+        const skillName = target.key.slice(6);
+        for (const platform of ["claude", "cursor", "codex"]) {
+          const platformObj = patched[platform];
+          const platformSkills = platformObj?.skills;
+          const skill = platformSkills?.find((s) => s.name === skillName);
+          if (skill) {
+            skill.content = fixedValue;
+            break;
+          }
+        }
       }
     }
     return patched;

package/package.json

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