@rely-ai/caliber 1.24.1-dev.1773872765 → 1.25.0-dev.1773915517

package/dist/bin.js

@@ -20,6 +20,41 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  AUTH_DIR: () => AUTH_DIR,
+  BACKUPS_DIR: () => BACKUPS_DIR,
+  CALIBER_DIR: () => CALIBER_DIR,
+  LEARNING_DIR: () => LEARNING_DIR,
+  LEARNING_MAX_EVENTS: () => LEARNING_MAX_EVENTS,
+  LEARNING_ROI_FILE: () => LEARNING_ROI_FILE,
+  LEARNING_SESSION_FILE: () => LEARNING_SESSION_FILE,
+  LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
+  MANIFEST_FILE: () => MANIFEST_FILE,
+  MIN_SESSIONS_FOR_COMPARISON: () => MIN_SESSIONS_FOR_COMPARISON,
+  PERSONAL_LEARNINGS_FILE: () => PERSONAL_LEARNINGS_FILE
+});
+import path2 from "path";
+import os from "os";
+var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS, LEARNING_ROI_FILE, PERSONAL_LEARNINGS_FILE, MIN_SESSIONS_FOR_COMPARISON;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    AUTH_DIR = path2.join(os.homedir(), ".caliber");
+    CALIBER_DIR = ".caliber";
+    MANIFEST_FILE = path2.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path2.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path2.join(CALIBER_DIR, "learning");
+    LEARNING_SESSION_FILE = "current-session.jsonl";
+    LEARNING_STATE_FILE = "state.json";
+    LEARNING_MAX_EVENTS = 500;
+    LEARNING_ROI_FILE = "roi-stats.json";
+    PERSONAL_LEARNINGS_FILE = path2.join(AUTH_DIR, "personal-learnings.md");
+    MIN_SESSIONS_FOR_COMPARISON = 3;
+  }
+});
+
 // src/llm/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -36,8 +71,8 @@ __export(config_exports, {
   writeConfigFile: () => writeConfigFile
 });
 import fs4 from "fs";
-import path4 from "path";
-import os from "os";
+import path5 from "path";
+import os2 from "os";
 function getMaxPromptTokens() {
   const config = loadConfig();
   const model = process.env.CALIBER_MODEL || config?.model;
@@ -136,8 +171,8 @@ var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONT
 var init_config = __esm({
   "src/llm/config.ts"() {
     "use strict";
-    CONFIG_DIR = path4.join(os.homedir(), ".caliber");
-    CONFIG_FILE = path4.join(CONFIG_DIR, "config.json");
+    CONFIG_DIR = path5.join(os2.homedir(), ".caliber");
+    CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
     DEFAULT_MODELS = {
       anthropic: "claude-sonnet-4-6",
       vertex: "claude-sonnet-4-6",
@@ -185,44 +220,13 @@ var init_types = __esm({
   }
 });
 
-// src/constants.ts
-var constants_exports = {};
-__export(constants_exports, {
-  AUTH_DIR: () => AUTH_DIR,
-  BACKUPS_DIR: () => BACKUPS_DIR,
-  CALIBER_DIR: () => CALIBER_DIR,
-  LEARNING_DIR: () => LEARNING_DIR,
-  LEARNING_MAX_EVENTS: () => LEARNING_MAX_EVENTS,
-  LEARNING_ROI_FILE: () => LEARNING_ROI_FILE,
-  LEARNING_SESSION_FILE: () => LEARNING_SESSION_FILE,
-  LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
-  MANIFEST_FILE: () => MANIFEST_FILE
-});
-import path10 from "path";
-import os3 from "os";
-var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS, LEARNING_ROI_FILE;
-var init_constants = __esm({
-  "src/constants.ts"() {
-    "use strict";
-    AUTH_DIR = path10.join(os3.homedir(), ".caliber");
-    CALIBER_DIR = ".caliber";
-    MANIFEST_FILE = path10.join(CALIBER_DIR, "manifest.json");
-    BACKUPS_DIR = path10.join(CALIBER_DIR, "backups");
-    LEARNING_DIR = path10.join(CALIBER_DIR, "learning");
-    LEARNING_SESSION_FILE = "current-session.jsonl";
-    LEARNING_STATE_FILE = "state.json";
-    LEARNING_MAX_EVENTS = 500;
-    LEARNING_ROI_FILE = "roi-stats.json";
-  }
-});
-
 // src/lib/resolve-caliber.ts
 var resolve_caliber_exports = {};
 __export(resolve_caliber_exports, {
   isCaliberCommand: () => isCaliberCommand,
   resolveCaliber: () => resolveCaliber
 });
-import fs16 from "fs";
+import fs18 from "fs";
 import { execSync as execSync6 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
@@ -244,7 +248,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs16.existsSync(binPath)) {
+  if (binPath && fs18.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -268,13 +272,13 @@ var init_resolve_caliber = __esm({
 
 // src/utils/editor.ts
 import { execSync as execSync13, spawn as spawn3 } from "child_process";
-import fs24 from "fs";
-import path20 from "path";
+import fs26 from "fs";
+import path22 from "path";
 import os5 from "os";
 function getEmptyFilePath(proposedPath) {
-  fs24.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path20.join(DIFF_TEMP_DIR, path20.basename(proposedPath));
-  fs24.writeFileSync(tempPath, "");
+  fs26.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path22.join(DIFF_TEMP_DIR, path22.basename(proposedPath));
+  fs26.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
@@ -314,7 +318,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path20.join(os5.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path22.join(os5.tmpdir(), "caliber-diff");
   }
 });
 
@@ -326,7 +330,7 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs25 from "fs";
+import fs27 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
@@ -363,8 +367,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs25.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs25.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs27.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs27.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -539,13 +543,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs34 from "fs";
-import path26 from "path";
+import fs36 from "fs";
+import path28 from "path";
 import os7 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs34.existsSync(LOCK_FILE)) return false;
-    const raw = fs34.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs36.existsSync(LOCK_FILE)) return false;
+    const raw = fs36.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -560,13 +564,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs34.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs36.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs34.existsSync(LOCK_FILE)) fs34.unlinkSync(LOCK_FILE);
+    if (fs36.existsSync(LOCK_FILE)) fs36.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -574,25 +578,25 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path26.join(os7.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path28.join(os7.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs41 from "fs";
-import path31 from "path";
+import fs45 from "fs";
+import path35 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path22 from "path";
+import path24 from "path";
 import chalk14 from "chalk";
-import fs29 from "fs";
+import fs31 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
-import path6 from "path";
+import path7 from "path";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -607,10 +611,14 @@ function isInsideGitRepo() {
     dir = parent;
   }
 }
-function getGitRemoteUrl() {
-  if (!isInsideGitRepo()) return void 0;
+function getGitRemoteUrl(cwd) {
+  if (!cwd && !isInsideGitRepo()) return void 0;
   try {
-    return execSync("git remote get-url origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      ...cwd ? { cwd, timeout: 3e3 } : {}
+    }).trim();
   } catch {
     return void 0;
   }
@@ -696,37 +704,38 @@ function scan(base, rel, depth, maxDepth, result) {
 }
 
 // src/fingerprint/existing-config.ts
+init_constants();
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 function readExistingConfigs(dir) {
   const configs = {};
-  const readmeMdPath = path2.join(dir, "README.md");
+  const readmeMdPath = path3.join(dir, "README.md");
   if (fs2.existsSync(readmeMdPath)) {
     configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
   }
-  const agentsMdPath = path2.join(dir, "AGENTS.md");
+  const agentsMdPath = path3.join(dir, "AGENTS.md");
   if (fs2.existsSync(agentsMdPath)) {
     configs.agentsMd = fs2.readFileSync(agentsMdPath, "utf-8");
   }
-  const claudeMdPath = path2.join(dir, "CLAUDE.md");
+  const claudeMdPath = path3.join(dir, "CLAUDE.md");
   if (fs2.existsSync(claudeMdPath)) {
     configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path2.join(dir, ".claude", "settings.json");
+  const claudeSettingsPath = path3.join(dir, ".claude", "settings.json");
   if (fs2.existsSync(claudeSettingsPath)) {
     try {
       configs.claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path2.join(dir, ".claude", "skills");
+  const skillsDir = path3.join(dir, ".claude", "skills");
   if (fs2.existsSync(skillsDir)) {
     try {
       const entries = fs2.readdirSync(skillsDir);
       const skills = [];
       for (const entry of entries) {
-        const entryPath = path2.join(skillsDir, entry);
-        const skillMdPath = path2.join(entryPath, "SKILL.md");
+        const entryPath = path3.join(skillsDir, entry);
+        const skillMdPath = path3.join(entryPath, "SKILL.md");
         if (fs2.statSync(entryPath).isDirectory() && fs2.existsSync(skillMdPath)) {
           skills.push({ filename: `${entry}/SKILL.md`, content: fs2.readFileSync(skillMdPath, "utf-8") });
         } else if (entry.endsWith(".md")) {
@@ -737,36 +746,36 @@ function readExistingConfigs(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path2.join(dir, ".cursorrules");
+  const cursorrulesPath = path3.join(dir, ".cursorrules");
   if (fs2.existsSync(cursorrulesPath)) {
     configs.cursorrules = fs2.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path2.join(dir, ".cursor", "rules");
+  const cursorRulesDir = path3.join(dir, ".cursor", "rules");
   if (fs2.existsSync(cursorRulesDir)) {
     try {
       const files = fs2.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs2.readFileSync(path2.join(cursorRulesDir, f), "utf-8")
+        content: fs2.readFileSync(path3.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorSkillsDir = path2.join(dir, ".cursor", "skills");
+  const cursorSkillsDir = path3.join(dir, ".cursor", "skills");
   if (fs2.existsSync(cursorSkillsDir)) {
     try {
       const slugs = fs2.readdirSync(cursorSkillsDir).filter((f) => {
-        return fs2.statSync(path2.join(cursorSkillsDir, f)).isDirectory();
+        return fs2.statSync(path3.join(cursorSkillsDir, f)).isDirectory();
       });
-      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path2.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
+      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path3.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
         name,
         filename: "SKILL.md",
-        content: fs2.readFileSync(path2.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
+        content: fs2.readFileSync(path3.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
       }));
     } catch {
     }
   }
-  const mcpJsonPath = path2.join(dir, ".mcp.json");
+  const mcpJsonPath = path3.join(dir, ".mcp.json");
   if (fs2.existsSync(mcpJsonPath)) {
     try {
       const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
@@ -776,7 +785,7 @@ function readExistingConfigs(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path2.join(dir, ".cursor", "mcp.json");
+  const cursorMcpPath = path3.join(dir, ".cursor", "mcp.json");
   if (fs2.existsSync(cursorMcpPath)) {
     try {
       const cursorMcpJson = JSON.parse(fs2.readFileSync(cursorMcpPath, "utf-8"));
@@ -786,12 +795,20 @@ function readExistingConfigs(dir) {
     } catch {
     }
   }
+  if (fs2.existsSync(PERSONAL_LEARNINGS_FILE)) {
+    try {
+      const content = fs2.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+      const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
+      if (bullets) configs.personalLearnings = bullets;
+    } catch {
+    }
+  }
   return configs;
 }
 
 // src/fingerprint/code-analysis.ts
 import fs3 from "fs";
-import path3 from "path";
+import path4 from "path";
 import { execSync as execSync2 } from "child_process";
 var IGNORE_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -1096,18 +1113,18 @@ function extractSkeletonIndentBased(lines, ext) {
 }
 function extractImports(content, filePath) {
   const imports = [];
-  const dir = path3.dirname(filePath);
+  const dir = path4.dirname(filePath);
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     const jsMatch = trimmed.match(/(?:from|require\()\s*['"]([^'"]+)['"]/);
     if (jsMatch && jsMatch[1].startsWith(".")) {
-      imports.push(path3.normalize(path3.join(dir, jsMatch[1])));
+      imports.push(path4.normalize(path4.join(dir, jsMatch[1])));
       continue;
     }
     const pyMatch = trimmed.match(/^from\s+(\.[.\w]*)\s+import/);
     if (pyMatch) {
       const modulePath = pyMatch[1].replace(/\./g, "/");
-      imports.push(path3.normalize(path3.join(dir, modulePath)));
+      imports.push(path4.normalize(path4.join(dir, modulePath)));
       continue;
     }
     const goMatch = trimmed.match(/^\s*"([^"]+)"/);
@@ -1120,7 +1137,7 @@ function extractImports(content, filePath) {
 function buildImportCounts(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const [filePath, content] of files) {
-    const ext = path3.extname(filePath).toLowerCase();
+    const ext = path4.extname(filePath).toLowerCase();
     if (!SOURCE_EXTENSIONS.has(ext)) continue;
     const imports = extractImports(content, filePath);
     for (const imp of imports) {
@@ -1154,7 +1171,7 @@ function getGitFrequency(dir) {
 function groupByDirectory(files) {
   const groups = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path3.dirname(f.path);
+    const dir = path4.dirname(f.path);
     const group = groups.get(dir) || [];
     group.push(f);
     groups.set(dir, group);
@@ -1175,14 +1192,14 @@ function analyzeCode(dir) {
   let totalChars = 0;
   for (const relPath of allPaths) {
     try {
-      totalChars += fs3.statSync(path3.join(dir, relPath)).size;
+      totalChars += fs3.statSync(path4.join(dir, relPath)).size;
     } catch {
     }
   }
   const fileContents = /* @__PURE__ */ new Map();
   for (const relPath of allPaths) {
     try {
-      const content = fs3.readFileSync(path3.join(dir, relPath), "utf-8");
+      const content = fs3.readFileSync(path4.join(dir, relPath), "utf-8");
       if (content.split("\n").length <= 500) fileContents.set(relPath, content);
     } catch {
     }
@@ -1192,7 +1209,7 @@ function analyzeCode(dir) {
   const scored = [];
   let compressedChars = 0;
   for (const [relPath, rawContent] of fileContents) {
-    const ext = path3.extname(relPath).toLowerCase();
+    const ext = path4.extname(relPath).toLowerCase();
     const compressed = compressContent(rawContent, ext);
     const skeleton = extractSkeleton(compressed, ext);
     compressedChars += compressed.length;
@@ -1221,7 +1238,7 @@ function analyzeCode(dir) {
     }
     if (similar.length > 0) {
       dupGroups++;
-      const names = similar.map((f) => path3.basename(f.path));
+      const names = similar.map((f) => path4.basename(f.path));
       const summary = `(${similar.length} similar file${similar.length === 1 ? "" : "s"} in ${dirPath}/: ${names.join(", ")})`;
       const summarySize = summary.length + 30;
       if (includedChars + summarySize <= CHAR_BUDGET) {
@@ -1258,7 +1275,7 @@ function analyzeCode(dir) {
 }
 function walkDir(base, rel, depth, maxDepth, files) {
   if (depth > maxDepth) return;
-  const fullPath = path3.join(base, rel);
+  const fullPath = path4.join(base, rel);
   let entries;
   try {
     entries = fs3.readdirSync(fullPath, { withFileTypes: true });
@@ -1274,7 +1291,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
     } else if (entry.isFile()) {
       if (SKIP_FILES.has(entry.name)) continue;
       if (SKIP_PATTERNS.some((p) => p.test(entry.name))) continue;
-      const ext = path3.extname(entry.name).toLowerCase();
+      const ext = path4.extname(entry.name).toLowerCase();
       if (TEXT_EXTENSIONS.has(ext) || depth === 0 && !ext && !entry.name.startsWith(".")) {
         files.push(relPath);
       }
@@ -1282,7 +1299,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
   }
 }
 function filePriority(filePath) {
-  const base = path3.basename(filePath);
+  const base = path4.basename(filePath);
   const entryPoints = /* @__PURE__ */ new Set([
     "index.ts",
     "index.js",
@@ -1589,7 +1606,7 @@ var OpenAICompatProvider = class {
 
 // src/llm/cursor-acp.ts
 import { spawn, execSync as execSync3 } from "child_process";
-import os2 from "os";
+import os3 from "os";
 
 // src/llm/seat-based-errors.ts
 var ERROR_PATTERNS = [
@@ -1663,7 +1680,7 @@ var CursorAcpProvider = class {
     });
   }
   buildArgs(model, streaming) {
-    const args = ["--print", "--trust", "--workspace", os2.tmpdir()];
+    const args = ["--print", "--trust", "--workspace", os3.tmpdir()];
     if (model && model !== "auto" && model !== "default") {
       args.push("--model", model);
     }
@@ -2302,7 +2319,7 @@ async function validateModel(options) {
 init_config();
 
 // src/ai/prompts.ts
-var ROLE_AND_CONTEXT = `You are an expert auditor for coding agent configurations (Claude Code, Cursor, and Codex).
+var ROLE_AND_CONTEXT = `You are an expert auditor for coding agent configurations (Claude Code, Cursor, Codex, and GitHub Copilot).
 
 Your job depends on context:
 - If no existing configs exist \u2192 generate an initial setup from scratch.
@@ -2314,7 +2331,9 @@ var CONFIG_FILE_TYPES = `You understand these config files:
 - .agents/skills/{name}/SKILL.md: Same OpenSkills format for Codex skills (Codex scans .agents/skills/ for skills).
 - .cursor/skills/{name}/SKILL.md: Same OpenSkills format for Cursor skills.
 - .cursorrules: Coding rules for Cursor (deprecated legacy format \u2014 do NOT generate this).
-- .cursor/rules/*.mdc: Modern Cursor rules with frontmatter (description, globs, alwaysApply).`;
+- .cursor/rules/*.mdc: Modern Cursor rules with frontmatter (description, globs, alwaysApply).
+- .github/copilot-instructions.md: Always-on repository-wide instructions for GitHub Copilot \u2014 same purpose as CLAUDE.md but for Copilot. Plain markdown, no frontmatter.
+- .github/instructions/*.instructions.md: Path-specific instruction files for GitHub Copilot with YAML frontmatter containing an \`applyTo\` glob pattern (e.g. \`applyTo: "**/*.ts,**/*.tsx"\`). Only loaded when Copilot is working on matching files.`;
 var EXCLUSIONS = `Do NOT generate .claude/settings.json, .claude/settings.local.json, or mcpServers \u2014 those are managed separately.`;
 var OUTPUT_FORMAT = `Your output MUST follow this exact format (no markdown fences):
 
@@ -2356,6 +2375,7 @@ var SCORING_CRITERIA = `SCORING CRITERIA \u2014 your output is scored determinis
 Existence (25 pts):
 - CLAUDE.md exists (6 pts) \u2014 always generate for claude targets
 - AGENTS.md exists (6 pts) \u2014 always generate for codex target
+- copilot-instructions.md exists (6 pts) \u2014 always generate for github-copilot target
 - Skills configured (8 pts) \u2014 generate 3+ skills for full points
 - MCP servers referenced (3 pts) \u2014 mention detected MCP integrations in your config text
 - When cursor is targeted: Cursor rules exist (3+3 pts), cross-platform parity (2 pts)
@@ -2407,7 +2427,7 @@ ${OUTPUT_FORMAT}
 
 AgentSetup schema:
 {
-  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
+  "targetAgent": ["claude", "cursor", "codex", "github-copilot"] (array of selected agents),
   "fileDescriptions": {
     "<file-path>": "reason for this change (max 80 chars)"
   },
@@ -2425,6 +2445,10 @@ AgentSetup schema:
   "cursor": {
     "skills": [{ "name": "string (kebab-case, matches directory name)", "description": "string (what this skill does and when to use it)", "content": "string (markdown body \u2014 NO frontmatter, it will be generated from name+description)" }],
     "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
+  },
+  "copilot": {
+    "instructions": "string (markdown content for .github/copilot-instructions.md \u2014 same quality/structure as CLAUDE.md)",
+    "instructionFiles": [{ "filename": "string.instructions.md", "content": "string (with applyTo YAML frontmatter, e.g. ---\\napplyTo: \\"**/*.ts,**/*.tsx\\"\\n---\\n\\nInstructions here)" }]
   }
 }
 
@@ -2446,7 +2470,7 @@ ${OUTPUT_FORMAT}
 
 CoreSetup schema:
 {
-  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
+  "targetAgent": ["claude", "cursor", "codex", "github-copilot"] (array of selected agents),
   "fileDescriptions": {
     "<file-path>": "reason for this change (max 80 chars)"
   },
@@ -2464,6 +2488,10 @@ CoreSetup schema:
   "cursor": {
     "skillTopics": [{ "name": "string (kebab-case)", "description": "string" }],
     "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
+  },
+  "copilot": {
+    "instructions": "string (markdown content for .github/copilot-instructions.md \u2014 same quality/structure as CLAUDE.md)",
+    "instructionFiles": [{ "filename": "string.instructions.md", "content": "string (with applyTo YAML frontmatter)" }]
   }
 }
 
@@ -2515,7 +2543,7 @@ Description field formula: [What it does] + [When to use it with trigger phrases
 
 Return ONLY a JSON object:
 {"name": "string (kebab-case)", "description": "string (what + when + capabilities + negative triggers)", "content": "string (markdown body)"}`;
-var REFINE_SYSTEM_PROMPT = `You are an expert at modifying coding agent configurations (Claude Code, Cursor, and Codex).
+var REFINE_SYSTEM_PROMPT = `You are an expert at modifying coding agent configurations (Claude Code, Cursor, Codex, and GitHub Copilot).
 
 You will receive the current AgentSetup JSON and a user request describing what to change.
 
@@ -2523,7 +2551,7 @@ Apply the requested changes to the setup and return the complete updated AgentSe
 
 AgentSetup schema:
 {
-  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
+  "targetAgent": ["claude", "cursor", "codex", "github-copilot"] (array of selected agents),
   "fileDescriptions": {
     "<file-path>": "reason for this change (max 80 chars)"
   },
@@ -2541,6 +2569,10 @@ AgentSetup schema:
   "cursor": {
     "skills": [{ "name": "string (kebab-case)", "description": "string", "content": "string (markdown body, no frontmatter)" }],
     "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
+  },
+  "copilot": {
+    "instructions": "string (markdown content for .github/copilot-instructions.md)",
+    "instructionFiles": [{ "filename": "string.instructions.md", "content": "string (with applyTo YAML frontmatter)" }]
   }
 }
 
@@ -2586,7 +2618,9 @@ Return a JSON object with this exact shape:
     "readmeMd": "<updated content or null>",
     "cursorrules": "<updated content or null>",
     "cursorRules": [{"filename": "name.mdc", "content": "..."}] or null,
-    "claudeSkills": [{"filename": "name.md", "content": "..."}] or null
+    "claudeSkills": [{"filename": "name.md", "content": "..."}] or null,
+    "copilotInstructions": "<updated content or null>",
+    "copilotInstructionFiles": [{"filename": "name.instructions.md", "content": "..."}] or null
   },
   "changesSummary": "<1-2 sentence summary of what was updated and why>",
   "docsUpdated": ["CLAUDE.md", "README.md"]
@@ -2628,6 +2662,12 @@ Each bullet MUST be prefixed with an observation type in bold brackets. Valid ty
 - **[env]** \u2014 an environment or configuration requirement
 - **[convention]** \u2014 a project-specific rule or naming convention
 
+Each type can optionally include a scope suffix to indicate whether the learning is project-specific or personal to the developer:
+- **[type:project]** \u2014 specific to this codebase (DEFAULT \u2014 use when in doubt)
+- **[type:personal]** \u2014 specific to the developer's workflow or personal preferences
+
+Use :personal ONLY for user corrections that are clearly personal preferences rather than project requirements. For example, "use bun not npm" is :personal if the project's lockfile doesn't enforce it. "Always run tsc before tsup" is :project because it's about the project's build process. When in doubt, default to :project (or omit the scope entirely, which means :project).
+
 Good examples:
 - "**[correction]** Files in \`src/generated/\` are auto-generated \u2014 never edit them directly"
 - "**[correction]** Use \`pnpm\` not \`npm\` \u2014 the lockfile is pnpm-lock.yaml and npm creates conflicts"
@@ -2675,6 +2715,7 @@ Analyze the provided file tree and file extension distribution. Return a JSON ob
 - "languages": array of programming languages used, ordered by prominence in the project (most files first)
 - "frameworks": array of frameworks and key libraries detected, ordered by prominence
 - "tools": array of external tools, services, and platforms the project integrates with, ordered by prominence
+- "workspaces": array of relative paths to sub-projects, workspaces, or modules detected from workspace config files (e.g. pnpm-workspace.yaml, Cargo.toml [workspace], go.work, settings.gradle, BUILD files). Empty array if not a multi-project repo.
 
 Use the file extension distribution to determine the ordering \u2014 technologies with more files should appear first.
 
@@ -2711,7 +2752,8 @@ async function detectProjectStack(fileTree, suffixCounts) {
   return {
     languages: Array.isArray(result.languages) ? result.languages : [],
     frameworks: Array.isArray(result.frameworks) ? result.frameworks : [],
-    tools: Array.isArray(result.tools) ? result.tools : []
+    tools: Array.isArray(result.tools) ? result.tools : [],
+    workspaces: Array.isArray(result.workspaces) ? result.workspaces : []
   };
 }
 
@@ -2720,14 +2762,14 @@ init_config();
 
 // src/fingerprint/cache.ts
 import fs6 from "fs";
-import path5 from "path";
+import path6 from "path";
 import crypto from "crypto";
 import { execSync as execSync5 } from "child_process";
 var CACHE_VERSION = 1;
 var CACHE_DIR = ".caliber/cache";
 var CACHE_FILE = "fingerprint.json";
 function getCachePath(dir) {
-  return path5.join(dir, CACHE_DIR, CACHE_FILE);
+  return path6.join(dir, CACHE_DIR, CACHE_FILE);
 }
 function getGitHead(dir) {
   try {
@@ -2776,16 +2818,17 @@ function loadFingerprintCache(dir, fileTree) {
       codeAnalysis: cache.codeAnalysis,
       languages: cache.languages,
       frameworks: cache.frameworks,
-      tools: cache.tools
+      tools: cache.tools,
+      workspaces: cache.workspaces
     };
   } catch {
     return null;
   }
 }
-function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks, tools) {
+function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks, tools, workspaces) {
   const cachePath = getCachePath(dir);
   try {
-    const cacheDir = path5.dirname(cachePath);
+    const cacheDir = path6.dirname(cachePath);
     if (!fs6.existsSync(cacheDir)) {
       fs6.mkdirSync(cacheDir, { recursive: true });
     }
@@ -2796,12 +2839,24 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       codeAnalysis,
       languages,
       frameworks,
-      tools
+      tools,
+      workspaces
     };
     fs6.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
+function getDetectedWorkspaces(dir) {
+  const cachePath = getCachePath(dir);
+  try {
+    if (!fs6.existsSync(cachePath)) return [];
+    const raw = fs6.readFileSync(cachePath, "utf-8");
+    const cache = JSON.parse(raw);
+    return cache.workspaces ?? [];
+  } catch {
+    return [];
+  }
+}
 
 // src/fingerprint/index.ts
 async function collectFingerprint(dir) {
@@ -2833,20 +2888,21 @@ async function collectFingerprint(dir) {
     existingConfigs,
     codeAnalysis
   };
-  await enrichWithLLM(fingerprint);
+  const workspaces = await enrichWithLLM(fingerprint);
   saveFingerprintCache(
     dir,
     fileTree,
     codeAnalysis,
     fingerprint.languages,
     fingerprint.frameworks,
-    fingerprint.tools
+    fingerprint.tools,
+    workspaces
   );
   return fingerprint;
 }
 function readPackageName(dir) {
   try {
-    const pkgPath = path6.join(dir, "package.json");
+    const pkgPath = path7.join(dir, "package.json");
     if (!fs7.existsSync(pkgPath)) return void 0;
     const pkg3 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
@@ -2857,12 +2913,12 @@ function readPackageName(dir) {
 async function enrichWithLLM(fingerprint) {
   try {
     const config = loadConfig();
-    if (!config) return;
-    if (fingerprint.fileTree.length === 0) return;
+    if (!config) return [];
+    if (fingerprint.fileTree.length === 0) return [];
     const suffixCounts = {};
     for (const entry of fingerprint.fileTree) {
       if (entry.endsWith("/")) continue;
-      const ext = path6.extname(entry).toLowerCase();
+      const ext = path7.extname(entry).toLowerCase();
       if (ext) {
         suffixCounts[ext] = (suffixCounts[ext] || 0) + 1;
       }
@@ -2871,99 +2927,574 @@ async function enrichWithLLM(fingerprint) {
     if (result.languages?.length) fingerprint.languages = result.languages;
     if (result.frameworks?.length) fingerprint.frameworks = result.frameworks;
     if (result.tools?.length) fingerprint.tools = result.tools;
+    return result.workspaces ?? [];
   } catch {
+    return [];
   }
 }
 
-// src/ai/generate.ts
-init_config();
+// src/fingerprint/sources.ts
+import fs8 from "fs";
+import path8 from "path";
 
-// src/utils/dependencies.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-function readFileOrNull(path33) {
+// src/scoring/utils.ts
+import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
+import { join, relative } from "path";
+function readFileOrNull(filePath) {
   try {
-    return readFileSync(path33, "utf-8");
+    return readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path33) {
-  const content = readFileOrNull(path33);
-  if (!content) return null;
-  try {
-    return JSON.parse(content);
-  } catch {
-    return null;
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "env",
+  ".env",
+  "target",
+  "vendor",
+  ".cache",
+  ".parcel-cache",
+  "coverage",
+  ".nyc_output",
+  ".turbo",
+  ".caliber",
+  ".claude",
+  ".cursor",
+  ".agents",
+  ".codex"
+]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  "Thumbs.db",
+  ".gitignore",
+  ".editorconfig",
+  ".prettierrc",
+  ".prettierignore",
+  ".eslintignore",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb"
+]);
+function collectProjectStructure(dir, maxDepth = 2) {
+  const dirs = [];
+  const files = [];
+  function walk(currentDir, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const name = entry.name;
+        if (name.startsWith(".") && IGNORED_DIRS.has(name)) continue;
+        if (IGNORED_FILES.has(name)) continue;
+        const rel = relative(dir, join(currentDir, name));
+        if (entry.isDirectory()) {
+          if (IGNORED_DIRS.has(name)) continue;
+          dirs.push(rel);
+          walk(join(currentDir, name), depth + 1);
+        } else if (entry.isFile()) {
+          files.push(rel);
+        }
+      }
+    } catch {
+    }
   }
+  walk(dir, 0);
+  return { dirs, files };
 }
-function extractNpmDeps(dir) {
-  const pkg3 = readJsonOrNull(join(dir, "package.json"));
-  if (!pkg3) return [];
-  const deps = {
-    ...pkg3.dependencies,
-    ...pkg3.devDependencies
-  };
-  const trivial = /* @__PURE__ */ new Set([
-    "typescript",
-    "@types/node",
-    "tslib",
-    "ts-node",
-    "tsx",
-    "prettier",
-    "eslint",
-    "@eslint/js",
-    "rimraf",
-    "cross-env",
-    "dotenv",
-    "nodemon",
-    "husky",
-    "lint-staged",
-    "commitlint",
-    "@commitlint/cli",
-    "@commitlint/config-conventional"
-  ]);
-  const trivialPatterns = [
-    /^@rely-ai\//,
-    /^@caliber-ai\//,
-    /^eslint-/,
-    /^@eslint\//,
-    /^prettier-/,
-    /^@typescript-eslint\//
-  ];
-  return Object.keys(deps).filter((d) => !trivial.has(d) && !d.startsWith("@types/") && !trivialPatterns.some((p) => p.test(d))).slice(0, 30);
-}
-function extractPythonDeps(dir) {
-  const reqTxt = readFileOrNull(join(dir, "requirements.txt"));
-  if (reqTxt) {
-    return reqTxt.split("\n").map((l) => l.trim().split(/[=<>!~\[]/)[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 30);
+function collectPrimaryConfigContent(dir) {
+  const parts = [];
+  for (const file of ["CLAUDE.md", ".cursorrules", "AGENTS.md"]) {
+    const content = readFileOrNull(join(dir, file));
+    if (content) parts.push(content);
   }
-  const pyproject = readFileOrNull(join(dir, "pyproject.toml"));
-  if (pyproject) {
-    const depMatch = pyproject.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
-    if (depMatch) {
-      return depMatch[1].split("\n").map((l) => l.trim().replace(/["',]/g, "").split(/[=<>!~\[]/)[0].trim()).filter((l) => l.length > 0).slice(0, 30);
+  try {
+    const rulesDir = join(dir, ".cursor", "rules");
+    const mdcFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".mdc"));
+    for (const f of mdcFiles) {
+      const content = readFileOrNull(join(rulesDir, f));
+      if (content) parts.push(content);
     }
+  } catch {
   }
-  return [];
+  return parts.join("\n");
 }
-function extractGoDeps(dir) {
-  const goMod = readFileOrNull(join(dir, "go.mod"));
-  if (!goMod) return [];
-  const requireBlock = goMod.match(/require\s*\(([\s\S]*?)\)/);
-  if (!requireBlock) return [];
-  return requireBlock[1].split("\n").map((l) => l.trim().split(/\s/)[0]).filter((l) => l && !l.startsWith("//")).map((l) => l.split("/").pop() || l).slice(0, 30);
+function collectAllConfigContent(dir) {
+  const parts = [collectPrimaryConfigContent(dir)];
+  for (const skillsDir of [join(dir, ".claude", "skills"), join(dir, ".agents", "skills")]) {
+    try {
+      const entries = readdirSync(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skill = readFileOrNull(join(skillsDir, entry.name, "SKILL.md"));
+          if (skill) parts.push(skill);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          const content = readFileOrNull(join(skillsDir, entry.name));
+          if (content) parts.push(content);
+        }
+      }
+    } catch {
+    }
+  }
+  return parts.join("\n");
 }
-function extractRustDeps(dir) {
-  const cargo = readFileOrNull(join(dir, "Cargo.toml"));
-  if (!cargo) return [];
-  const depSection = cargo.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
-  if (!depSection) return [];
-  return depSection[1].split("\n").map((l) => l.trim().split(/\s*=/)[0].trim()).filter((l) => l.length > 0 && !l.startsWith("#")).slice(0, 30);
+function estimateTokens2(text) {
+  return Math.ceil(text.length / 4);
 }
-function extractAllDeps(dir) {
-  return [
-    ...extractNpmDeps(dir),
+function analyzeMarkdownStructure(content) {
+  const lines = content.split("\n");
+  let headingCount = 0;
+  let h2Count = 0;
+  let h3Count = 0;
+  let codeBlockCount = 0;
+  let codeBlockLines = 0;
+  let listItemCount = 0;
+  let inlineCodeCount = 0;
+  let inCodeBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      if (!inCodeBlock) codeBlockCount++;
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockLines++;
+      continue;
+    }
+    if (trimmed.startsWith("## ") && !trimmed.startsWith("### ")) h2Count++;
+    if (trimmed.startsWith("### ")) h3Count++;
+    if (trimmed.startsWith("#")) headingCount++;
+    if (/^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) listItemCount++;
+    const inlineMatches = trimmed.match(/`[^`]+`/g);
+    if (inlineMatches) inlineCodeCount += inlineMatches.length;
+  }
+  return {
+    headingCount,
+    h2Count,
+    h3Count,
+    codeBlockCount,
+    codeBlockLines,
+    listItemCount,
+    inlineCodeCount,
+    totalLines: lines.length,
+    nonEmptyLines: lines.filter((l) => l.trim().length > 0).length
+  };
+}
+function extractReferences(content) {
+  const refs = /* @__PURE__ */ new Set();
+  const backtickPattern = /`([^`]+)`/g;
+  let match;
+  while ((match = backtickPattern.exec(content)) !== null) {
+    const term = match[1].trim();
+    if ((term.includes("/") || /\.\w{1,5}$/.test(term)) && !term.startsWith("-") && term.length < 200) {
+      if (term.startsWith("@") && (term.match(/\//g) || []).length === 1) continue;
+      if (term.includes(" ")) continue;
+      if (/^\d+\.\d+/.test(term)) continue;
+      if (term.includes("/") && !/\.\w{1,5}$/.test(term)) {
+        if (term !== term.toLowerCase() && !/^[a-z]/.test(term)) continue;
+        const segments = term.split("/");
+        if (segments.every((s) => s.length <= 3)) continue;
+      }
+      const cleaned = term.replace(/[,;:!?)]+$/, "");
+      if (cleaned.length > 1) refs.add(cleaned);
+    }
+  }
+  const pathPattern = /(?:^|\s)((?:[a-zA-Z0-9_@.-]+\/)+[a-zA-Z0-9_.*-]+\.[a-zA-Z]{1,5})/gm;
+  while ((match = pathPattern.exec(content)) !== null) {
+    const term = match[1].trim();
+    if (term.length > 2 && term.length < 200) {
+      if (term.startsWith("@") && (term.match(/\//g) || []).length === 1) continue;
+      const cleaned = term.replace(/[,;:!?)]+$/, "");
+      if (cleaned.length > 1) refs.add(cleaned);
+    }
+  }
+  return Array.from(refs);
+}
+function validateFileReferences(content, dir, checkExists = existsSync2) {
+  const refs = extractReferences(content);
+  const valid = [];
+  const invalid = [];
+  for (const ref of refs) {
+    if (/^https?:\/\//.test(ref)) continue;
+    if (/^\d+\.\d+/.test(ref)) continue;
+    if (ref.startsWith("#") || ref.startsWith("@")) continue;
+    if (ref.includes("*") || ref.includes("..")) continue;
+    if (!ref.includes("/") && !ref.includes(".")) continue;
+    const fullPath = join(dir, ref);
+    if (checkExists(fullPath)) {
+      valid.push(ref);
+    } else {
+      const withoutTrailing = ref.replace(/\/+$/, "");
+      if (withoutTrailing !== ref && checkExists(join(dir, withoutTrailing))) {
+        valid.push(ref);
+      } else {
+        invalid.push(ref);
+      }
+    }
+  }
+  return { valid, invalid, total: valid.length + invalid.length };
+}
+function countConcreteness(content) {
+  let concrete = 0;
+  let abstract = 0;
+  let inCodeBlock = false;
+  for (const line of content.split("\n")) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    const classification = classifyLine(line, inCodeBlock);
+    if (classification === "concrete") concrete++;
+    else if (classification === "abstract") abstract++;
+  }
+  return { concrete, abstract };
+}
+function countTreeLines(content) {
+  const treeLinePattern = /[├└│─┬]/;
+  let count = 0;
+  let inCodeBlock = false;
+  for (const line of content.split("\n")) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock && treeLinePattern.test(line)) count++;
+  }
+  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();
+  if (trimmed.length === 0) return "neutral";
+  if (trimmed.startsWith("#")) return "neutral";
+  if (/`[^`]+`/.test(trimmed)) return "concrete";
+  if (/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\.[a-zA-Z]{1,5}/.test(trimmed)) return "concrete";
+  if (/[a-zA-Z0-9_]{4,}\/[a-zA-Z0-9_.-]/.test(trimmed)) return "concrete";
+  if (/\b[a-zA-Z0-9_-]+\.[a-zA-Z]{1,5}\b/.test(trimmed) && !/\b(e\.g|i\.e|vs|etc)\b/i.test(trimmed)) return "concrete";
+  return "abstract";
+}
+
+// src/fingerprint/sources.ts
+var MAX_SOURCES_IN_PROMPT = 5;
+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 content = readFileOrNull(configPath);
+  if (!content) return [];
+  try {
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed.sources)) {
+      console.warn("Warning: .caliber/sources.json is malformed (missing sources array), skipping sources");
+      return [];
+    }
+    return parsed.sources.filter(
+      (s) => s.type && (s.path || s.url)
+    );
+  } catch {
+    console.warn("Warning: .caliber/sources.json is malformed, skipping sources");
+    return [];
+  }
+}
+function writeSourcesConfig(dir, sources2) {
+  const configDir = path8.join(dir, ".caliber");
+  if (!fs8.existsSync(configDir)) {
+    fs8.mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = path8.join(configDir, "sources.json");
+  fs8.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+}
+function detectSourceType(absPath) {
+  try {
+    return fs8.statSync(absPath).isDirectory() ? "repo" : "file";
+  } catch {
+    return "file";
+  }
+}
+function isInsideDir(childPath, parentDir) {
+  const relative2 = path8.relative(parentDir, childPath);
+  return !relative2.startsWith("..") && !path8.isAbsolute(relative2);
+}
+function resolveAllSources(dir, cliSources, workspaces) {
+  const seen = /* @__PURE__ */ new Map();
+  const projectRoot = path8.resolve(dir);
+  for (const src of cliSources) {
+    const absPath = path8.resolve(dir, src);
+    if (seen.has(absPath)) continue;
+    const type = detectSourceType(absPath);
+    seen.set(absPath, {
+      absPath,
+      config: { type, path: src },
+      origin: "cli"
+    });
+  }
+  const configSources = loadSourcesConfig(dir);
+  for (const cfg of configSources) {
+    if (cfg.type === "url") continue;
+    if (!cfg.path) continue;
+    const absPath = path8.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);
+    if (seen.has(absPath)) continue;
+    if (!isInsideDir(absPath, projectRoot)) continue;
+    seen.set(absPath, {
+      absPath,
+      config: { type: "repo", path: ws, role: "workspace-sibling" },
+      origin: "workspace"
+    });
+  }
+  const valid = [];
+  for (const [absPath, resolved] of seen) {
+    let stat;
+    try {
+      stat = fs8.statSync(absPath);
+    } catch {
+      console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
+      continue;
+    }
+    if (isInsideDir(absPath, projectRoot) && resolved.origin !== "workspace") {
+      if (absPath !== projectRoot) {
+        console.warn(`Skipping ${resolved.config.path || absPath}: inside current project`);
+      }
+      continue;
+    }
+    if (resolved.config.type === "file" && !stat.isFile()) continue;
+    if (resolved.config.type === "repo" && !stat.isDirectory()) continue;
+    valid.push(resolved);
+  }
+  valid.sort((a, b) => {
+    const pA = ORIGIN_PRIORITY[a.origin] ?? 2;
+    const pB = ORIGIN_PRIORITY[b.origin] ?? 2;
+    if (pA !== pB) return pA - pB;
+    return a.absPath.length - b.absPath.length;
+  });
+  const capped = valid.slice(0, MAX_SOURCES_IN_PROMPT);
+  return capped.map((r) => collectSourceSummary(r, dir));
+}
+function collectSourceSummary(resolved, projectDir) {
+  const { config, origin, absPath } = resolved;
+  if (config.type === "file") {
+    return collectFileSummary(resolved, projectDir);
+  }
+  const summaryPath = path8.join(absPath, ".caliber", "summary.json");
+  const summaryContent = readFileOrNull(summaryPath);
+  if (summaryContent) {
+    try {
+      const published = JSON.parse(summaryContent);
+      return {
+        name: published.name || path8.basename(absPath),
+        type: "repo",
+        role: config.role || published.role || "related-repo",
+        description: config.description || published.description || "",
+        origin,
+        topLevelDirs: Array.isArray(published.topLevelDirs) ? published.topLevelDirs : void 0,
+        existingClaudeMd: typeof published.conventions === "string" ? published.conventions : void 0,
+        packageName: typeof published.name === "string" ? published.name : void 0
+      };
+    } catch {
+    }
+  }
+  return collectRepoSummary(resolved, projectDir);
+}
+function collectRepoSummary(resolved, projectDir) {
+  const { config, origin, absPath } = resolved;
+  const packageName = readPackageName(absPath);
+  let topLevelDirs;
+  let keyFiles;
+  try {
+    const entries = fs8.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 existingClaudeMd = claudeMdContent ? claudeMdContent.slice(0, SOURCE_CONTENT_LIMIT) : void 0;
+  const readmeContent = readFileOrNull(path8.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),
+    type: "repo",
+    role: config.role || "related-repo",
+    description: config.description || "",
+    origin,
+    gitRemoteUrl,
+    topLevelDirs,
+    keyFiles,
+    existingClaudeMd,
+    readmeExcerpt,
+    packageName
+  };
+}
+function collectFileSummary(resolved, projectDir) {
+  const { config, origin, absPath } = resolved;
+  const content = readFileOrNull(absPath);
+  return {
+    name: path8.basename(absPath),
+    type: "file",
+    role: config.role || "reference-doc",
+    description: config.description || content?.slice(0, 100).split("\n")[0] || "",
+    origin,
+    existingClaudeMd: content ? content.slice(0, SOURCE_CONTENT_LIMIT) : void 0
+  };
+}
+function formatSourcesForPrompt(sources2) {
+  if (sources2.length === 0) return "";
+  const parts = [
+    "\n--- Related Sources ---",
+    "This project works with these related sources. Reference them in the generated",
+    "config where relevant \u2014 mention shared conventions, cross-repo workflows, and",
+    "integration points.\n"
+  ];
+  for (const source of sources2) {
+    parts.push(`[${source.name}] (${source.role})`);
+    if (source.description) parts.push(source.description);
+    if (source.topLevelDirs?.length) {
+      parts.push(`Key dirs: ${source.topLevelDirs.join(", ")}`);
+    }
+    if (source.keyFiles?.length) {
+      parts.push(`Key files: ${source.keyFiles.join(", ")}`);
+    }
+    if (source.existingClaudeMd) {
+      parts.push(`Their CLAUDE.md:
+${source.existingClaudeMd}`);
+    } else if (source.readmeExcerpt) {
+      parts.push(`Their README:
+${source.readmeExcerpt}`);
+    }
+    parts.push("");
+  }
+  parts.push("--- End Related Sources ---");
+  return parts.join("\n");
+}
+
+// src/ai/generate.ts
+init_config();
+
+// src/utils/dependencies.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function readFileOrNull2(path37) {
+  try {
+    return readFileSync2(path37, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readJsonOrNull(path37) {
+  const content = readFileOrNull2(path37);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractNpmDeps(dir) {
+  const pkg3 = readJsonOrNull(join2(dir, "package.json"));
+  if (!pkg3) return [];
+  const deps = {
+    ...pkg3.dependencies,
+    ...pkg3.devDependencies
+  };
+  const trivial = /* @__PURE__ */ new Set([
+    "typescript",
+    "@types/node",
+    "tslib",
+    "ts-node",
+    "tsx",
+    "prettier",
+    "eslint",
+    "@eslint/js",
+    "rimraf",
+    "cross-env",
+    "dotenv",
+    "nodemon",
+    "husky",
+    "lint-staged",
+    "commitlint",
+    "@commitlint/cli",
+    "@commitlint/config-conventional"
+  ]);
+  const trivialPatterns = [
+    /^@rely-ai\//,
+    /^@caliber-ai\//,
+    /^eslint-/,
+    /^@eslint\//,
+    /^prettier-/,
+    /^@typescript-eslint\//
+  ];
+  return Object.keys(deps).filter((d) => !trivial.has(d) && !d.startsWith("@types/") && !trivialPatterns.some((p) => p.test(d))).slice(0, 30);
+}
+function extractPythonDeps(dir) {
+  const reqTxt = readFileOrNull2(join2(dir, "requirements.txt"));
+  if (reqTxt) {
+    return reqTxt.split("\n").map((l) => l.trim().split(/[=<>!~\[]/)[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 30);
+  }
+  const pyproject = readFileOrNull2(join2(dir, "pyproject.toml"));
+  if (pyproject) {
+    const depMatch = pyproject.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (depMatch) {
+      return depMatch[1].split("\n").map((l) => l.trim().replace(/["',]/g, "").split(/[=<>!~\[]/)[0].trim()).filter((l) => l.length > 0).slice(0, 30);
+    }
+  }
+  return [];
+}
+function extractGoDeps(dir) {
+  const goMod = readFileOrNull2(join2(dir, "go.mod"));
+  if (!goMod) return [];
+  const requireBlock = goMod.match(/require\s*\(([\s\S]*?)\)/);
+  if (!requireBlock) return [];
+  return requireBlock[1].split("\n").map((l) => l.trim().split(/\s/)[0]).filter((l) => l && !l.startsWith("//")).map((l) => l.split("/").pop() || l).slice(0, 30);
+}
+function extractRustDeps(dir) {
+  const cargo = readFileOrNull2(join2(dir, "Cargo.toml"));
+  if (!cargo) return [];
+  const depSection = cargo.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+  if (!depSection) return [];
+  return depSection[1].split("\n").map((l) => l.trim().split(/\s*=/)[0].trim()).filter((l) => l.length > 0 && !l.startsWith("#")).slice(0, 30);
+}
+function extractAllDeps(dir) {
+  return [
+    ...extractNpmDeps(dir),
     ...extractPythonDeps(dir),
     ...extractGoDeps(dir),
     ...extractRustDeps(dir)
@@ -3094,6 +3625,12 @@ ${fingerprint.fileTree.slice(0, 50).join("\n")}`);
     parts.push(`
 Dependencies: ${allDeps.join(", ")}`);
   }
+  if (fingerprint.sources?.length) {
+    parts.push("\nRelated Sources:");
+    for (const s of fingerprint.sources) {
+      parts.push(`- ${s.name} (${s.role}): ${s.description || "related project"}`);
+    }
+  }
   return parts.join("\n");
 }
 async function generateSkill(context, topic, model) {
@@ -3409,6 +3946,11 @@ ${truncate(skill.content, LIMITS.SKILL_CHARS)}`);
 (${existing.cursorSkills.length - LIMITS.SKILLS_MAX} more skills omitted)`);
     }
   }
+  if (existing.personalLearnings) {
+    parts.push(`
+--- Personal Learnings (developer-specific, include in generated configs) ---
+${existing.personalLearnings}`);
+  }
   const allDeps = extractAllDeps(process.cwd());
   if (allDeps.length > 0) {
     parts.push(`
@@ -3458,24 +4000,27 @@ ${f.content}
     parts.push(header);
     parts.push(codeLines.join("\n"));
   }
+  if (fingerprint.sources?.length) {
+    parts.push(formatSourcesForPrompt(fingerprint.sources));
+  }
   return parts.join("\n");
 }
 
 // src/writers/index.ts
-import fs13 from "fs";
+import fs15 from "fs";
 
 // src/writers/claude/index.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs8.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs9.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path7.join(".claude", "skills", skill.name);
-      if (!fs8.existsSync(skillDir)) fs8.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path7.join(skillDir, "SKILL.md");
+      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 frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -3483,49 +4028,49 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs8.writeFileSync(skillPath, frontmatter + skill.content);
+      fs9.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs8.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs8.readFileSync(".mcp.json", "utf-8"));
+      if (fs9.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs9.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs8.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs9.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs9.writeFileSync(".cursorrules", config.cursorrules);
+    fs10.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path8.join(".cursor", "rules");
-    if (!fs9.existsSync(rulesDir)) fs9.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path10.join(".cursor", "rules");
+    if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path8.join(rulesDir, rule.filename);
-      fs9.writeFileSync(rulePath, rule.content);
+      const rulePath = path10.join(rulesDir, rule.filename);
+      fs10.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path8.join(".cursor", "skills", skill.name);
-      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path8.join(skillDir, "SKILL.md");
+      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 frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -3533,41 +4078,41 @@ function writeCursorConfig(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) {
     const cursorDir = ".cursor";
-    if (!fs9.existsSync(cursorDir)) fs9.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path8.join(cursorDir, "mcp.json");
+    if (!fs10.existsSync(cursorDir)) fs10.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path10.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs9.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs9.readFileSync(mcpPath, "utf-8"));
+      if (fs10.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs9.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs10.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
 }
 
 // src/writers/codex/index.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs10.writeFileSync("AGENTS.md", config.agentsMd);
+  fs11.writeFileSync("AGENTS.md", config.agentsMd);
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path9.join(".agents", "skills", skill.name);
-      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path9.join(skillDir, "SKILL.md");
+      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 frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -3575,71 +4120,92 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs10.writeFileSync(skillPath, frontmatter + skill.content);
+      fs11.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   return written;
 }
 
+// src/writers/github-copilot/index.ts
+import fs12 from "fs";
+import path12 from "path";
+function writeGithubCopilotConfig(config) {
+  const written = [];
+  if (config.instructions) {
+    fs12.mkdirSync(".github", { recursive: true });
+    fs12.writeFileSync(path12.join(".github", "copilot-instructions.md"), config.instructions);
+    written.push(".github/copilot-instructions.md");
+  }
+  if (config.instructionFiles?.length) {
+    const instructionsDir = path12.join(".github", "instructions");
+    fs12.mkdirSync(instructionsDir, { recursive: true });
+    for (const file of config.instructionFiles) {
+      fs12.writeFileSync(path12.join(instructionsDir, file.filename), file.content);
+      written.push(`.github/instructions/${file.filename}`);
+    }
+  }
+  return written;
+}
+
 // src/writers/backup.ts
 init_constants();
-import fs11 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path13 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path11.join(BACKUPS_DIR, timestamp);
+  const backupDir = path13.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs11.existsSync(file)) continue;
-    const dest = path11.join(backupDir, file);
-    const destDir = path11.dirname(dest);
-    if (!fs11.existsSync(destDir)) {
-      fs11.mkdirSync(destDir, { recursive: true });
+    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 });
     }
-    fs11.copyFileSync(file, dest);
+    fs13.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path11.join(backupDir, file);
-  if (!fs11.existsSync(backupFile)) return false;
-  const destDir = path11.dirname(file);
-  if (!fs11.existsSync(destDir)) {
-    fs11.mkdirSync(destDir, { recursive: true });
+  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 });
   }
-  fs11.copyFileSync(backupFile, file);
+  fs13.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs12 from "fs";
+import fs14 from "fs";
 import crypto2 from "crypto";
 function readManifest() {
   try {
-    if (!fs12.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs12.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs14.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs14.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs12.existsSync(CALIBER_DIR)) {
-    fs12.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs14.existsSync(CALIBER_DIR)) {
+    fs14.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs12.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs14.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs12.readFileSync(filePath);
+  const content = fs14.readFileSync(filePath);
   return crypto2.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) => fs13.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs15.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs13.existsSync(f)),
+    ...filesToWrite.filter((f) => fs15.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -3653,9 +4219,12 @@ function writeSetup(setup) {
   if (setup.targetAgent.includes("codex") && setup.codex) {
     written.push(...writeCodexConfig(setup.codex));
   }
+  if (setup.targetAgent.includes("github-copilot") && setup.copilot) {
+    written.push(...writeGithubCopilotConfig(setup.copilot));
+  }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs13.unlinkSync(filePath);
+    fs15.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -3685,8 +4254,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs13.existsSync(entry.path)) {
-        fs13.unlinkSync(entry.path);
+      if (fs15.existsSync(entry.path)) {
+        fs15.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -3696,8 +4265,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs13.existsSync(MANIFEST_FILE2)) {
-    fs13.unlinkSync(MANIFEST_FILE2);
+  if (fs15.existsSync(MANIFEST_FILE2)) {
+    fs15.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -3728,27 +4297,33 @@ function getFilesToWrite(setup) {
       for (const s of setup.codex.skills) files.push(`.agents/skills/${s.name}/SKILL.md`);
     }
   }
+  if (setup.targetAgent.includes("github-copilot") && setup.copilot) {
+    if (setup.copilot.instructions) files.push(".github/copilot-instructions.md");
+    if (setup.copilot.instructionFiles) {
+      for (const f of setup.copilot.instructionFiles) files.push(`.github/instructions/${f.filename}`);
+    }
+  }
   return files;
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs13.existsSync(gitignorePath)) {
-    const content = fs13.readFileSync(gitignorePath, "utf-8");
+  if (fs15.existsSync(gitignorePath)) {
+    const content = fs15.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs13.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs15.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs13.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs15.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
 init_constants();
-import fs14 from "fs";
-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");
+import fs16 from "fs";
+import path14 from "path";
+var STAGED_DIR = path14.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path14.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path14.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -3758,20 +4333,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path12.join(projectDir, file.path);
-    if (fs14.existsSync(originalPath)) {
-      const existing = fs14.readFileSync(originalPath, "utf-8");
+    const originalPath = path14.join(projectDir, file.path);
+    if (fs16.existsSync(originalPath)) {
+      const existing = fs16.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path12.join(PROPOSED_DIR, file.path);
-    fs14.mkdirSync(path12.dirname(proposedPath), { recursive: true });
-    fs14.writeFileSync(proposedPath, file.content);
-    if (fs14.existsSync(originalPath)) {
-      const currentPath = path12.join(CURRENT_DIR, file.path);
-      fs14.mkdirSync(path12.dirname(currentPath), { recursive: true });
-      fs14.copyFileSync(originalPath, currentPath);
+    const proposedPath = path14.join(PROPOSED_DIR, file.path);
+    fs16.mkdirSync(path14.dirname(proposedPath), { recursive: true });
+    fs16.writeFileSync(proposedPath, file.content);
+    if (fs16.existsSync(originalPath)) {
+      const currentPath = path14.join(CURRENT_DIR, file.path);
+      fs16.mkdirSync(path14.dirname(currentPath), { recursive: true });
+      fs16.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -3782,13 +4357,13 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs14.existsSync(STAGED_DIR)) {
-    fs14.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs16.existsSync(STAGED_DIR)) {
+    fs16.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs15 from "fs";
+import fs17 from "fs";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -3836,8 +4411,18 @@ function collectSetupFiles(setup, targetAgent) {
       }
     }
   }
+  const copilot = setup.copilot;
+  if (copilot) {
+    if (copilot.instructions) files.push({ path: ".github/copilot-instructions.md", content: copilot.instructions });
+    const instructionFiles = copilot.instructionFiles;
+    if (Array.isArray(instructionFiles)) {
+      for (const file of instructionFiles) {
+        files.push({ path: `.github/instructions/${file.filename}`, content: file.content });
+      }
+    }
+  }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs15.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs17.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.");
@@ -3855,27 +4440,27 @@ ${agentRefs.join(" ")}
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs17 from "fs";
-import path13 from "path";
+import fs19 from "fs";
+import path15 from "path";
 import { execSync as execSync7 } from "child_process";
-var SETTINGS_PATH = path13.join(".claude", "settings.json");
+var SETTINGS_PATH = path15.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs17.existsSync(SETTINGS_PATH)) return {};
+  if (!fs19.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs19.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path13.dirname(SETTINGS_PATH);
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path15.dirname(SETTINGS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3938,19 +4523,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync7("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path13.join(gitDir, "hooks");
+    return path15.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path15.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) return false;
-  const content = fs17.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs19.existsSync(hookPath)) return false;
+  const content = fs19.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3959,44 +4544,44 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path13.dirname(hookPath);
-  if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path15.dirname(hookPath);
+  if (!fs19.existsSync(hooksDir)) fs19.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs17.existsSync(hookPath)) {
-    content = fs17.readFileSync(hookPath, "utf-8");
+  if (fs19.existsSync(hookPath)) {
+    content = fs19.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs17.writeFileSync(hookPath, content);
-  fs17.chmodSync(hookPath, 493);
+  fs19.writeFileSync(hookPath, content);
+  fs19.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) {
+  if (!hookPath || !fs19.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs17.readFileSync(hookPath, "utf-8");
+  let content = fs19.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs17.unlinkSync(hookPath);
+    fs19.unlinkSync(hookPath);
   } else {
-    fs17.writeFileSync(hookPath, content);
+    fs19.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs18 from "fs";
-import path14 from "path";
-var SETTINGS_PATH2 = path14.join(".claude", "settings.json");
+import fs20 from "fs";
+import path16 from "path";
+var SETTINGS_PATH2 = path16.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" },
@@ -4013,17 +4598,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings2() {
-  if (!fs18.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs20.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs20.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path14.dirname(SETTINGS_PATH2);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path16.dirname(SETTINGS_PATH2);
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -4057,7 +4642,7 @@ function installLearningHooks() {
   writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path14.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path16.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -4065,17 +4650,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs18.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs18.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs20.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path14.dirname(CURSOR_HOOKS_PATH);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  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));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -4145,22 +4730,22 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs19 from "fs";
-import path15 from "path";
+import fs21 from "fs";
+import path17 from "path";
 import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path17.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
     if (value === "both") return ["claude", "cursor"];
-    if (["claude", "cursor", "codex"].includes(value)) return [value];
+    if (["claude", "cursor", "codex", "github-copilot"].includes(value)) return [value];
   }
   return void 0;
 }
 function readState() {
   try {
-    if (!fs19.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs19.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs21.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs21.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -4168,10 +4753,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs21.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -4287,11 +4872,11 @@ async function runInteractiveProviderSetup(options) {
 
 // src/scoring/index.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/scoring/checks/existence.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 
 // src/scoring/constants.ts
 var POINTS_CLAUDE_MD_EXISTS = 6;
@@ -4319,6 +4904,8 @@ var POINTS_HOOKS = 2;
 var POINTS_AGENTS_MD = 1;
 var POINTS_OPEN_SKILLS_FORMAT = 2;
 var POINTS_LEARNED_CONTENT = 2;
+var POINTS_SOURCES_CONFIGURED = 3;
+var POINTS_SOURCES_REFERENCED = 3;
 var TOKEN_BUDGET_THRESHOLDS = [
   { maxTokens: 2e3, points: 6 },
   { maxTokens: 3500, points: 5 },
@@ -4382,6 +4969,9 @@ var BOTH_ONLY_CHECKS = /* @__PURE__ */ new Set([
 var CODEX_ONLY_CHECKS = /* @__PURE__ */ new Set([
   "codex_agents_md_exists"
 ]);
+var COPILOT_ONLY_CHECKS = /* @__PURE__ */ new Set([
+  "copilot_instructions_exists"
+]);
 var NON_CODEX_CHECKS = /* @__PURE__ */ new Set([
   "agents_md_exists"
 ]);
@@ -4402,13 +4992,13 @@ function computeGrade(score) {
 // src/scoring/checks/existence.ts
 function countFiles(dir, pattern) {
   try {
-    return readdirSync(dir, { recursive: true }).map(String).filter((f) => pattern.test(f));
+    return readdirSync2(dir, { recursive: true }).map(String).filter((f) => pattern.test(f));
   } catch {
     return [];
   }
 }
 function hasMcpServers(dir) {
-  const sources = [];
+  const sources2 = [];
   let count = 0;
   const mcpFiles = [
     ".mcp.json",
@@ -4418,21 +5008,21 @@ function hasMcpServers(dir) {
   ];
   for (const rel of mcpFiles) {
     try {
-      const content = readFileSync2(join2(dir, rel), "utf-8");
+      const content = readFileSync3(join3(dir, rel), "utf-8");
       const parsed = JSON.parse(content);
       const servers = parsed.mcpServers;
       if (servers && Object.keys(servers).length > 0) {
         count += Object.keys(servers).length;
-        sources.push(rel);
+        sources2.push(rel);
       }
     } catch {
     }
   }
-  return { count, sources };
+  return { count, sources: sources2 };
 }
 function checkExistence(dir) {
   const checks = [];
-  const claudeMdExists = existsSync2(join2(dir, "CLAUDE.md"));
+  const claudeMdExists = existsSync3(join3(dir, "CLAUDE.md"));
   checks.push({
     id: "claude_md_exists",
     name: "CLAUDE.md exists",
@@ -4448,8 +5038,8 @@ function checkExistence(dir) {
       instruction: "Create CLAUDE.md with project context, commands, architecture, and conventions."
     }
   });
-  const hasCursorrules = existsSync2(join2(dir, ".cursorrules"));
-  const cursorRulesDir = existsSync2(join2(dir, ".cursor", "rules"));
+  const hasCursorrules = existsSync3(join3(dir, ".cursorrules"));
+  const cursorRulesDir = existsSync3(join3(dir, ".cursor", "rules"));
   const cursorRulesExist = hasCursorrules || cursorRulesDir;
   checks.push({
     id: "cursor_rules_exist",
@@ -4466,7 +5056,7 @@ function checkExistence(dir) {
       instruction: "Create .cursor/rules/ with project-specific Cursor rules."
     }
   });
-  const agentsMdExists = existsSync2(join2(dir, "AGENTS.md"));
+  const agentsMdExists = existsSync3(join3(dir, "AGENTS.md"));
   checks.push({
     id: "codex_agents_md_exists",
     name: "AGENTS.md exists",
@@ -4478,12 +5068,28 @@ function checkExistence(dir) {
     suggestion: agentsMdExists ? void 0 : "Create AGENTS.md with project context for Codex",
     fix: agentsMdExists ? void 0 : {
       action: "create_file",
-      data: { file: "AGENTS.md" },
-      instruction: "Create AGENTS.md with project context for Codex."
+      data: { file: "AGENTS.md" },
+      instruction: "Create AGENTS.md with project context for Codex."
+    }
+  });
+  const copilotInstructionsExists = existsSync3(join3(dir, ".github", "copilot-instructions.md"));
+  checks.push({
+    id: "copilot_instructions_exists",
+    name: "Copilot instructions exist",
+    category: "existence",
+    maxPoints: POINTS_CLAUDE_MD_EXISTS,
+    earnedPoints: copilotInstructionsExists ? POINTS_CLAUDE_MD_EXISTS : 0,
+    passed: copilotInstructionsExists,
+    detail: copilotInstructionsExists ? "Found at .github/copilot-instructions.md" : "Not found",
+    suggestion: copilotInstructionsExists ? void 0 : "Create .github/copilot-instructions.md with project context for GitHub Copilot",
+    fix: copilotInstructionsExists ? void 0 : {
+      action: "create_file",
+      data: { file: ".github/copilot-instructions.md" },
+      instruction: "Create .github/copilot-instructions.md with project context for GitHub Copilot."
     }
   });
-  const claudeSkills = countFiles(join2(dir, ".claude", "skills"), /\.(md|SKILL\.md)$/);
-  const codexSkills = countFiles(join2(dir, ".agents", "skills"), /SKILL\.md$/);
+  const claudeSkills = countFiles(join3(dir, ".claude", "skills"), /\.(md|SKILL\.md)$/);
+  const codexSkills = countFiles(join3(dir, ".agents", "skills"), /SKILL\.md$/);
   const skillCount = claudeSkills.length + codexSkills.length;
   const skillBase = skillCount >= 1 ? POINTS_SKILLS_EXIST : 0;
   const skillBonus = Math.min((skillCount - 1) * POINTS_SKILLS_BONUS_PER_EXTRA, POINTS_SKILLS_BONUS_CAP);
@@ -4504,7 +5110,7 @@ function checkExistence(dir) {
       instruction: "Create .claude/skills/ with 2-3 project-specific workflow skills."
     } : void 0
   });
-  const mdcFiles = countFiles(join2(dir, ".cursor", "rules"), /\.mdc$/);
+  const mdcFiles = countFiles(join3(dir, ".cursor", "rules"), /\.mdc$/);
   const mdcCount = mdcFiles.length;
   checks.push({
     id: "cursor_mdc_rules",
@@ -4547,297 +5153,24 @@ function checkExistence(dir) {
     maxPoints: POINTS_CROSS_PLATFORM_PARITY,
     earnedPoints: hasParity ? POINTS_CROSS_PLATFORM_PARITY : 0,
     passed: hasParity,
-    detail: hasParity ? "Both Claude Code and Cursor configured" : hasClaudeConfigs ? "Only Claude Code \u2014 no Cursor configs" : hasCursorConfigs ? "Only Cursor \u2014 no Claude Code configs" : "Neither platform configured",
-    suggestion: hasParity ? void 0 : "Add configs for both platforms so all teammates get context",
-    fix: hasParity ? void 0 : {
-      action: "add_platform",
-      data: { hasClaude: hasClaudeConfigs, hasCursor: hasCursorConfigs },
-      instruction: hasClaudeConfigs ? "Add Cursor rules (.cursor/rules/) for cross-platform support." : "Add CLAUDE.md for cross-platform support."
-    }
-  });
-  return checks;
-}
-
-// src/scoring/checks/quality.ts
-import { join as join4 } from "path";
-
-// src/scoring/utils.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { join as join3, relative } from "path";
-function readFileOrNull2(filePath) {
-  try {
-    return readFileSync3(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-var IGNORED_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  ".nuxt",
-  "__pycache__",
-  ".venv",
-  "venv",
-  "env",
-  ".env",
-  "target",
-  "vendor",
-  ".cache",
-  ".parcel-cache",
-  "coverage",
-  ".nyc_output",
-  ".turbo",
-  ".caliber",
-  ".claude",
-  ".cursor",
-  ".agents",
-  ".codex"
-]);
-var IGNORED_FILES = /* @__PURE__ */ new Set([
-  ".DS_Store",
-  "Thumbs.db",
-  ".gitignore",
-  ".editorconfig",
-  ".prettierrc",
-  ".prettierignore",
-  ".eslintignore",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "bun.lockb"
-]);
-function collectProjectStructure(dir, maxDepth = 2) {
-  const dirs = [];
-  const files = [];
-  function walk(currentDir, depth) {
-    if (depth > maxDepth) return;
-    try {
-      const entries = readdirSync2(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        const name = entry.name;
-        if (name.startsWith(".") && IGNORED_DIRS.has(name)) continue;
-        if (IGNORED_FILES.has(name)) continue;
-        const rel = relative(dir, join3(currentDir, name));
-        if (entry.isDirectory()) {
-          if (IGNORED_DIRS.has(name)) continue;
-          dirs.push(rel);
-          walk(join3(currentDir, name), depth + 1);
-        } else if (entry.isFile()) {
-          files.push(rel);
-        }
-      }
-    } catch {
-    }
-  }
-  walk(dir, 0);
-  return { dirs, files };
-}
-function collectPrimaryConfigContent(dir) {
-  const parts = [];
-  for (const file of ["CLAUDE.md", ".cursorrules", "AGENTS.md"]) {
-    const content = readFileOrNull2(join3(dir, file));
-    if (content) parts.push(content);
-  }
-  try {
-    const rulesDir = join3(dir, ".cursor", "rules");
-    const mdcFiles = readdirSync2(rulesDir).filter((f) => f.endsWith(".mdc"));
-    for (const f of mdcFiles) {
-      const content = readFileOrNull2(join3(rulesDir, f));
-      if (content) parts.push(content);
-    }
-  } catch {
-  }
-  return parts.join("\n");
-}
-function collectAllConfigContent(dir) {
-  const parts = [collectPrimaryConfigContent(dir)];
-  for (const skillsDir of [join3(dir, ".claude", "skills"), join3(dir, ".agents", "skills")]) {
-    try {
-      const entries = readdirSync2(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const skill = readFileOrNull2(join3(skillsDir, entry.name, "SKILL.md"));
-          if (skill) parts.push(skill);
-        } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          const content = readFileOrNull2(join3(skillsDir, entry.name));
-          if (content) parts.push(content);
-        }
-      }
-    } catch {
-    }
-  }
-  return parts.join("\n");
-}
-function estimateTokens2(text) {
-  return Math.ceil(text.length / 4);
-}
-function analyzeMarkdownStructure(content) {
-  const lines = content.split("\n");
-  let headingCount = 0;
-  let h2Count = 0;
-  let h3Count = 0;
-  let codeBlockCount = 0;
-  let codeBlockLines = 0;
-  let listItemCount = 0;
-  let inlineCodeCount = 0;
-  let inCodeBlock = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("```")) {
-      if (!inCodeBlock) codeBlockCount++;
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock) {
-      codeBlockLines++;
-      continue;
-    }
-    if (trimmed.startsWith("## ") && !trimmed.startsWith("### ")) h2Count++;
-    if (trimmed.startsWith("### ")) h3Count++;
-    if (trimmed.startsWith("#")) headingCount++;
-    if (/^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) listItemCount++;
-    const inlineMatches = trimmed.match(/`[^`]+`/g);
-    if (inlineMatches) inlineCodeCount += inlineMatches.length;
-  }
-  return {
-    headingCount,
-    h2Count,
-    h3Count,
-    codeBlockCount,
-    codeBlockLines,
-    listItemCount,
-    inlineCodeCount,
-    totalLines: lines.length,
-    nonEmptyLines: lines.filter((l) => l.trim().length > 0).length
-  };
-}
-function extractReferences(content) {
-  const refs = /* @__PURE__ */ new Set();
-  const backtickPattern = /`([^`]+)`/g;
-  let match;
-  while ((match = backtickPattern.exec(content)) !== null) {
-    const term = match[1].trim();
-    if ((term.includes("/") || /\.\w{1,5}$/.test(term)) && !term.startsWith("-") && term.length < 200) {
-      if (term.startsWith("@") && (term.match(/\//g) || []).length === 1) continue;
-      if (term.includes(" ")) continue;
-      if (/^\d+\.\d+/.test(term)) continue;
-      if (term.includes("/") && !/\.\w{1,5}$/.test(term)) {
-        if (term !== term.toLowerCase() && !/^[a-z]/.test(term)) continue;
-        const segments = term.split("/");
-        if (segments.every((s) => s.length <= 3)) continue;
-      }
-      const cleaned = term.replace(/[,;:!?)]+$/, "");
-      if (cleaned.length > 1) refs.add(cleaned);
-    }
-  }
-  const pathPattern = /(?:^|\s)((?:[a-zA-Z0-9_@.-]+\/)+[a-zA-Z0-9_.*-]+\.[a-zA-Z]{1,5})/gm;
-  while ((match = pathPattern.exec(content)) !== null) {
-    const term = match[1].trim();
-    if (term.length > 2 && term.length < 200) {
-      if (term.startsWith("@") && (term.match(/\//g) || []).length === 1) continue;
-      const cleaned = term.replace(/[,;:!?)]+$/, "");
-      if (cleaned.length > 1) refs.add(cleaned);
-    }
-  }
-  return Array.from(refs);
-}
-function validateFileReferences(content, dir, checkExists = existsSync3) {
-  const refs = extractReferences(content);
-  const valid = [];
-  const invalid = [];
-  for (const ref of refs) {
-    if (/^https?:\/\//.test(ref)) continue;
-    if (/^\d+\.\d+/.test(ref)) continue;
-    if (ref.startsWith("#") || ref.startsWith("@")) continue;
-    if (ref.includes("*") || ref.includes("..")) continue;
-    if (!ref.includes("/") && !ref.includes(".")) continue;
-    const fullPath = join3(dir, ref);
-    if (checkExists(fullPath)) {
-      valid.push(ref);
-    } else {
-      const withoutTrailing = ref.replace(/\/+$/, "");
-      if (withoutTrailing !== ref && checkExists(join3(dir, withoutTrailing))) {
-        valid.push(ref);
-      } else {
-        invalid.push(ref);
-      }
-    }
-  }
-  return { valid, invalid, total: valid.length + invalid.length };
-}
-function countConcreteness(content) {
-  let concrete = 0;
-  let abstract = 0;
-  let inCodeBlock = false;
-  for (const line of content.split("\n")) {
-    if (line.trim().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    const classification = classifyLine(line, inCodeBlock);
-    if (classification === "concrete") concrete++;
-    else if (classification === "abstract") abstract++;
-  }
-  return { concrete, abstract };
-}
-function countTreeLines(content) {
-  const treeLinePattern = /[├└│─┬]/;
-  let count = 0;
-  let inCodeBlock = false;
-  for (const line of content.split("\n")) {
-    if (line.trim().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock && treeLinePattern.test(line)) count++;
-  }
-  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);
+    detail: hasParity ? "Both Claude Code and Cursor configured" : hasClaudeConfigs ? "Only Claude Code \u2014 no Cursor configs" : hasCursorConfigs ? "Only Cursor \u2014 no Claude Code configs" : "Neither platform configured",
+    suggestion: hasParity ? void 0 : "Add configs for both platforms so all teammates get context",
+    fix: hasParity ? void 0 : {
+      action: "add_platform",
+      data: { hasClaude: hasClaudeConfigs, hasCursor: hasCursorConfigs },
+      instruction: hasClaudeConfigs ? "Add Cursor rules (.cursor/rules/) for cross-platform support." : "Add CLAUDE.md for cross-platform support."
+    }
   });
-}
-function classifyLine(line, inCodeBlock) {
-  if (inCodeBlock) return "concrete";
-  const trimmed = line.trim();
-  if (trimmed.length === 0) return "neutral";
-  if (trimmed.startsWith("#")) return "neutral";
-  if (/`[^`]+`/.test(trimmed)) return "concrete";
-  if (/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\.[a-zA-Z]{1,5}/.test(trimmed)) return "concrete";
-  if (/[a-zA-Z0-9_]{4,}\/[a-zA-Z0-9_.-]/.test(trimmed)) return "concrete";
-  if (/\b[a-zA-Z0-9_-]+\.[a-zA-Z]{1,5}\b/.test(trimmed) && !/\b(e\.g|i\.e|vs|etc)\b/i.test(trimmed)) return "concrete";
-  return "abstract";
+  return checks;
 }
 
 // src/scoring/checks/quality.ts
+import { join as join4 } from "path";
 function checkQuality(dir) {
   const checks = [];
-  const claudeMd = readFileOrNull2(join4(dir, "CLAUDE.md"));
-  const cursorrules = readFileOrNull2(join4(dir, ".cursorrules"));
-  const agentsMd = readFileOrNull2(join4(dir, "AGENTS.md"));
+  const claudeMd = readFileOrNull(join4(dir, "CLAUDE.md"));
+  const cursorrules = readFileOrNull(join4(dir, ".cursorrules"));
+  const agentsMd = readFileOrNull(join4(dir, "AGENTS.md"));
   const allContent = [claudeMd, cursorrules, agentsMd].filter(Boolean);
   const combinedContent = allContent.join("\n");
   const primaryInstructions = claudeMd ?? agentsMd ?? cursorrules;
@@ -5253,7 +5586,7 @@ function checkFreshness(dir) {
   ];
   const secretFindings = [];
   for (const rel of filesToScan) {
-    const content = readFileOrNull2(join6(dir, rel));
+    const content = readFileOrNull(join6(dir, rel));
     if (!content) continue;
     const lines = content.split("\n");
     for (let i = 0; i < lines.length; i++) {
@@ -5287,7 +5620,7 @@ function checkFreshness(dir) {
   const settingsPath = join6(dir, ".claude", "settings.json");
   let hasPermissions = false;
   let permissionDetail = "";
-  const settingsContent = readFileOrNull2(settingsPath);
+  const settingsContent = readFileOrNull(settingsPath);
   if (settingsContent) {
     try {
       const settings = JSON.parse(settingsContent);
@@ -5327,7 +5660,7 @@ function hasPreCommitHook(dir) {
   try {
     const gitDir = execSync11("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join7(gitDir, "hooks", "pre-commit");
-    const content = readFileOrNull2(hookPath);
+    const content = readFileOrNull(hookPath);
     return content ? content.includes("caliber") : false;
   } catch {
     return false;
@@ -5338,7 +5671,7 @@ function checkBonus(dir) {
   let hasClaudeHooks = false;
   let hasPrecommit = false;
   const hookSources = [];
-  const settingsContent = readFileOrNull2(join7(dir, ".claude", "settings.json"));
+  const settingsContent = readFileOrNull(join7(dir, ".claude", "settings.json"));
   if (settingsContent) {
     try {
       const settings = JSON.parse(settingsContent);
@@ -5393,7 +5726,7 @@ function checkBonus(dir) {
     const entries = readdirSync3(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const skillMd = readFileOrNull2(join7(skillsDir, entry.name, "SKILL.md"));
+        const skillMd = readFileOrNull(join7(skillsDir, entry.name, "SKILL.md"));
         if (skillMd) {
           totalSkillFiles++;
           if (skillMd.trimStart().startsWith("---")) {
@@ -5422,7 +5755,7 @@ function checkBonus(dir) {
       instruction: "Migrate flat skill files to .claude/skills/{name}/SKILL.md with YAML frontmatter."
     } : void 0
   });
-  const learningsContent = readFileOrNull2(join7(dir, "CALIBER_LEARNINGS.md"));
+  const learningsContent = readFileOrNull(join7(dir, "CALIBER_LEARNINGS.md"));
   const hasLearned = learningsContent ? learningsContent.split("\n").filter((l) => l.startsWith("- ")).length > 0 : false;
   checks.push({
     id: "learned_content",
@@ -5437,24 +5770,62 @@ function checkBonus(dir) {
   return checks;
 }
 
+// src/scoring/checks/sources.ts
+import { join as join8 } from "path";
+function checkSources(dir) {
+  const checks = [];
+  const configSources = loadSourcesConfig(dir);
+  const hasSources = configSources.length > 0;
+  checks.push({
+    id: "sources_configured",
+    name: "External sources configured",
+    category: "bonus",
+    maxPoints: hasSources ? POINTS_SOURCES_CONFIGURED : 0,
+    earnedPoints: hasSources ? POINTS_SOURCES_CONFIGURED : 0,
+    passed: hasSources,
+    detail: hasSources ? `${configSources.length} source${configSources.length === 1 ? "" : "s"} configured` : "No external sources configured",
+    suggestion: hasSources ? void 0 : "Run `caliber sources add <path>` to add related repos or docs"
+  });
+  if (hasSources) {
+    const claudeMd = readFileOrNull(join8(dir, "CLAUDE.md"));
+    const content = claudeMd?.toLowerCase() || "";
+    const referenced = configSources.some((source) => {
+      if (!source.path) return false;
+      const name = source.path.split("/").pop()?.toLowerCase() || "";
+      return name.length > 2 && content.includes(name);
+    });
+    checks.push({
+      id: "sources_referenced",
+      name: "Sources referenced in config",
+      category: "grounding",
+      maxPoints: POINTS_SOURCES_REFERENCED,
+      earnedPoints: referenced ? POINTS_SOURCES_REFERENCED : 0,
+      passed: referenced,
+      detail: referenced ? "At least one source is referenced in CLAUDE.md" : "No configured sources are mentioned in CLAUDE.md",
+      suggestion: referenced ? void 0 : "Regenerate with `caliber init` to include source context in your config"
+    });
+  }
+  return checks;
+}
+
 // src/scoring/dismissed.ts
 init_constants();
-import fs20 from "fs";
-import path16 from "path";
-var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+import fs22 from "fs";
+import path18 from "path";
+var DISMISSED_FILE = path18.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs20.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs20.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs22.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs22.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs20.existsSync(CALIBER_DIR)) {
-    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs22.existsSync(CALIBER_DIR)) {
+    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs20.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs22.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -5473,6 +5844,7 @@ function filterChecksForTarget(checks, target) {
     if (CLAUDE_ONLY_CHECKS.has(c.id)) return target.includes("claude");
     if (CURSOR_ONLY_CHECKS.has(c.id)) return target.includes("cursor");
     if (CODEX_ONLY_CHECKS.has(c.id)) return target.includes("codex");
+    if (COPILOT_ONLY_CHECKS.has(c.id)) return target.includes("github-copilot");
     if (BOTH_ONLY_CHECKS.has(c.id)) return target.includes("claude") && target.includes("cursor");
     if (NON_CODEX_CHECKS.has(c.id)) return !target.includes("codex");
     return true;
@@ -5480,9 +5852,10 @@ function filterChecksForTarget(checks, target) {
 }
 function detectTargetAgent(dir) {
   const agents = [];
-  if (existsSync7(join8(dir, "CLAUDE.md")) || existsSync7(join8(dir, ".claude", "skills"))) agents.push("claude");
-  if (existsSync7(join8(dir, ".cursorrules")) || existsSync7(join8(dir, ".cursor", "rules"))) agents.push("cursor");
-  if (existsSync7(join8(dir, ".codex")) || existsSync7(join8(dir, ".agents", "skills"))) agents.push("codex");
+  if (existsSync7(join9(dir, "CLAUDE.md")) || existsSync7(join9(dir, ".claude", "skills"))) agents.push("claude");
+  if (existsSync7(join9(dir, ".cursorrules")) || existsSync7(join9(dir, ".cursor", "rules"))) agents.push("cursor");
+  if (existsSync7(join9(dir, ".codex")) || existsSync7(join9(dir, ".agents", "skills"))) agents.push("codex");
+  if (existsSync7(join9(dir, ".github", "copilot-instructions.md"))) agents.push("github-copilot");
   return agents.length > 0 ? agents : ["claude"];
 }
 function computeLocalScore(dir, targetAgent) {
@@ -5493,7 +5866,8 @@ function computeLocalScore(dir, targetAgent) {
     ...checkGrounding(dir),
     ...checkAccuracy(dir),
     ...checkFreshness(dir),
-    ...checkBonus(dir)
+    ...checkBonus(dir),
+    ...checkSources(dir)
   ];
   const dismissed = getDismissedIds();
   const checks = filterChecksForTarget(allChecks, target).filter((c) => !dismissed.has(c.id));
@@ -5696,16 +6070,16 @@ import chalk6 from "chalk";
 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 join9, dirname as dirname2 } from "path";
+import { join as join10, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs21 from "fs";
-import path17 from "path";
+import fs23 from "fs";
+import path19 from "path";
 import crypto3 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path17.join(dir, "CLAUDE.md");
-  if (fs21.existsSync(claudeMdPath)) {
+  const claudeMdPath = path19.join(dir, "CLAUDE.md");
+  if (fs23.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5714,10 +6088,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path17.join(dir, ".claude", "skills");
-  if (fs21.existsSync(skillsDir)) {
-    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path17.join(skillsDir, file);
+  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",
@@ -5727,10 +6101,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path17.join(dir, ".mcp.json");
-  if (fs21.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path19.join(dir, ".mcp.json");
+  if (fs23.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5745,8 +6119,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path17.join(dir, "AGENTS.md");
-  if (fs21.existsSync(agentsMdPath)) {
+  const agentsMdPath = path19.join(dir, "AGENTS.md");
+  if (fs23.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -5755,12 +6129,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path17.join(dir, ".agents", "skills");
-  if (fs21.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path19.join(dir, ".agents", "skills");
+  if (fs23.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(codexSkillsDir)) {
-        const skillFile = path17.join(codexSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      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",
@@ -5773,8 +6147,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path17.join(dir, ".cursorrules");
-  if (fs21.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path19.join(dir, ".cursorrules");
+  if (fs23.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5783,10 +6157,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
-  if (fs21.existsSync(cursorRulesDir)) {
-    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path17.join(cursorRulesDir, file);
+  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",
@@ -5796,12 +6170,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
-  if (fs21.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
+  if (fs23.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(cursorSkillsDir)) {
-        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      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",
@@ -5814,10 +6188,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
-  if (fs21.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
+  if (fs23.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5835,7 +6209,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs21.readFileSync(filePath, "utf-8");
+  const text = fs23.readFileSync(filePath, "utf-8");
   return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5850,27 +6224,27 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs22 from "fs";
-import path18 from "path";
+import fs24 from "fs";
+import path20 from "path";
 import os4 from "os";
 import crypto4 from "crypto";
 import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path18.join(os4.homedir(), ".caliber");
-var CONFIG_FILE2 = path18.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = path20.join(os4.homedir(), ".caliber");
+var CONFIG_FILE2 = path20.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs22.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs22.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs24.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs24.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs22.existsSync(CONFIG_DIR2)) {
-    fs22.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs24.existsSync(CONFIG_DIR2)) {
+    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs22.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6054,17 +6428,17 @@ function detectLocalPlatforms() {
 }
 function getSkillPath(platform, slug) {
   if (platform === "cursor") {
-    return join9(".cursor", "skills", slug, "SKILL.md");
+    return join10(".cursor", "skills", slug, "SKILL.md");
   }
   if (platform === "codex") {
-    return join9(".agents", "skills", slug, "SKILL.md");
+    return join10(".agents", "skills", slug, "SKILL.md");
   }
-  return join9(".claude", "skills", slug, "SKILL.md");
+  return join10(".claude", "skills", slug, "SKILL.md");
 }
 function getSkillDir(platform) {
-  if (platform === "cursor") return join9(process.cwd(), ".cursor", "skills");
-  if (platform === "codex") return join9(process.cwd(), ".agents", "skills");
-  return join9(process.cwd(), ".claude", "skills");
+  if (platform === "cursor") return join10(process.cwd(), ".cursor", "skills");
+  if (platform === "codex") return join10(process.cwd(), ".agents", "skills");
+  return join10(process.cwd(), ".claude", "skills");
 }
 function getInstalledSkills(platforms) {
   const installed = /* @__PURE__ */ new Set();
@@ -6235,7 +6609,7 @@ Already installed skills: ${Array.from(installed).join(", ")}`);
   return parts.join("\n");
 }
 function extractTopDeps() {
-  const pkgPath = join9(process.cwd(), "package.json");
+  const pkgPath = join10(process.cwd(), "package.json");
   if (!existsSync8(pkgPath)) return [];
   try {
     const pkg3 = JSON.parse(readFileSync4(pkgPath, "utf-8"));
@@ -6574,7 +6948,7 @@ async function installSkills(recs, platforms, contentMap) {
     if (!content) continue;
     for (const platform of platforms) {
       const skillPath = getSkillPath(platform, rec.slug);
-      const fullPath = join9(process.cwd(), skillPath);
+      const fullPath = join10(process.cwd(), skillPath);
       mkdirSync(dirname2(fullPath), { recursive: true });
       writeFileSync(fullPath, content, "utf-8");
       installed.push(`[${platform}] ${skillPath}`);
@@ -6829,11 +7203,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path33) => {
-    const cached = existsCache.get(path33);
+  const cachedExists = (path37) => {
+    const cached = existsCache.get(path37);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path33);
-    existsCache.set(path33, result);
+    const result = existsSync9(path37);
+    existsCache.set(path37, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -6972,8 +7346,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 
 // src/lib/debug-report.ts
-import fs23 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path21 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -7042,11 +7416,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path19.dirname(outputPath);
-    if (!fs23.existsSync(dir)) {
-      fs23.mkdirSync(dir, { recursive: true });
+    const dir = path21.dirname(outputPath);
+    if (!fs25.existsSync(dir)) {
+      fs25.mkdirSync(dir, { recursive: true });
     }
-    fs23.writeFileSync(outputPath, lines.join("\n"));
+    fs25.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -7447,7 +7821,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs26 from "fs";
+import fs28 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -7588,16 +7962,18 @@ init_config();
 init_review();
 function detectAgents(dir) {
   const agents = [];
-  if (fs26.existsSync(`${dir}/.claude`)) agents.push("claude");
-  if (fs26.existsSync(`${dir}/.cursor`)) agents.push("cursor");
-  if (fs26.existsSync(`${dir}/.agents`) || fs26.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs28.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs28.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs28.existsSync(`${dir}/.agents`) || fs28.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs28.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
   const choices = [
     { name: "Claude Code", value: "claude", checked: detected?.includes("claude") ?? false },
     { name: "Cursor", value: "cursor", checked: detected?.includes("cursor") ?? false },
-    { name: "Codex (OpenAI)", value: "codex", checked: detected?.includes("codex") ?? false }
+    { name: "Codex (OpenAI)", value: "codex", checked: detected?.includes("codex") ?? false },
+    { name: "GitHub Copilot", value: "github-copilot", checked: detected?.includes("github-copilot") ?? false }
   ];
   const hasDefaults = detected && detected.length > 0;
   const message = hasDefaults ? "Detected agents (press Enter to confirm, or toggle with space)" : "Which coding agents do you use? (toggle with space)";
@@ -7671,7 +8047,7 @@ async function classifyRefineIntent(message) {
   const fastModel = getFastModel();
   try {
     const result = await llmJsonCall({
-      system: `You classify whether a user message is a valid request to modify AI agent config files (CLAUDE.md, .cursorrules, skills).
+      system: `You classify whether a user message is a valid request to modify AI agent config files (CLAUDE.md, .cursorrules, copilot-instructions.md, skills).
 Valid: requests to add, remove, change, or restructure config content. Examples: "add testing commands", "remove the terraform section", "make CLAUDE.md shorter".
 Invalid: questions, requests to show/display something, general chat, or anything that isn't a concrete config change.
 Return {"valid": true} or {"valid": false}. Nothing else.`,
@@ -7725,18 +8101,18 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs27 from "fs";
+import fs29 from "fs";
 function formatWhatChanged(setup) {
   const lines = [];
   const claude = setup.claude;
   const codex = setup.codex;
   const cursor = setup.cursor;
   if (claude?.claudeMd) {
-    const action = fs27.existsSync("CLAUDE.md") ? "Updated" : "Created";
+    const action = fs29.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   if (codex?.agentsMd) {
-    const action = fs27.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs29.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -7773,7 +8149,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs27.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk12.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -7783,7 +8159,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 = fs27.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -7794,7 +8170,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs27.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -7804,7 +8180,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs27.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -7814,7 +8190,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs27.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -7824,7 +8200,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 = fs27.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -7835,7 +8211,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rulesArr) && rulesArr.length > 0) {
       for (const rule of rulesArr) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs27.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -7882,12 +8258,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs28 from "fs";
-import path21 from "path";
+import fs30 from "fs";
+import path23 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path21.join(dir, ".caliber");
+  const caliberDir = path23.join(dir, ".caliber");
   try {
-    const stat = fs28.statSync(caliberDir);
+    const stat = fs30.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -7940,8 +8316,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs28.existsSync(settingsPath)) {
-      settings = JSON.parse(fs28.readFileSync(settingsPath, "utf-8"));
+    if (fs30.existsSync(settingsPath)) {
+      settings = JSON.parse(fs30.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -7950,12 +8326,12 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs28.existsSync(".claude")) fs28.mkdirSync(".claude", { recursive: true });
-  fs28.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs30.existsSync(".claude")) fs30.mkdirSync(".claude", { recursive: true });
+  fs30.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path21.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path23.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -7968,8 +8344,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs28.mkdirSync(path21.join(process.cwd(), ".caliber"), { recursive: true });
-    fs28.writeFileSync(logPath, lines.join("\n"));
+    fs30.mkdirSync(path23.join(process.cwd(), ".caliber"), { recursive: true });
+    fs30.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8036,7 +8412,7 @@ async function initCommand(options) {
    \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(chalk14.dim("  Scan your project and generate tailored config files for"));
-    console.log(chalk14.dim("  Claude Code, Cursor, and Codex.\n"));
+    console.log(chalk14.dim("  Claude Code, Cursor, Codex, and GitHub Copilot.\n"));
     console.log(title.bold("  How it works:\n"));
     console.log(chalk14.dim("  1. Setup      Connect your LLM provider and select your agents"));
     console.log(chalk14.dim("  2. Engine     Detect stack, generate configs & skills in parallel"));
@@ -8165,6 +8541,13 @@ async function initCommand(options) {
     display.update(TASK_STACK, "done", stackSummary + largeRepoNote);
     trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
     log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
+    const cliSources = options.source || [];
+    const workspaces = getDetectedWorkspaces(process.cwd());
+    const sources2 = resolveAllSources(process.cwd(), cliSources, workspaces);
+    if (sources2.length > 0) {
+      fingerprint.sources = sources2;
+      log(options.verbose, `Sources: ${sources2.length} resolved (${sources2.map((s) => s.name).join(", ")})`);
+    }
     if (report) {
       report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
       report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
@@ -8397,10 +8780,10 @@ async function initCommand(options) {
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
-  const { default: ora8 } = await import("ora");
-  const writeSpinner = ora8("Writing config files...").start();
+  const { default: ora9 } = await import("ora");
+  const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs29.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs31.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -8613,9 +8996,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path22.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path24.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk14.dim(`  Debug report written to ${path22.relative(process.cwd(), reportPath)}
+    console.log(chalk14.dim(`  Debug report written to ${path24.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -8654,7 +9037,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs30 from "fs";
+import fs32 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -8681,7 +9064,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs30.existsSync(entry.path);
+    const exists = fs32.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -8836,21 +9219,21 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs31 from "fs";
+import fs33 from "fs";
 import os6 from "os";
-import path23 from "path";
+import path25 from "path";
 import { execFileSync } from "child_process";
 import chalk18 from "chalk";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs31.mkdtempSync(path23.join(os6.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs33.mkdtempSync(path25.join(os6.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
         const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        fs31.writeFileSync(path23.join(tmpDir, file), content);
+        fs33.writeFileSync(path25.join(tmpDir, file), content);
       } catch {
       }
     }
@@ -8858,10 +9241,10 @@ function scoreBaseRef(ref, target) {
       try {
         const files = execFileSync("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean);
         for (const file of files) {
-          const filePath = path23.join(tmpDir, file);
-          fs31.mkdirSync(path23.dirname(filePath), { recursive: true });
+          const filePath = path25.join(tmpDir, file);
+          fs33.mkdirSync(path25.dirname(filePath), { recursive: true });
           const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-          fs31.writeFileSync(filePath, content);
+          fs33.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -8871,7 +9254,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs31.rmSync(tmpDir, { recursive: true, force: true });
+    fs33.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -8931,8 +9314,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs35 from "fs";
-import path27 from "path";
+import fs37 from "fs";
+import path29 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
 
@@ -9010,38 +9393,49 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs32 from "fs";
-import path24 from "path";
+import fs34 from "fs";
+import path26 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs32.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs34.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs32.writeFileSync("README.md", docs.readmeMd);
+    fs34.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs32.writeFileSync(".cursorrules", docs.cursorrules);
+    fs34.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path24.join(".cursor", "rules");
-    if (!fs32.existsSync(rulesDir)) fs32.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path26.join(".cursor", "rules");
+    if (!fs34.existsSync(rulesDir)) fs34.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path24.join(rulesDir, rule.filename);
-      fs32.writeFileSync(filePath, rule.content);
-      written.push(filePath);
+      fs34.writeFileSync(path26.join(rulesDir, rule.filename), rule.content);
+      written.push(`.cursor/rules/${rule.filename}`);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path24.join(".claude", "skills");
-    if (!fs32.existsSync(skillsDir)) fs32.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path26.join(".claude", "skills");
+    if (!fs34.existsSync(skillsDir)) fs34.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path24.join(skillsDir, skill.filename);
-      fs32.writeFileSync(filePath, skill.content);
-      written.push(filePath);
+      fs34.writeFileSync(path26.join(skillsDir, skill.filename), skill.content);
+      written.push(`.claude/skills/${skill.filename}`);
+    }
+  }
+  if (docs.copilotInstructions) {
+    fs34.mkdirSync(".github", { recursive: true });
+    fs34.writeFileSync(path26.join(".github", "copilot-instructions.md"), docs.copilotInstructions);
+    written.push(".github/copilot-instructions.md");
+  }
+  if (docs.copilotInstructionFiles) {
+    const instructionsDir = path26.join(".github", "instructions");
+    fs34.mkdirSync(instructionsDir, { recursive: true });
+    for (const file of docs.copilotInstructionFiles) {
+      fs34.writeFileSync(path26.join(instructionsDir, file.filename), file.content);
+      written.push(`.github/instructions/${file.filename}`);
     }
   }
   return written;
@@ -9049,8 +9443,8 @@ function writeRefreshDocs(docs) {
 
 // src/ai/refresh.ts
 init_config();
-async function refreshDocs(diff, existingDocs, projectContext, learnedSection) {
-  const prompt = buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection);
+async function refreshDocs(diff, existingDocs, projectContext, learnedSection, sources2) {
+  const prompt = buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection, sources2);
   const fastModel = getFastModel();
   const raw = await llmCall({
     system: REFRESH_SYSTEM_PROMPT,
@@ -9060,7 +9454,7 @@ async function refreshDocs(diff, existingDocs, projectContext, learnedSection) {
   });
   return parseJsonResponse(raw);
 }
-function buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection) {
+function buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection, sources2) {
   const parts = [];
   parts.push("Update documentation based on the following code changes.\n");
   if (projectContext.packageName) parts.push(`Project: ${projectContext.packageName}`);
@@ -9113,12 +9507,15 @@ Changed files: ${diff.changedFiles.join(", ")}`);
     parts.push("Consider these accumulated learnings when deciding what to update:");
     parts.push(learnedSection);
   }
+  if (sources2?.length) {
+    parts.push(formatSourcesForPrompt(sources2));
+  }
   return parts.join("\n");
 }
 
 // src/learner/writer.ts
-import fs33 from "fs";
-import path25 from "path";
+import fs35 from "fs";
+import path27 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -9128,6 +9525,13 @@ function normalizeBullet(bullet) {
 function hasTypePrefix(bullet) {
   return TYPE_PREFIX_RE.test(bullet.replace(/^- /, ""));
 }
+var SCOPE_RE = /^\*\*\[[^\]:]+:([^\]]+)\]\*\*/;
+function extractScope(bullet) {
+  const clean = bullet.replace(/^- /, "");
+  const match = clean.match(SCOPE_RE);
+  if (match && match[1] === "personal") return "personal";
+  return "project";
+}
 var SIMILARITY_THRESHOLD = 0.7;
 function isSimilarLearning(a, b) {
   const normA = normalizeBullet(a);
@@ -9140,12 +9544,19 @@ function isSimilarLearning(a, b) {
 }
 
 // src/learner/writer.ts
+init_constants();
 var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
 var LEARNINGS_HEADER = `# Caliber Learnings
 
 Accumulated patterns and anti-patterns from development sessions.
 Auto-managed by [caliber](https://github.com/rely-ai-org/caliber) \u2014 do not edit manually.
 
+`;
+var PERSONAL_LEARNINGS_HEADER = `# Personal Learnings
+
+Developer-specific patterns and preferences.
+Auto-managed by [caliber](https://github.com/rely-ai-org/caliber) \u2014 do not edit manually.
+
 `;
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
@@ -9154,11 +9565,24 @@ function writeLearnedContent(update) {
   const written = [];
   let newItemCount = 0;
   let newItems = [];
+  let personalItemCount = 0;
+  let personalItems = [];
   if (update.claudeMdLearnedSection) {
-    const result = writeLearnedSection(update.claudeMdLearnedSection);
-    newItemCount = result.newCount;
-    newItems = result.newItems;
-    written.push(LEARNINGS_FILE);
+    const bullets = parseBullets(update.claudeMdLearnedSection);
+    const projectBullets = bullets.filter((b) => extractScope(b) === "project");
+    const personalBullets = bullets.filter((b) => extractScope(b) === "personal");
+    if (projectBullets.length > 0) {
+      const result = writeLearnedSection(projectBullets.join("\n"));
+      newItemCount = result.newCount;
+      newItems = result.newItems;
+      written.push(LEARNINGS_FILE);
+    }
+    if (personalBullets.length > 0) {
+      const result = writePersonalLearnedSection(personalBullets.join("\n"));
+      personalItemCount = result.newCount;
+      personalItems = result.newItems;
+      written.push(PERSONAL_LEARNINGS_FILE);
+    }
   }
   if (update.skills?.length) {
     for (const skill of update.skills) {
@@ -9166,7 +9590,7 @@ function writeLearnedContent(update) {
       written.push(skillPath);
     }
   }
-  return { written, newItemCount, newItems };
+  return { written, newItemCount, newItems, personalItemCount, personalItems };
 }
 function parseBullets(content) {
   const lines = content.split("\n");
@@ -9207,19 +9631,22 @@ function deduplicateLearnedItems(existing, incoming) {
   const capped = merged.length > MAX_LEARNED_ITEMS ? merged.slice(-MAX_LEARNED_ITEMS) : merged;
   return { merged: capped.join("\n"), newCount: newItems.length, newItems };
 }
-function writeLearnedSection(content) {
-  const existingSection = readLearnedSection();
-  const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
-  fs33.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
+  const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
+  fs35.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs35.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
+function writeLearnedSection(content) {
+  return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
+}
 function writeLearnedSkill(skill) {
-  const skillDir = path25.join(".claude", "skills", skill.name);
-  if (!fs33.existsSync(skillDir)) fs33.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path25.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs33.existsSync(skillPath)) {
-    const existing = fs33.readFileSync(skillPath, "utf-8");
-    fs33.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path27.join(".claude", "skills", skill.name);
+  if (!fs35.existsSync(skillDir)) fs35.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path27.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs35.existsSync(skillPath)) {
+    const existing = fs35.readFileSync(skillPath, "utf-8");
+    fs35.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -9228,37 +9655,47 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs33.writeFileSync(skillPath, frontmatter + skill.content);
+    fs35.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
+function writePersonalLearnedSection(content) {
+  if (!fs35.existsSync(AUTH_DIR)) fs35.mkdirSync(AUTH_DIR, { recursive: true });
+  return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
+}
+function readPersonalLearnings() {
+  if (!fs35.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs35.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
+  return bullets || null;
+}
 function readLearnedSection() {
-  if (fs33.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs33.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs35.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs35.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs33.existsSync(claudeMdPath)) return null;
-  const content = fs33.readFileSync(claudeMdPath, "utf-8");
+  if (!fs35.existsSync(claudeMdPath)) return null;
+  const content = fs35.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
   return content.slice(startIdx + LEARNED_START.length, endIdx).trim() || null;
 }
 function migrateInlineLearnings() {
-  if (fs33.existsSync(LEARNINGS_FILE)) return false;
+  if (fs35.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs33.existsSync(claudeMdPath)) return false;
-  const content = fs33.readFileSync(claudeMdPath, "utf-8");
+  if (!fs35.existsSync(claudeMdPath)) return false;
+  const content = fs35.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return false;
   const section = content.slice(startIdx + LEARNED_START.length, endIdx).trim();
   if (!section) return false;
-  fs33.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs35.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs33.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs35.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -9270,11 +9707,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs35.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs37.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path27.join(parentDir, entry.name);
-      if (fs35.existsSync(path27.join(childPath, ".git"))) {
+      const childPath = path29.join(parentDir, entry.name);
+      if (fs37.existsSync(path29.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -9305,6 +9742,8 @@ async function refreshSingleRepo(repoDir, options) {
     frameworks: fingerprint.frameworks,
     packageName: fingerprint.packageName
   };
+  const workspaces = getDetectedWorkspaces(repoDir);
+  const sources2 = resolveAllSources(repoDir, [], workspaces);
   const response = await refreshDocs(
     {
       committed: diff.committedDiff,
@@ -9315,7 +9754,8 @@ async function refreshSingleRepo(repoDir, options) {
     },
     existingDocs,
     projectContext,
-    learnedSection
+    learnedSection,
+    sources2.length > 0 ? sources2 : void 0
   );
   if (!response.docsUpdated || response.docsUpdated.length === 0) {
     spinner?.succeed(`${prefix}No doc updates needed`);
@@ -9377,7 +9817,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path27.basename(repo);
+      const repoName = path29.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -9398,7 +9838,7 @@ async function refreshCommand(options) {
 
 // src/commands/hooks.ts
 import chalk20 from "chalk";
-import fs36 from "fs";
+import fs38 from "fs";
 var HOOKS = [
   {
     id: "session-end",
@@ -9438,11 +9878,11 @@ async function hooksCommand(options) {
         console.log(chalk20.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
-    if (fs36.existsSync(".claude")) {
+    if (fs38.existsSync(".claude")) {
       const r = installLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Claude Code learning hooks enabled");
     }
-    if (fs36.existsSync(".cursor")) {
+    if (fs38.existsSync(".cursor")) {
       const r = installCursorLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Cursor learning hooks enabled");
     }
@@ -9610,7 +10050,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs40 from "fs";
+import fs42 from "fs";
 import chalk23 from "chalk";
 
 // src/learner/stdin.ts
@@ -9642,8 +10082,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs37 from "fs";
-import path28 from "path";
+import fs39 from "fs";
+import path30 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -9652,48 +10092,48 @@ var DEFAULT_STATE = {
   lastAnalysisEventCount: 0
 };
 function ensureLearningDir() {
-  if (!fs37.existsSync(LEARNING_DIR)) {
-    fs37.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs39.existsSync(LEARNING_DIR)) {
+    fs39.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path28.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path30.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path28.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path30.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
   if (str.length <= MAX_RESPONSE_LENGTH) return response;
   return { _truncated: str.slice(0, MAX_RESPONSE_LENGTH) };
 }
+function trimSessionFileIfNeeded(filePath) {
+  const state = readState2();
+  if (state.eventCount + 1 > LEARNING_MAX_EVENTS) {
+    const lines = fs39.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    if (lines.length > LEARNING_MAX_EVENTS) {
+      const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
+      fs39.writeFileSync(filePath, kept.join("\n") + "\n");
+    }
+  }
+}
 function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs37.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
-  const count = getEventCount();
-  if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs37.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
-    const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs37.writeFileSync(filePath, kept.join("\n") + "\n");
-  }
+  fs39.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  trimSessionFileIfNeeded(filePath);
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs37.appendFileSync(filePath, JSON.stringify(event) + "\n");
-  const count = getEventCount();
-  if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs37.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
-    const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs37.writeFileSync(filePath, kept.join("\n") + "\n");
-  }
+  fs39.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  trimSessionFileIfNeeded(filePath);
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs37.existsSync(filePath)) return [];
-  const lines = fs37.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs39.existsSync(filePath)) return [];
+  const lines = fs39.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -9705,26 +10145,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs37.existsSync(filePath)) return 0;
-  const content = fs37.readFileSync(filePath, "utf-8");
+  if (!fs39.existsSync(filePath)) return 0;
+  const content = fs39.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs37.existsSync(filePath)) fs37.unlinkSync(filePath);
+  if (fs39.existsSync(filePath)) fs39.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs37.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs39.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs37.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs39.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs37.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs39.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -9732,14 +10172,14 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path28.join(LEARNING_DIR, LOCK_FILE2);
+  return path30.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs37.existsSync(lockPath)) {
+  if (fs39.existsSync(lockPath)) {
     try {
-      const stat = fs37.statSync(lockPath);
+      const stat = fs39.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
         return false;
       }
@@ -9747,7 +10187,7 @@ function acquireFinalizeLock() {
     }
   }
   try {
-    fs37.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs39.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -9756,7 +10196,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs37.existsSync(lockPath)) fs37.unlinkSync(lockPath);
+    if (fs39.existsSync(lockPath)) fs39.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -9802,22 +10242,22 @@ function sanitizeSecrets(text) {
 
 // src/lib/notifications.ts
 init_constants();
-import fs38 from "fs";
-import path29 from "path";
+import fs40 from "fs";
+import path31 from "path";
 import chalk22 from "chalk";
-var NOTIFICATION_FILE = path29.join(LEARNING_DIR, "last-finalize-summary.json");
+var NOTIFICATION_FILE = path31.join(LEARNING_DIR, "last-finalize-summary.json");
 function writeFinalizeSummary(summary) {
   try {
     ensureLearningDir();
-    fs38.writeFileSync(NOTIFICATION_FILE, JSON.stringify(summary, null, 2));
+    fs40.writeFileSync(NOTIFICATION_FILE, JSON.stringify(summary, null, 2));
   } catch {
   }
 }
 function checkPendingNotifications() {
   try {
-    if (!fs38.existsSync(NOTIFICATION_FILE)) return;
-    const raw = fs38.readFileSync(NOTIFICATION_FILE, "utf-8");
-    fs38.unlinkSync(NOTIFICATION_FILE);
+    if (!fs40.existsSync(NOTIFICATION_FILE)) return;
+    const raw = fs40.readFileSync(NOTIFICATION_FILE, "utf-8");
+    fs40.unlinkSync(NOTIFICATION_FILE);
     const summary = JSON.parse(raw);
     if (!summary.newItemCount || summary.newItemCount === 0) return;
     const wasteLabel = summary.wasteTokens > 0 ? ` (~${summary.wasteTokens.toLocaleString()} wasted tokens captured)` : "";
@@ -9833,7 +10273,7 @@ function checkPendingNotifications() {
     console.log("");
   } catch {
     try {
-      fs38.unlinkSync(NOTIFICATION_FILE);
+      fs40.unlinkSync(NOTIFICATION_FILE);
     } catch {
     }
   }
@@ -9888,7 +10328,7 @@ function parseAnalysisResponse(raw) {
     return { claudeMdLearnedSection: null, skills: null, explanations: ["LLM response contained invalid JSON."] };
   }
 }
-async function analyzeEvents(events, existingClaudeMd, existingLearnedSection, existingSkills) {
+async function analyzeEvents(events, existingClaudeMd, existingLearnedSection, existingSkills, personalLearnings) {
   const fittedEvents = trimEventsToFit(events, MAX_PROMPT_TOKENS - 1e4);
   const eventsText = formatEventsForPrompt(fittedEvents);
   const contextParts = [];
@@ -9907,6 +10347,11 @@ ${existingLearnedSection}`);
     contextParts.push(`## Existing Skills
 
 ${skillsSummary}`);
+  }
+  if (personalLearnings) {
+    contextParts.push(`## Personal Learnings (developer-specific, do NOT duplicate these)
+
+${personalLearnings}`);
   }
   contextParts.push(`## Task Segmentation & Attribution Instructions
 
@@ -9966,8 +10411,8 @@ init_config();
 
 // src/learner/roi.ts
 init_constants();
-import fs39 from "fs";
-import path30 from "path";
+import fs41 from "fs";
+import path32 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
   totalWasteSeconds: 0,
@@ -9981,22 +10426,28 @@ var DEFAULT_TOTALS = {
   lastSessionTimestamp: ""
 };
 function roiFilePath() {
-  return path30.join(LEARNING_DIR, LEARNING_ROI_FILE);
+  return path32.join(LEARNING_DIR, LEARNING_ROI_FILE);
 }
 function readROIStats() {
   const filePath = roiFilePath();
-  if (!fs39.existsSync(filePath)) {
+  if (!fs41.existsSync(filePath)) {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
   try {
-    return JSON.parse(fs39.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs41.readFileSync(filePath, "utf-8"));
   } catch {
+    try {
+      const corruptPath = filePath + ".corrupt";
+      fs41.renameSync(filePath, corruptPath);
+      console.error(`caliber: roi-stats.json was corrupt \u2014 renamed to ${corruptPath}`);
+    } catch {
+    }
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
 }
 function writeROIStats(stats) {
   ensureLearningDir();
-  fs39.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
+  fs41.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
 }
 function recalculateTotals(stats) {
   const totals = stats.totals;
@@ -10016,8 +10467,24 @@ function recalculateTotals(stats) {
       totals.totalFailuresWithoutLearnings += s.failureCount;
     }
   }
-  totals.estimatedSavingsTokens = totals.totalWasteTokens * totals.totalSessionsWithLearnings;
-  totals.estimatedSavingsSeconds = totals.totalWasteSeconds * totals.totalSessionsWithLearnings;
+  if (totals.totalSessionsWithLearnings >= MIN_SESSIONS_FOR_COMPARISON && totals.totalSessionsWithoutLearnings >= MIN_SESSIONS_FOR_COMPARISON) {
+    const rateWithout = totals.totalFailuresWithoutLearnings / totals.totalSessionsWithoutLearnings;
+    const rateWith = totals.totalFailuresWithLearnings / totals.totalSessionsWithLearnings;
+    if (rateWithout > 0 && rateWith < rateWithout) {
+      const reduction = (rateWithout - rateWith) / rateWithout;
+      const totalSessions = totals.totalSessionsWithLearnings + totals.totalSessionsWithoutLearnings;
+      const avgWastePerSession = totalSessions > 0 ? totals.totalWasteTokens / totalSessions : 0;
+      totals.estimatedSavingsTokens = Math.round(reduction * avgWastePerSession * totals.totalSessionsWithLearnings);
+      const avgWasteSecondsPerSession = totalSessions > 0 ? totals.totalWasteSeconds / totalSessions : 0;
+      totals.estimatedSavingsSeconds = Math.round(reduction * avgWasteSecondsPerSession * totals.totalSessionsWithLearnings);
+    } else {
+      totals.estimatedSavingsTokens = 0;
+      totals.estimatedSavingsSeconds = 0;
+    }
+  } else {
+    totals.estimatedSavingsTokens = 0;
+    totals.estimatedSavingsSeconds = 0;
+  }
   if (stats.sessions.length > 0) {
     totals.firstSessionTimestamp = stats.sessions[0].timestamp;
     totals.lastSessionTimestamp = stats.sessions[stats.sessions.length - 1].timestamp;
@@ -10085,7 +10552,102 @@ function formatROISummary(stats) {
   return lines.join("\n");
 }
 
+// src/learner/attribution.ts
+init_config();
+function normalizeText(text) {
+  return text.replace(/[^a-zA-Z0-9\s]/g, "").replace(/\s+/g, " ").toLowerCase().trim();
+}
+function preNormalizeLearning(summary) {
+  const norm = normalizeText(summary);
+  return { words: norm.split(" ").filter((w) => w.length > 3) };
+}
+function matchesNormalized(learning, normError) {
+  if (learning.words.length === 0 || !normError) return false;
+  const matchCount = learning.words.filter((w) => normError.includes(w)).length;
+  return matchCount / learning.words.length >= 0.6;
+}
+function matchLearningsToFailures(learnings, failureEvents) {
+  if (learnings.length === 0 || failureEvents.length === 0) {
+    return { matchedIndices: [], unmatchedFailures: failureEvents.length };
+  }
+  const normalized = learnings.map((l) => preNormalizeLearning(l.summary));
+  const matchedIndices = /* @__PURE__ */ new Set();
+  let unmatchedFailures = 0;
+  for (const event of failureEvents) {
+    const errorText = typeof event.tool_response === "object" && "_truncated" in event.tool_response ? String(event.tool_response._truncated) : JSON.stringify(event.tool_response);
+    const normError = normalizeText(errorText);
+    let matched = false;
+    for (let i = 0; i < learnings.length; i++) {
+      if (matchesNormalized(normalized[i], normError)) {
+        matchedIndices.add(i);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) unmatchedFailures++;
+  }
+  return { matchedIndices: [...matchedIndices], unmatchedFailures };
+}
+async function semanticMatchFallback(learnings, failureEvents) {
+  if (learnings.length === 0 || failureEvents.length === 0) {
+    return { matchedIndices: [], unmatchedFailures: failureEvents.length };
+  }
+  const learningSummaries = learnings.map((l, i) => `${i}: ${l.summary}`).join("\n");
+  const failureSummaries = failureEvents.slice(0, 10).map((e) => {
+    const errorText = typeof e.tool_response === "object" && "_truncated" in e.tool_response ? String(e.tool_response._truncated).slice(0, 200) : JSON.stringify(e.tool_response).slice(0, 200);
+    return `[${e.tool_name}] ${errorText}`;
+  }).join("\n");
+  const prompt = `Given these existing learnings (numbered):
+${learningSummaries}
+
+And these failure events from a session:
+${failureSummaries}
+
+Which learnings (by index number) are related to or could have prevented these failures?
+Return a JSON object: {"matchedIndices": [0, 2]} or {"matchedIndices": []} if none match.`;
+  try {
+    const fastModel = getFastModel();
+    const raw = await llmCall({
+      system: "You match failure patterns to existing learnings. Return only valid JSON.",
+      prompt,
+      maxTokens: 256,
+      ...fastModel ? { model: fastModel } : {}
+    });
+    const json = extractJson(raw);
+    if (json) {
+      const parsed = JSON.parse(json);
+      const indices = (parsed.matchedIndices || []).filter((i) => typeof i === "number" && i >= 0 && i < learnings.length);
+      return { matchedIndices: indices, unmatchedFailures: failureEvents.length - indices.length };
+    }
+  } catch {
+  }
+  return { matchedIndices: [], unmatchedFailures: failureEvents.length };
+}
+function updateActivations(stats, matchedIndices) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const idx of matchedIndices) {
+    if (idx < stats.learnings.length) {
+      stats.learnings[idx].activationCount = (stats.learnings[idx].activationCount ?? 0) + 1;
+      stats.learnings[idx].lastActivationTimestamp = now;
+    }
+  }
+}
+var DEFAULT_MIN_SESSIONS = 10;
+function findStaleLearnings(stats, minSessions = DEFAULT_MIN_SESSIONS) {
+  if (stats.sessions.length < minSessions) return [];
+  return stats.learnings.filter((l) => {
+    const activations = l.activationCount ?? 0;
+    if (activations > 0) return false;
+    const createdAt = new Date(l.timestamp).getTime();
+    const sessionsAfterCreation = stats.sessions.filter(
+      (s) => new Date(s.timestamp).getTime() > createdAt
+    ).length;
+    return sessionsAfterCreation >= minSessions;
+  });
+}
+
 // src/commands/learn.ts
+init_constants();
 var MIN_EVENTS_FOR_ANALYSIS = 25;
 var MIN_EVENTS_AUTO = 10;
 var AUTO_SETTLE_MS = 200;
@@ -10169,25 +10731,34 @@ async function learnFinalizeCommand(options) {
       resetState();
       return;
     }
-    const events = readAllEvents();
+    const allEvents = readAllEvents();
     const threshold = isAuto ? MIN_EVENTS_AUTO : MIN_EVENTS_FOR_ANALYSIS;
-    if (events.length < threshold) {
-      if (!isAuto) console.log(chalk23.dim(`caliber: ${events.length}/${threshold} events recorded \u2014 need more before analysis`));
+    if (allEvents.length < threshold) {
+      if (!isAuto) console.log(chalk23.dim(`caliber: ${allEvents.length}/${threshold} events recorded \u2014 need more before analysis`));
       return;
     }
     await validateModel({ fast: true });
     migrateInlineLearnings();
+    const state = readState2();
+    const analysisOffset = isIncremental ? state.lastAnalysisEventCount || 0 : 0;
+    const events = analysisOffset > 0 ? allEvents.slice(analysisOffset) : allEvents;
+    if (events.length < threshold) {
+      if (!isAuto) console.log(chalk23.dim(`caliber: ${events.length}/${threshold} new events since last analysis \u2014 need more`));
+      return;
+    }
     const existingConfigs = readExistingConfigs(process.cwd());
     const existingLearnedSection = readLearnedSection();
+    const existingPersonalLearnings = readPersonalLearnings();
     const existingSkills = existingConfigs.claudeSkills || [];
     const response = await analyzeEvents(
       events,
       existingConfigs.claudeMd || "",
       existingLearnedSection,
-      existingSkills
+      existingSkills,
+      existingPersonalLearnings
     );
     analyzed = true;
-    const waste = calculateSessionWaste(events);
+    const waste = calculateSessionWaste(allEvents);
     const existingLearnedItems = existingLearnedSection ? existingLearnedSection.split("\n").filter((l) => l.startsWith("- ")).length : 0;
     const hadLearnings = existingLearnedItems > 0;
     let newLearningsProduced = 0;
@@ -10215,7 +10786,8 @@ async function learnFinalizeCommand(options) {
         }
         const wastePerLearning = Math.round(waste.totalWasteTokens / result.newItemCount);
         const TYPE_RE = /^\*\*\[([^\]]+)\]\*\*/;
-        const learningEntries = result.newItems.map((item) => {
+        const explanations = response.explanations || [];
+        const learningEntries = result.newItems.map((item, idx) => {
           const clean = item.replace(/^- /, "");
           const typeMatch = clean.match(TYPE_RE);
           return {
@@ -10223,7 +10795,8 @@ async function learnFinalizeCommand(options) {
             observationType: typeMatch ? typeMatch[1] : "unknown",
             summary: clean.replace(TYPE_RE, "").trim().slice(0, 80),
             wasteTokens: wastePerLearning,
-            sourceEventCount: events.length
+            sourceEventCount: events.length,
+            explanation: explanations[idx] || null
           };
         });
         for (const entry of learningEntries) {
@@ -10247,8 +10820,8 @@ async function learnFinalizeCommand(options) {
     }
     const sessionSummary = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionId: readState2().sessionId || "unknown",
-      eventCount: events.length,
+      sessionId: state.sessionId || "unknown",
+      eventCount: allEvents.length,
       failureCount: waste.failureCount,
       promptCount: waste.promptCount,
       wasteSeconds: Math.round(waste.totalWasteSeconds),
@@ -10261,8 +10834,21 @@ async function learnFinalizeCommand(options) {
       taskFailureCount: tasks.length > 0 ? taskFailureCount : void 0
     };
     const roiStats = recordSession(sessionSummary, roiLearningEntries);
+    if (roiStats.learnings.length > 0 && waste.failureCount > 0) {
+      const failureEvents = allEvents.filter(
+        (e) => e.hook_event_name === "PostToolUseFailure"
+      );
+      let attribution = matchLearningsToFailures(roiStats.learnings, failureEvents);
+      if (attribution.matchedIndices.length === 0 && failureEvents.length > 0) {
+        attribution = await semanticMatchFallback(roiStats.learnings, failureEvents);
+      }
+      if (attribution.matchedIndices.length > 0) {
+        updateActivations(roiStats, attribution.matchedIndices);
+        writeROIStats(roiStats);
+      }
+    }
     trackLearnSessionAnalyzed({
-      eventCount: events.length,
+      eventCount: allEvents.length,
       failureCount: waste.failureCount,
       correctionCount: waste.promptCount,
       hadLearningsAvailable: hadLearnings,
@@ -10285,6 +10871,12 @@ async function learnFinalizeCommand(options) {
       estimatedSavingsSeconds: t.estimatedSavingsSeconds,
       learningCount: roiStats.learnings.length
     });
+    if (!isIncremental) {
+      const staleLearnings = findStaleLearnings(roiStats);
+      if (staleLearnings.length > 0 && !isAuto) {
+        console.log(chalk23.yellow(`caliber: ${staleLearnings.length} learning${staleLearnings.length === 1 ? "" : "s"} never activated \u2014 run \`caliber learn list --verbose\` to review`));
+      }
+    }
     if (!isAuto && t.estimatedSavingsTokens > 0) {
       const totalLearnings = existingLearnedItems + newLearningsProduced;
       console.log(chalk23.dim(`caliber: ${totalLearnings} learnings active \u2014 est. ~${t.estimatedSavingsTokens.toLocaleString()} tokens saved across ${t.totalSessionsWithLearnings} sessions`));
@@ -10310,7 +10902,7 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs40.existsSync(".claude")) {
+  if (fs42.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Claude Code learning hooks installed");
@@ -10319,7 +10911,7 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs40.existsSync(".cursor")) {
+  if (fs42.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Cursor learning hooks installed");
@@ -10328,7 +10920,7 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs40.existsSync(".claude") && !fs40.existsSync(".cursor")) {
+  if (!fs42.existsSync(".claude") && !fs42.existsSync(".cursor")) {
     console.log(chalk23.yellow("No .claude/ or .cursor/ directory found."));
     console.log(chalk23.dim("  Run `caliber init` first, or create the directory manually."));
     return;
@@ -10398,16 +10990,116 @@ Learned items in CALIBER_LEARNINGS.md: ${chalk23.cyan(String(lineCount))}`);
     }
   }
 }
+function getAllLearnings() {
+  const items = [];
+  let idx = 0;
+  const projectSection = readLearnedSection();
+  if (projectSection) {
+    for (const line of projectSection.split("\n").filter((l) => l.startsWith("- "))) {
+      items.push({ text: line, source: "project", index: idx++ });
+    }
+  }
+  const personalSection = readPersonalLearnings();
+  if (personalSection) {
+    for (const line of personalSection.split("\n").filter((l) => l.startsWith("- "))) {
+      items.push({ text: line, source: "personal", index: idx++ });
+    }
+  }
+  return items;
+}
+async function learnListCommand(options) {
+  const items = getAllLearnings();
+  if (items.length === 0) {
+    console.log(chalk23.dim("No learnings yet. Run `caliber learn install` to start."));
+    return;
+  }
+  const roiStats = options?.verbose ? readROIStats() : null;
+  console.log(chalk23.bold(`
+  Learnings (${items.length})
+`));
+  for (const item of items) {
+    const tag = item.source === "personal" ? chalk23.magenta("[personal]") : chalk23.blue("[project]");
+    const display = item.text.replace(/^- /, "").slice(0, 100);
+    console.log(`  ${chalk23.dim(String(item.index + 1).padStart(2, " "))}. ${tag} ${display}`);
+    if (options?.verbose && roiStats) {
+      const match = roiStats.learnings.find((l) => display.includes(l.summary.slice(0, 40)));
+      if (match) {
+        const activations = match.activationCount ?? 0;
+        const stale = activations === 0 && roiStats.sessions.length >= 10;
+        const activationLabel = stale ? chalk23.yellow(`${activations} activations [stale]`) : chalk23.dim(`${activations} activation${activations === 1 ? "" : "s"}`);
+        console.log(`      ${activationLabel}`);
+        if (match.explanation) {
+          console.log(`      ${chalk23.dim("Why: " + match.explanation.slice(0, 80))}`);
+        }
+      }
+    }
+  }
+  console.log("");
+}
+async function learnDeleteCommand(indexStr) {
+  const index = parseInt(indexStr, 10);
+  if (isNaN(index) || index < 1) {
+    console.log(chalk23.red(`Invalid index: "${indexStr}". Use a number from \`caliber learn list\`.`));
+    return;
+  }
+  const items = getAllLearnings();
+  const targetIdx = index - 1;
+  if (targetIdx >= items.length) {
+    console.log(chalk23.red(`Index ${index} is out of range. You have ${items.length} learnings.`));
+    return;
+  }
+  const item = items[targetIdx];
+  const filePath = item.source === "personal" ? PERSONAL_LEARNINGS_FILE : "CALIBER_LEARNINGS.md";
+  if (!fs42.existsSync(filePath)) {
+    console.log(chalk23.red("Learnings file not found."));
+    return;
+  }
+  const content = fs42.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const bulletsOfSource = items.filter((i) => i.source === item.source);
+  const posInFile = bulletsOfSource.indexOf(item);
+  let bulletsSeen = 0;
+  let lineToRemove = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].startsWith("- ")) {
+      if (bulletsSeen === posInFile) {
+        lineToRemove = i;
+        break;
+      }
+      bulletsSeen++;
+    }
+  }
+  if (lineToRemove === -1) {
+    console.log(chalk23.red("Could not locate learning in file."));
+    return;
+  }
+  const bulletToRemove = lines[lineToRemove];
+  const newLines = lines.filter((_, i) => i !== lineToRemove);
+  fs42.writeFileSync(filePath, newLines.join("\n"));
+  if (item.source === "personal") {
+    fs42.chmodSync(filePath, 384);
+  }
+  const roiStats = readROIStats();
+  const cleanText = bulletToRemove.replace(/^- /, "").replace(/^\*\*\[[^\]]+\]\*\*\s*/, "").trim();
+  const roiIdx = roiStats.learnings.findIndex((l) => cleanText.includes(l.summary.slice(0, 30)));
+  if (roiIdx !== -1) {
+    roiStats.learnings.splice(roiIdx, 1);
+    writeROIStats(roiStats);
+  }
+  console.log(chalk23.green("\u2713") + ` Removed: ${bulletToRemove.replace(/^- /, "").slice(0, 80)}`);
+}
 
 // src/commands/insights.ts
 import chalk24 from "chalk";
+init_constants();
 var MIN_SESSIONS_FULL = 20;
 function buildInsightsData(stats) {
   const t = stats.totals;
   const totalSessions = t.totalSessionsWithLearnings + t.totalSessionsWithoutLearnings;
   const failureRateWith = t.totalSessionsWithLearnings > 0 ? t.totalFailuresWithLearnings / t.totalSessionsWithLearnings : null;
   const failureRateWithout = t.totalSessionsWithoutLearnings > 0 ? t.totalFailuresWithoutLearnings / t.totalSessionsWithoutLearnings : null;
-  const failureRateImprovement = failureRateWith !== null && failureRateWithout !== null && failureRateWithout > 0 ? Math.round((1 - failureRateWith / failureRateWithout) * 100) : null;
+  const hasSufficientCohorts = t.totalSessionsWithLearnings >= MIN_SESSIONS_FOR_COMPARISON && t.totalSessionsWithoutLearnings >= MIN_SESSIONS_FOR_COMPARISON;
+  const failureRateImprovement = hasSufficientCohorts && failureRateWith !== null && failureRateWithout !== null && failureRateWithout > 0 ? Math.round((1 - failureRateWith / failureRateWithout) * 100) : null;
   let taskCount = 0;
   let taskSuccessCount = 0;
   let taskCorrectionCount = 0;
@@ -10462,6 +11154,8 @@ function displayEarlyData(data, score) {
   }
   if (data.failureRateImprovement !== null && data.failureRateImprovement > 0) {
     console.log(`  Failure rate trend:     ${chalk24.green(`${data.failureRateImprovement}% fewer`)} failures with learnings ${chalk24.dim("(early signal)")}`);
+  } else if (data.totalSessions > 0 && data.failureRateImprovement === null) {
+    console.log(`  Failure rate trend:     ${chalk24.dim("collecting data (need 3+ sessions in each group)")}`);
   }
   if (data.taskSuccessRate !== null) {
     console.log(`  Task success rate:      ${chalk24.cyan(`${data.taskSuccessRate}%`)} ${chalk24.dim(`(${data.taskCount} tasks)`)}`);
@@ -10486,6 +11180,8 @@ function displayFullInsights(data, score) {
     console.log(`    Failure rate:         ${chalk24.red(data.failureRateWithout.toFixed(1))}/session ${chalk24.dim("\u2192")} ${chalk24.green(data.failureRateWith.toFixed(1))}/session with learnings`);
     if (data.failureRateImprovement !== null && data.failureRateImprovement > 0) {
       console.log(`    Improvement:          ${chalk24.green(`${data.failureRateImprovement}%`)} fewer failures`);
+    } else if (data.failureRateImprovement === null) {
+      console.log(`    Improvement:          ${chalk24.dim("collecting data (need 3+ sessions in each group)")}`);
     }
   }
   if (data.totalWasteTokens > 0 || data.estimatedSavingsTokens > 0) {
@@ -10527,10 +11223,173 @@ async function insightsCommand(options) {
   }
 }
 
+// src/commands/sources.ts
+import fs43 from "fs";
+import path33 from "path";
+import chalk25 from "chalk";
+async function sourcesListCommand() {
+  const dir = process.cwd();
+  const configSources = loadSourcesConfig(dir);
+  const workspaces = getDetectedWorkspaces(dir);
+  if (configSources.length === 0 && workspaces.length === 0) {
+    console.log(chalk25.dim("\n  No sources configured.\n"));
+    console.log(chalk25.dim("  Add a source: ") + chalk25.hex("#83D1EB")("caliber sources add <path>"));
+    console.log(chalk25.dim("  Or add to .caliber/sources.json manually.\n"));
+    return;
+  }
+  console.log(chalk25.bold("\n  External Sources\n"));
+  if (configSources.length > 0) {
+    for (const source of configSources) {
+      const sourcePath = source.path || source.url || "";
+      const exists = source.path ? fs43.existsSync(path33.resolve(dir, source.path)) : false;
+      const status = exists ? chalk25.green("reachable") : chalk25.red("not found");
+      const hasSummary = source.path && fs43.existsSync(path33.join(path33.resolve(dir, source.path), ".caliber", "summary.json"));
+      console.log(`  ${chalk25.bold(source.role || source.type)}  ${chalk25.dim(sourcePath)}`);
+      console.log(`    Type: ${source.type}  Status: ${status}${hasSummary ? "  " + chalk25.cyan("has summary.json") : ""}`);
+      if (source.description) console.log(`    ${chalk25.dim(source.description)}`);
+      console.log("");
+    }
+  }
+  if (workspaces.length > 0) {
+    console.log(chalk25.dim("  Auto-detected workspaces:"));
+    for (const ws of workspaces) {
+      const exists = fs43.existsSync(path33.resolve(dir, ws));
+      console.log(`    ${exists ? chalk25.green("\u25CF") : chalk25.red("\u25CF")} ${ws}`);
+    }
+    console.log("");
+  }
+}
+async function sourcesAddCommand(sourcePath) {
+  const dir = process.cwd();
+  const absPath = path33.resolve(dir, sourcePath);
+  if (!fs43.existsSync(absPath)) {
+    console.log(chalk25.red(`
+  Path not found: ${sourcePath}
+`));
+    throw new Error("__exit__");
+  }
+  const type = detectSourceType(absPath);
+  if (isInsideDir(absPath, dir)) {
+    console.log(chalk25.red(`
+  Cannot add a path inside the current project as a source.
+`));
+    throw new Error("__exit__");
+  }
+  const existing = loadSourcesConfig(dir);
+  const alreadyConfigured = existing.some(
+    (s) => s.path && path33.resolve(dir, s.path) === absPath
+  );
+  if (alreadyConfigured) {
+    console.log(chalk25.yellow(`
+  Already configured: ${sourcePath}
+`));
+    return;
+  }
+  const defaultRole = type === "repo" ? "related-repo" : "reference-doc";
+  const roleInput = await promptInput(`Role (e.g., shared-library, deployment) [${defaultRole}]:`);
+  const role = roleInput || defaultRole;
+  const description = await promptInput("Brief description (optional):");
+  const newSource = {
+    type,
+    path: sourcePath,
+    role,
+    ...description ? { description } : {}
+  };
+  existing.push(newSource);
+  writeSourcesConfig(dir, existing);
+  console.log(chalk25.green(`
+  \u2713 Added ${sourcePath} as ${type} source (${role})
+`));
+}
+async function sourcesRemoveCommand(name) {
+  const dir = process.cwd();
+  const existing = loadSourcesConfig(dir);
+  const idx = existing.findIndex(
+    (s) => s.path?.includes(name) || s.role === name
+  );
+  if (idx === -1) {
+    console.log(chalk25.red(`
+  Source not found: ${name}
+`));
+    console.log(chalk25.dim("  Available sources:"));
+    for (const s of existing) {
+      console.log(chalk25.dim(`    ${s.path || s.url} (${s.role || s.type})`));
+    }
+    throw new Error("__exit__");
+  }
+  const removed = existing.splice(idx, 1)[0];
+  writeSourcesConfig(dir, existing);
+  console.log(chalk25.green(`
+  \u2713 Removed ${removed.path || removed.url} (${removed.role || removed.type})
+`));
+}
+
+// src/commands/publish.ts
+import fs44 from "fs";
+import path34 from "path";
+import chalk26 from "chalk";
+import ora7 from "ora";
+init_config();
+async function publishCommand() {
+  const dir = process.cwd();
+  const config = loadConfig();
+  if (!config) {
+    console.log(chalk26.red("No LLM provider configured. Run ") + chalk26.hex("#83D1EB")("caliber config") + chalk26.red(" first."));
+    throw new Error("__exit__");
+  }
+  const spinner = ora7("Generating project summary...").start();
+  try {
+    const fingerprint = await collectFingerprint(dir);
+    const claudeMd = readFileOrNull(path34.join(dir, "CLAUDE.md"));
+    const topLevelDirs = fingerprint.fileTree.filter((f) => f.endsWith("/") && !f.includes("/")).map((f) => f.replace(/\/$/, ""));
+    const summary = {
+      name: fingerprint.packageName || path34.basename(dir),
+      version: "1.0.0",
+      description: fingerprint.description || "",
+      languages: fingerprint.languages,
+      frameworks: fingerprint.frameworks,
+      tools: fingerprint.tools,
+      topLevelDirs
+    };
+    if (claudeMd) {
+      summary.conventions = claudeMd.slice(0, 2e3);
+    }
+    try {
+      const pkgContent = readFileOrNull(path34.join(dir, "package.json"));
+      if (pkgContent) {
+        const pkg3 = JSON.parse(pkgContent);
+        if (pkg3.scripts) {
+          const commands = {};
+          for (const key of ["test", "build", "dev", "lint", "start"]) {
+            if (pkg3.scripts[key]) commands[key] = `npm run ${key}`;
+          }
+          if (Object.keys(commands).length > 0) summary.commands = commands;
+        }
+      }
+    } catch {
+    }
+    const outputDir = path34.join(dir, ".caliber");
+    if (!fs44.existsSync(outputDir)) {
+      fs44.mkdirSync(outputDir, { recursive: true });
+    }
+    const outputPath = path34.join(outputDir, "summary.json");
+    fs44.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+    spinner.succeed("Project summary published");
+    console.log(`  ${chalk26.green("\u2713")} ${path34.relative(dir, outputPath)}`);
+    console.log(chalk26.dim("\n  Other projects can now reference this repo as a source."));
+    console.log(chalk26.dim("  When they run `caliber init`, they'll read this summary automatically.\n"));
+  } catch (err) {
+    spinner.fail("Failed to generate summary");
+    if (err instanceof Error && err.message === "__exit__") throw err;
+    console.error(chalk26.red(err instanceof Error ? err.message : "Unknown error"));
+    throw new Error("__exit__");
+  }
+}
+
 // src/cli.ts
-var __dirname = path31.dirname(fileURLToPath(import.meta.url));
+var __dirname = path35.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs41.readFileSync(path31.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs45.readFileSync(path35.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -10582,43 +11441,50 @@ program.hook("preAction", (thisCommand) => {
 });
 function parseAgentOption(value) {
   if (value === "both") return ["claude", "cursor"];
-  if (value === "all") return ["claude", "cursor", "codex"];
-  const valid = ["claude", "cursor", "codex"];
+  if (value === "all") return ["claude", "cursor", "codex", "github-copilot"];
+  const valid = ["claude", "cursor", "codex", "github-copilot"];
   const agents = [...new Set(value.split(",").map((s) => s.trim().toLowerCase()).filter((a) => valid.includes(a)))];
   if (agents.length === 0) {
-    console.error(`Invalid agent "${value}". Choose from: claude, cursor, codex (comma-separated for multiple)`);
+    console.error(`Invalid agent "${value}". Choose from: claude, cursor, codex, github-copilot (comma-separated for multiple)`);
     process.exit(1);
   }
   return agents;
 }
-program.command("init").description("Initialize your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").option("--debug-report", void 0, false).option("--show-tokens", "Show token usage summary at the end").option("--auto-approve", "Run without interactive prompts (auto-accept all)").option("--verbose", "Show detailed logs of each step").action(tracked("init", initCommand));
+program.command("init").description("Initialize your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex, github-copilot", parseAgentOption).option("--source <paths...>", "Related source paths to include as context").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").option("--debug-report", void 0, false).option("--show-tokens", "Show token usage summary at the end").option("--auto-approve", "Run without interactive prompts (auto-accept all)").option("--verbose", "Show detailed logs of each step").action(tracked("init", initCommand));
 program.command("undo").description("Revert all config changes made by Caliber").action(tracked("undo", undoCommand));
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(tracked("status", statusCommand));
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));
 program.command("config").description("Configure LLM provider, API key, and model").action(tracked("config", configCommand));
 program.command("skills").description("Discover and install community skills for your project").action(tracked("skills", recommendCommand));
-program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--compare <ref>", "Compare score against a git ref (branch, tag, or SHA)").action(tracked("score", scoreCommand));
+program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex, github-copilot", parseAgentOption).option("--compare <ref>", "Compare score against a git ref (branch, tag, or SHA)").action(tracked("score", scoreCommand));
 program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(tracked("refresh", refreshCommand));
 program.command("hooks").description("Manage auto-refresh hooks (toggle interactively)").option("--install", "Enable all hooks non-interactively").option("--remove", "Disable all hooks non-interactively").action(tracked("hooks", hooksCommand));
 program.command("insights").description("Show agent performance insights and learning impact").option("--json", "Output as JSON").action(tracked("insights", insightsCommand));
+var sources = program.command("sources").description("Manage external context sources (related repos, docs)");
+sources.command("list").description("Show configured and auto-detected sources").action(tracked("sources:list", sourcesListCommand));
+sources.command("add").description("Add an external source").argument("<path>", "Path to repo directory or file").action(tracked("sources:add", sourcesAddCommand));
+sources.command("remove").description("Remove a configured source").argument("<name>", "Source path or role to remove").action(tracked("sources:remove", sourcesRemoveCommand));
+program.command("publish").description("Generate a machine-readable summary for other repos to consume").action(tracked("publish", publishCommand));
 var learn = program.command("learn", { hidden: true }).description("[dev] Session learning \u2014 observe tool usage and extract reusable instructions");
 learn.command("observe").description("Record a tool event from stdin (called by hooks)").option("--failure", "Mark event as a tool failure").option("--prompt", "Record a user prompt event").action(tracked("learn:observe", learnObserveCommand));
 learn.command("finalize").description("Analyze session events and update CALIBER_LEARNINGS.md (called on SessionEnd)").option("--force", "Skip the running-process check (for manual invocation)").option("--auto", "Silent mode for hooks (lower threshold, no interactive output)").option("--incremental", "Extract learnings mid-session without clearing events").action(tracked("learn:finalize", (opts) => learnFinalizeCommand(opts)));
 learn.command("install").description("Install learning hooks into .claude/settings.json").action(tracked("learn:install", learnInstallCommand));
 learn.command("remove").description("Remove learning hooks from .claude/settings.json").action(tracked("learn:remove", learnRemoveCommand));
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
+learn.command("list").description("List all learnings with their source and activation data").option("--verbose", "Show explanations and activation counts").action(tracked("learn:list", (opts) => learnListCommand(opts)));
+learn.command("delete <index>").description("Delete a learning by its index number (from `caliber learn list`)").action(tracked("learn:delete", (index) => learnDeleteCommand(index)));
 
 // src/utils/version-check.ts
-import fs42 from "fs";
-import path32 from "path";
+import fs46 from "fs";
+import path36 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync15 } from "child_process";
-import chalk25 from "chalk";
-import ora7 from "ora";
+import chalk27 from "chalk";
+import ora8 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path32.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path36.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs42.readFileSync(path32.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs46.readFileSync(path36.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
@@ -10643,8 +11509,8 @@ function isNewer(registry, current) {
 function getInstalledVersion() {
   try {
     const globalRoot = execSync15("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path32.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs42.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path36.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs46.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -10669,17 +11535,17 @@ async function checkForUpdates() {
     if (!isInteractive) {
       const installTag = channel === "latest" ? "" : `@${channel}`;
       console.log(
-        chalk25.yellow(
+        chalk27.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk25.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
+Run ${chalk27.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk25.yellow(`
+      chalk27.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
@@ -10688,7 +11554,7 @@ Update available: ${current} -> ${latest}`)
       return;
     }
     const tag = channel === "latest" ? latest : channel;
-    const spinner = ora7("Updating caliber...").start();
+    const spinner = ora8("Updating caliber...").start();
     try {
       execSync15(`npm install -g @rely-ai/caliber@${tag}`, {
         stdio: "pipe",
@@ -10698,13 +11564,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk25.yellow(`Run ${chalk25.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
+        console.log(chalk27.yellow(`Run ${chalk27.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk25.green(`Updated to ${latest}`));
+      spinner.succeed(chalk27.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk25.dim(`
+      console.log(chalk27.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync15(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -10717,11 +11583,11 @@ Restarting: caliber ${args.join(" ")}
       if (err instanceof Error) {
         const stderr = err.stderr;
         const errMsg = stderr ? String(stderr).trim().split("\n").pop() : err.message.split("\n")[0];
-        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk25.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk27.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk25.yellow(
-          `Run ${chalk25.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
+        chalk27.yellow(
+          `Run ${chalk27.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
 `
         )
       );