squads-cli 0.4.10 → 0.4.11

package/dist/cli.js

@@ -43,8 +43,8 @@ import {
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync18 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join22 } from "path";
 import { homedir as homedir4 } from "os";
 import { Command } from "commander";
 import chalk4 from "chalk";
@@ -534,9 +534,18 @@ var Events = {
   CLI_FEEDBACK_ADD: "cli.feedback.add",
   CLI_FEEDBACK_SHOW: "cli.feedback.show",
   CLI_FEEDBACK_STATS: "cli.feedback.stats",
+  // Learnings
+  CLI_LEARN: "cli.learn",
+  CLI_LEARN_SHOW: "cli.learn.show",
+  CLI_LEARN_SEARCH: "cli.learn.search",
   // Auth
   CLI_LOGIN: "cli.login",
-  CLI_LOGOUT: "cli.logout"
+  CLI_LOGOUT: "cli.logout",
+  // Context Condenser
+  CONDENSER_COMPRESS: "condenser.compress",
+  CONDENSER_DEDUPE: "condenser.dedupe",
+  CONDENSER_PRUNE: "condenser.prune",
+  CONDENSER_SUMMARIZE: "condenser.summarize"
 };
 var exitHandlerRegistered = false;
 function registerExitHandler() {
@@ -884,10 +893,13 @@ async function initCommand(options) {
       ".agents/squads/demo",
       ".agents/memory",
       ".agents/memory/getting-started",
+      ".agents/memory/general/shared",
+      // For cross-squad learnings
       ".agents/outputs",
       ".claude",
       ".claude/skills",
-      ".claude/skills/squads-workflow"
+      ".claude/skills/squads-workflow",
+      ".claude/skills/squads-learn"
     ];
     for (const dir of dirs) {
       await fs.mkdir(path.join(cwd, dir), { recursive: true });
@@ -1063,6 +1075,56 @@ When a task could be automated:
       path.join(cwd, ".claude/skills/squads-workflow/instruction.md"),
       squadsWorkflowSkill
     );
+    const squadsLearnSkill = `---
+name: squads-learn
+description: Capture learnings after completing work. Use when finishing a task, fixing a bug, discovering a pattern, or learning something worth remembering for future sessions.
+---
+
+# Capture Learnings
+
+After completing work, capture what you learned so future sessions can benefit.
+
+## When to Use
+
+- After fixing a bug - What was the root cause?
+- After completing a feature - What approach worked?
+- After research - What's the key insight?
+- When you notice a pattern - Something that works consistently
+
+## Quick Commands
+
+\`\`\`bash
+# Capture a learning
+squads learn "The auth token needs refresh after 1 hour, not on 401"
+
+# With squad and category
+squads learn "Always check memory first" --squad engineering --category pattern
+
+# View learnings
+squads learnings show engineering
+squads learnings search "auth"
+\`\`\`
+
+## Categories
+
+- \`success\` - Something that worked well
+- \`failure\` - Something that didn't work (learn from mistakes)
+- \`pattern\` - A reusable approach
+- \`tip\` - General advice
+
+## End of Task Checklist
+
+Before marking done, ask:
+1. What worked that I should remember?
+2. What didn't work that I should avoid?
+3. Is there a pattern worth capturing?
+
+If yes \u2192 \`squads learn "<insight>"\`
+`;
+    await fs.writeFile(
+      path.join(cwd, ".claude/skills/squads-learn/SKILL.md"),
+      squadsLearnSkill
+    );
     const seedMemory = `# Getting Started with Squads
 
 ## What You've Set Up
@@ -1139,7 +1201,7 @@ When a task could be automated:
             hooks: [
               {
                 type: "command",
-                command: "squads memory sync",
+                command: 'squads memory sync && echo "\\n\u{1F4A1} Capture learnings: squads learn \\"<what you learned>\\"\\n"',
                 timeout: 15
               }
             ]
@@ -1303,9 +1365,9 @@ squads goal list       # View goals
   console.log(chalk.dim("  Created:"));
   console.log(chalk.dim("  \u2022 .agents/squads/demo/     - Demo squad with 2 agents"));
   console.log(chalk.dim("  \u2022 .agents/BUSINESS_BRIEF   - Business context template"));
-  console.log(chalk.dim("  \u2022 .agents/memory/          - Seed memory"));
+  console.log(chalk.dim("  \u2022 .agents/memory/          - Seed memory + learnings"));
   console.log(chalk.dim("  \u2022 .claude/settings.json    - Claude Code hooks"));
-  console.log(chalk.dim("  \u2022 .claude/skills/          - Squads workflow skill"));
+  console.log(chalk.dim("  \u2022 .claude/skills/          - Workflow + learn skills"));
   console.log(chalk.dim("  \u2022 CLAUDE.md                - Agent instructions"));
   console.log();
   const email = await promptEmail();
@@ -1331,21 +1393,185 @@ squads goal list       # View goals
 // src/commands/run.ts
 import ora2 from "ora";
 import { spawn as spawn2 } from "child_process";
-import { join as join4, dirname } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 
 // src/lib/squad-parser.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, basename } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4, basename } from "path";
 import matter from "gray-matter";
+
+// src/lib/mcp-config.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname } from "path";
+var SERVER_REGISTRY = {
+  // Browser/Web tools
+  "chrome-devtools": {
+    type: "stdio",
+    command: "npx",
+    args: ["chrome-devtools-mcp", "--isolated", "--headless"],
+    env: {}
+  },
+  "nano-banana": {
+    type: "stdio",
+    command: "npx",
+    args: ["nano-banana-mcp"],
+    env: {}
+  },
+  "firecrawl": {
+    type: "stdio",
+    command: "npx",
+    args: ["firecrawl-mcp"],
+    env: {
+      FIRECRAWL_API_KEY: "${FIRECRAWL_API_KEY}"
+    }
+  },
+  // Data tools
+  "supabase": {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@supabase/mcp-server-supabase@latest", "--read-only"],
+    env: {
+      SUPABASE_ACCESS_TOKEN: "${SUPABASE_ACCESS_TOKEN}"
+    }
+  },
+  "grafana": {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@leval/mcp-grafana"],
+    env: {
+      GRAFANA_URL: "${GRAFANA_URL}",
+      GRAFANA_SERVICE_ACCOUNT_TOKEN: "${GRAFANA_SERVICE_ACCOUNT_TOKEN}"
+    }
+  },
+  // AI/ML tools
+  "huggingface": {
+    type: "stdio",
+    command: "npx",
+    args: ["huggingface-mcp"],
+    env: {
+      HF_TOKEN: "${HF_TOKEN}"
+    }
+  },
+  "context7": {
+    type: "stdio",
+    command: "npx",
+    args: ["context7-mcp"],
+    env: {}
+  },
+  // Social/Research tools
+  "x-mcp": {
+    type: "stdio",
+    command: "python3",
+    args: ["~/.claude/mcps/x-mcp/server.py"],
+    env: {
+      X_BEARER_TOKEN: "${X_BEARER_TOKEN}"
+    }
+  },
+  // Telemetry
+  "langfuse-telemetry": {
+    type: "stdio",
+    command: "python3",
+    args: ["~/.claude/mcps/langfuse-telemetry/server.py"],
+    env: {
+      LANGFUSE_HOST: "${LANGFUSE_HOST}",
+      LANGFUSE_PUBLIC_KEY: "${LANGFUSE_PUBLIC_KEY}",
+      LANGFUSE_SECRET_KEY: "${LANGFUSE_SECRET_KEY}"
+    }
+  },
+  // Analytics
+  "ga4-admin": {
+    type: "stdio",
+    command: "python3",
+    args: ["-m", "mcp_ga4.server"],
+    env: {}
+  }
+};
+function getHome() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+function getContextsDir() {
+  return join3(getHome(), ".claude", "contexts");
+}
+function getMcpConfigsDir() {
+  return join3(getHome(), ".claude", "mcp-configs");
+}
+function generateMcpConfig(mcpServers) {
+  const config2 = { mcpServers: {} };
+  for (const server of mcpServers) {
+    const def = SERVER_REGISTRY[server];
+    if (def) {
+      config2.mcpServers[server] = def;
+    }
+  }
+  return config2;
+}
+function writeMcpConfig(config2, path3) {
+  const dir = dirname(path3);
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(path3, JSON.stringify(config2, null, 2));
+}
+function readMcpConfig(path3) {
+  if (!existsSync3(path3)) return null;
+  try {
+    const content = readFileSync2(path3, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function resolveMcpConfig(squadName, mcpServers, forceRegenerate = false) {
+  const home = getHome();
+  const userOverride = join3(getMcpConfigsDir(), `${squadName}.json`);
+  if (existsSync3(userOverride)) {
+    const config2 = readMcpConfig(userOverride);
+    return {
+      path: userOverride,
+      source: "user-override",
+      servers: config2 ? Object.keys(config2.mcpServers) : void 0
+    };
+  }
+  if (mcpServers && mcpServers.length > 0) {
+    const generatedPath = join3(getContextsDir(), `${squadName}.mcp.json`);
+    const shouldGenerate = forceRegenerate || !existsSync3(generatedPath);
+    if (shouldGenerate) {
+      const config3 = generateMcpConfig(mcpServers);
+      writeMcpConfig(config3, generatedPath);
+      return {
+        path: generatedPath,
+        source: "generated",
+        servers: Object.keys(config3.mcpServers),
+        generated: true
+      };
+    }
+    const config2 = readMcpConfig(generatedPath);
+    return {
+      path: generatedPath,
+      source: "generated",
+      servers: config2 ? Object.keys(config2.mcpServers) : mcpServers,
+      generated: false
+    };
+  }
+  return {
+    path: join3(home, ".claude.json"),
+    source: "fallback"
+  };
+}
+function resolveMcpConfigPath(squadName, mcpServers) {
+  return resolveMcpConfig(squadName, mcpServers).path;
+}
+
+// src/lib/squad-parser.ts
 function findSquadsDir() {
   let dir = process.cwd();
   for (let i = 0; i < 5; i++) {
-    const squadsPath = join3(dir, ".agents", "squads");
-    if (existsSync3(squadsPath)) {
+    const squadsPath = join4(dir, ".agents", "squads");
+    if (existsSync4(squadsPath)) {
       return squadsPath;
     }
-    const parent = join3(dir, "..");
+    const parent = join4(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -1354,14 +1580,14 @@ function findSquadsDir() {
 function findProjectRoot() {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  return join3(squadsDir, "..", "..");
+  return join4(squadsDir, "..", "..");
 }
 function hasLocalInfraConfig() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) return false;
-  const envPath = join3(projectRoot, ".env");
-  if (!existsSync3(envPath)) return false;
-  const content = readFileSync2(envPath, "utf-8");
+  const envPath = join4(projectRoot, ".env");
+  if (!existsSync4(envPath)) return false;
+  const content = readFileSync3(envPath, "utf-8");
   const infraKeys = ["LANGFUSE_", "SQUADS_BRIDGE", "SQUADS_POSTGRES", "SQUADS_REDIS"];
   return infraKeys.some((key) => content.includes(key));
 }
@@ -1370,8 +1596,8 @@ function listSquads(squadsDir) {
   const entries = readdirSync(squadsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && !entry.name.startsWith("_")) {
-      const squadFile = join3(squadsDir, entry.name, "SQUAD.md");
-      if (existsSync3(squadFile)) {
+      const squadFile = join4(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync4(squadFile)) {
         squads.push(entry.name);
       }
     }
@@ -1382,8 +1608,8 @@ function listAgents(squadsDir, squadName) {
   const agents = [];
   const dirs = squadName ? [squadName] : readdirSync(squadsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name);
   for (const dir of dirs) {
-    const squadPath = join3(squadsDir, dir);
-    if (!existsSync3(squadPath)) continue;
+    const squadPath = join4(squadsDir, dir);
+    if (!existsSync4(squadPath)) continue;
     const files = readdirSync(squadPath);
     for (const file of files) {
       if (file.endsWith(".md") && file !== "SQUAD.md") {
@@ -1392,7 +1618,7 @@ function listAgents(squadsDir, squadName) {
           name: agentName,
           role: `Agent in ${dir}`,
           trigger: "manual",
-          filePath: join3(squadPath, file)
+          filePath: join4(squadPath, file)
         });
       }
     }
@@ -1400,7 +1626,7 @@ function listAgents(squadsDir, squadName) {
   return agents;
 }
 function parseSquadFile(filePath) {
-  const rawContent = readFileSync2(filePath, "utf-8");
+  const rawContent = readFileSync3(filePath, "utf-8");
   const { data: frontmatter, content: bodyContent } = matter(rawContent);
   const fm = frontmatter;
   const lines = bodyContent.split("\n");
@@ -1521,20 +1747,20 @@ function parseSquadFile(filePath) {
 function loadSquad(squadName) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return null;
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return null;
   return parseSquadFile(squadFile);
 }
 function loadAgentDefinition(agentPath) {
-  if (!existsSync3(agentPath)) return "";
-  return readFileSync2(agentPath, "utf-8");
+  if (!existsSync4(agentPath)) return "";
+  return readFileSync3(agentPath, "utf-8");
 }
 function addGoalToSquad(squadName, goal2) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return false;
-  let content = readFileSync2(squadFile, "utf-8");
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return false;
+  let content = readFileSync3(squadFile, "utf-8");
   if (!content.includes("## Goals")) {
     const insertPoint = content.indexOf("## Dependencies");
     if (insertPoint > 0) {
@@ -1569,15 +1795,15 @@ function addGoalToSquad(squadName, goal2) {
 - [ ] ${goal2}` + content.slice(headerEnd);
     }
   }
-  writeFileSync2(squadFile, content);
+  writeFileSync3(squadFile, content);
   return true;
 }
 function updateGoalInSquad(squadName, goalIndex, updates) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return false;
-  const content = readFileSync2(squadFile, "utf-8");
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return false;
+  const content = readFileSync3(squadFile, "utf-8");
   const lines = content.split("\n");
   let currentSection = "";
   let goalCount = 0;
@@ -1599,7 +1825,7 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
             }
           }
           lines[i] = newLine;
-          writeFileSync2(squadFile, lines.join("\n"));
+          writeFileSync3(squadFile, lines.join("\n"));
           return true;
         }
         goalCount++;
@@ -1608,6 +1834,84 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
   }
   return false;
 }
+function findSkillsDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const skillsDir = join4(projectRoot, ".claude", "skills");
+  return existsSync4(skillsDir) ? skillsDir : null;
+}
+function findMemoryDir2() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const memoryDir = join4(projectRoot, ".agents", "memory");
+  return existsSync4(memoryDir) ? memoryDir : null;
+}
+function resolveSkillPath(skillName) {
+  const skillsDir = findSkillsDir();
+  if (!skillsDir) return null;
+  const skillPath = join4(skillsDir, skillName);
+  return existsSync4(skillPath) ? skillPath : null;
+}
+function resolveMemoryPaths(patterns) {
+  const memoryDir = findMemoryDir2();
+  if (!memoryDir) return [];
+  const resolved = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const subdir = pattern.slice(0, -2);
+      const subdirPath = join4(memoryDir, subdir);
+      if (existsSync4(subdirPath)) {
+        try {
+          const files = readdirSync(subdirPath);
+          for (const file of files) {
+            if (file.endsWith(".md")) {
+              resolved.push(join4(subdirPath, file));
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      const fullPath = join4(memoryDir, pattern);
+      if (existsSync4(fullPath)) {
+        resolved.push(fullPath);
+      }
+    }
+  }
+  return resolved;
+}
+function resolveExecutionContext(squad, forceRegenerate = false) {
+  const ctx = squad.context || {};
+  const mcpResolution = resolveMcpConfig(
+    squad.name,
+    ctx.mcp,
+    forceRegenerate
+  );
+  const skillPaths = [];
+  if (ctx.skills) {
+    for (const skill of ctx.skills) {
+      const path3 = resolveSkillPath(skill);
+      if (path3) {
+        skillPaths.push(path3);
+      }
+    }
+  }
+  const memoryPaths = ctx.memory?.load ? resolveMemoryPaths(ctx.memory.load) : [];
+  return {
+    // Copy all SquadContext fields
+    ...ctx,
+    // Add squad name
+    squadName: squad.name,
+    // Add resolved paths
+    resolved: {
+      mcpConfigPath: mcpResolution.path,
+      mcpSource: mcpResolution.source,
+      mcpServers: mcpResolution.servers || [],
+      skillPaths,
+      memoryPaths
+    }
+  };
+}
 
 // src/lib/permissions.ts
 import { minimatch } from "minimatch";
@@ -1846,9 +2150,12 @@ function generateExecutionId() {
   const random = Math.random().toString(36).substring(2, 8);
   return `exec_${timestamp}_${random}`;
 }
-function selectMcpConfig(squadName) {
+function selectMcpConfig(squadName, squad) {
+  if (squad?.context?.mcp && squad.context.mcp.length > 0) {
+    return resolveMcpConfigPath(squadName, squad.context.mcp);
+  }
   const home = process.env.HOME || "";
-  const configsDir = join4(home, ".claude", "mcp-configs");
+  const configsDir = join5(home, ".claude", "mcp-configs");
   const squadConfigs = {
     website: "website.json",
     // chrome-devtools, nano-banana
@@ -1863,12 +2170,12 @@ function selectMcpConfig(squadName) {
   };
   const configFile = squadConfigs[squadName.toLowerCase()];
   if (configFile) {
-    const configPath = join4(configsDir, configFile);
-    if (existsSync4(configPath)) {
+    const configPath = join5(configsDir, configFile);
+    if (existsSync5(configPath)) {
       return configPath;
     }
   }
-  return join4(home, ".claude.json");
+  return join5(home, ".claude.json");
 }
 function detectTaskType(agentName) {
   const name = agentName.toLowerCase();
@@ -1884,12 +2191,12 @@ function detectTaskType(agentName) {
   return "execution";
 }
 function ensureProjectTrusted(projectPath) {
-  const configPath = join4(process.env.HOME || "", ".claude.json");
-  if (!existsSync4(configPath)) {
+  const configPath = join5(process.env.HOME || "", ".claude.json");
+  if (!existsSync5(configPath)) {
     return;
   }
   try {
-    const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync4(configPath, "utf-8"));
     if (!config2.projects) {
       config2.projects = {};
     }
@@ -1898,7 +2205,7 @@ function ensureProjectTrusted(projectPath) {
     }
     if (!config2.projects[projectPath].hasTrustDialogAccepted) {
       config2.projects[projectPath].hasTrustDialogAccepted = true;
-      writeFileSync3(configPath, JSON.stringify(config2, null, 2));
+      writeFileSync4(configPath, JSON.stringify(config2, null, 2));
     }
   } catch {
   }
@@ -1906,25 +2213,25 @@ function ensureProjectTrusted(projectPath) {
 function getProjectRoot() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname(dirname(squadsDir));
+    return dirname2(dirname2(squadsDir));
   }
   return process.cwd();
 }
 function getExecutionLogPath(squadName, agentName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join4(memoryDir, squadName, agentName, "executions.md");
+  return join5(memoryDir, squadName, agentName, "executions.md");
 }
 function logExecution(record) {
   const logPath = getExecutionLogPath(record.squadName, record.agentName);
   if (!logPath) return;
-  const dir = dirname(logPath);
-  if (!existsSync4(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname2(logPath);
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
   let content = "";
-  if (existsSync4(logPath)) {
-    content = readFileSync3(logPath, "utf-8").trimEnd();
+  if (existsSync5(logPath)) {
+    content = readFileSync4(logPath, "utf-8").trimEnd();
   } else {
     content = `# ${record.squadName}/${record.agentName} - Execution Log`;
   }
@@ -1937,12 +2244,12 @@ function logExecution(record) {
 - Trigger: ${record.trigger || "manual"}
 - Task Type: ${record.taskType || "execution"}
 `;
-  writeFileSync3(logPath, content + entry);
+  writeFileSync4(logPath, content + entry);
 }
 function updateExecutionStatus(squadName, agentName, executionId, status, details) {
   const logPath = getExecutionLogPath(squadName, agentName);
-  if (!logPath || !existsSync4(logPath)) return;
-  let content = readFileSync3(logPath, "utf-8");
+  if (!logPath || !existsSync5(logPath)) return;
+  let content = readFileSync4(logPath, "utf-8");
   const endTime = (/* @__PURE__ */ new Date()).toISOString();
   const execMarker = `<!-- exec:${executionId} -->`;
   const markerIndex = content.indexOf(execMarker);
@@ -1963,7 +2270,7 @@ function updateExecutionStatus(squadName, agentName, executionId, status, detail
 - Error: ${details.error}`;
   }
   content = content.slice(0, entryStart) + updatedEntry + content.slice(entryEnd);
-  writeFileSync3(logPath, content);
+  writeFileSync4(logPath, content);
 }
 function extractMcpServersFromDefinition(definition) {
   const servers = /* @__PURE__ */ new Set();
@@ -2042,8 +2349,8 @@ async function runSquad(squad, squadsDir, options) {
   if (options.parallel) {
     const agentFiles = squad.agents.map((a) => ({
       name: a.name,
-      path: join4(squadsDir, squad.name, `${a.name}.md`)
-    })).filter((a) => existsSync4(a.path));
+      path: join5(squadsDir, squad.name, `${a.name}.md`)
+    })).filter((a) => existsSync5(a.path));
     if (agentFiles.length === 0) {
       writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
       return;
@@ -2079,8 +2386,8 @@ async function runSquad(squad, squadsDir, options) {
     writeLine();
     for (let i = 0; i < pipeline.agents.length; i++) {
       const agentName = pipeline.agents[i];
-      const agentPath = join4(squadsDir, squad.name, `${agentName}.md`);
-      if (existsSync4(agentPath)) {
+      const agentPath = join5(squadsDir, squad.name, `${agentName}.md`);
+      if (existsSync5(agentPath)) {
         writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
         await runAgent(agentName, agentPath, squad.name, options);
         writeLine();
@@ -2090,8 +2397,8 @@ async function runSquad(squad, squadsDir, options) {
     }
   } else {
     if (options.agent) {
-      const agentPath = join4(squadsDir, squad.name, `${options.agent}.md`);
-      if (existsSync4(agentPath)) {
+      const agentPath = join5(squadsDir, squad.name, `${options.agent}.md`);
+      if (existsSync5(agentPath)) {
         await runAgent(options.agent, agentPath, squad.name, options);
       } else {
         writeLine(`  ${icons.error} ${colors.red}Agent ${options.agent} not found${RESET}`);
@@ -2102,8 +2409,8 @@ async function runSquad(squad, squadsDir, options) {
         (a) => a.name.includes("lead") || a.trigger === "Manual"
       );
       if (orchestrator) {
-        const agentPath = join4(squadsDir, squad.name, `${orchestrator.name}.md`);
-        if (existsSync4(agentPath)) {
+        const agentPath = join5(squadsDir, squad.name, `${orchestrator.name}.md`);
+        if (existsSync5(agentPath)) {
           await runAgent(orchestrator.name, agentPath, squad.name, options);
         }
       } else {
@@ -2129,9 +2436,9 @@ async function runLeadMode(squad, squadsDir, options) {
   if (!squad) return;
   const agentFiles = squad.agents.map((a) => ({
     name: a.name,
-    path: join4(squadsDir, squad.name, `${a.name}.md`),
+    path: join5(squadsDir, squad.name, `${a.name}.md`),
     role: a.role || ""
-  })).filter((a) => existsSync4(a.path));
+  })).filter((a) => existsSync5(a.path));
   if (agentFiles.length === 0) {
     writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
     return;
@@ -2250,9 +2557,9 @@ async function runAgent(agentName, agentPath, squadName, options) {
   }
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    const squadFilePath = join4(squadsDir, squadName, "SQUAD.md");
-    if (existsSync4(squadFilePath)) {
-      const squadContent = readFileSync3(squadFilePath, "utf-8");
+    const squadFilePath = join5(squadsDir, squadName, "SQUAD.md");
+    if (existsSync5(squadFilePath)) {
+      const squadContent = readFileSync4(squadFilePath, "utf-8");
       const permContext = buildContextFromSquad(squadName, squadContent, agentName);
       const mcpServers = extractMcpServersFromDefinition(definition);
       const execRequest = {
@@ -2361,7 +2668,8 @@ async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foregro
   const agentMatch = prompt2.match(/(\w+) agent/);
   const squadName = process.env.SQUADS_SQUAD || squadMatch?.[1] || "unknown";
   const agentName = process.env.SQUADS_AGENT || agentMatch?.[1] || "unknown";
-  const mcpConfigPath = selectMcpConfig(squadName);
+  const squad = squadName !== "unknown" ? loadSquad(squadName) : null;
+  const mcpConfigPath = selectMcpConfig(squadName, squad);
   const execContext = {
     squad: squadName,
     agent: agentName,
@@ -2532,8 +2840,8 @@ async function listCommand(options) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync5, statSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, statSync } from "fs";
+import { join as join6 } from "path";
 async function statusCommand(squadName, options = {}) {
   await track(Events.CLI_STATUS, { squad: squadName || "all", verbose: options.verbose });
   const squadsDir = findSquadsDir();
@@ -2586,8 +2894,8 @@ async function showOverallStatus(squadsDir, _options) {
     let lastActivity = `${colors.dim}\u2014${RESET}`;
     let activityColor = colors.dim;
     if (memoryDir) {
-      const squadMemoryPath = join5(memoryDir, squadName);
-      if (existsSync5(squadMemoryPath)) {
+      const squadMemoryPath = join6(memoryDir, squadName);
+      if (existsSync6(squadMemoryPath)) {
         const states = getSquadState(squadName);
         memoryStatus = `${colors.green}${states.length} ${states.length === 1 ? "entry" : "entries"}${RESET}`;
         let mostRecent = 0;
@@ -2689,14 +2997,14 @@ async function showSquadStatus(squadName, squadsDir, options) {
 }
 
 // src/commands/stack.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, copyFileSync } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, copyFileSync } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
 import { homedir as homedir2 } from "os";
 import { execSync as execSync3, spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname2(__filename2);
+var __dirname2 = dirname3(__filename2);
 var DEFAULT_CONFIG = {
   SQUADS_DATABASE_URL: "postgresql://squads:squads@localhost:5433/squads",
   SQUADS_BRIDGE_URL: "http://localhost:8088",
@@ -2705,8 +3013,8 @@ var DEFAULT_CONFIG = {
   LANGFUSE_SECRET_KEY: "",
   REDIS_URL: "redis://localhost:6379"
 };
-var CONFIG_PATH2 = join6(homedir2(), ".squadsrc");
-var SQUADS_DATA_DIR = join6(homedir2(), ".squads");
+var CONFIG_PATH2 = join7(homedir2(), ".squadsrc");
+var SQUADS_DATA_DIR = join7(homedir2(), ".squads");
 var SERVICES = {
   bridge: {
     name: "Bridge API",
@@ -2840,25 +3148,25 @@ async function confirm2(question, defaultYes = true) {
 function findPackageDockerDir() {
   const candidates = [
     // From npm package (relative to dist/commands/stack.js)
-    join6(__dirname2, "..", "..", "docker"),
+    join7(__dirname2, "..", "..", "docker"),
     // Local development
-    join6(process.cwd(), "docker"),
-    join6(process.cwd(), "..", "squads-cli", "docker"),
-    join6(homedir2(), "agents-squads", "squads-cli", "docker")
+    join7(process.cwd(), "docker"),
+    join7(process.cwd(), "..", "squads-cli", "docker"),
+    join7(homedir2(), "agents-squads", "squads-cli", "docker")
   ];
   for (const dir of candidates) {
-    if (existsSync6(join6(dir, "docker-compose.yml"))) {
+    if (existsSync7(join7(dir, "docker-compose.yml"))) {
       return dir;
     }
   }
   return null;
 }
 function loadStackConfig() {
-  if (!existsSync6(CONFIG_PATH2)) {
+  if (!existsSync7(CONFIG_PATH2)) {
     return null;
   }
   try {
-    const content = readFileSync4(CONFIG_PATH2, "utf-8");
+    const content = readFileSync5(CONFIG_PATH2, "utf-8");
     const config2 = {};
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -2899,7 +3207,7 @@ function saveStackConfig(config2) {
     "# To activate: source ~/.squadsrc",
     ""
   ];
-  writeFileSync4(CONFIG_PATH2, lines.join("\n"));
+  writeFileSync5(CONFIG_PATH2, lines.join("\n"));
 }
 function applyStackConfig() {
   const config2 = loadStackConfig();
@@ -2971,13 +3279,13 @@ async function checkService(url, timeout = 2e3) {
 }
 function getLangfuseKeysFromDockerEnv() {
   const envPaths2 = [
-    join6(process.cwd(), "docker", ".env"),
-    join6(process.cwd(), "..", "squads-cli", "docker", ".env"),
-    join6(homedir2(), "agents-squads", "squads-cli", "docker", ".env")
+    join7(process.cwd(), "docker", ".env"),
+    join7(process.cwd(), "..", "squads-cli", "docker", ".env"),
+    join7(homedir2(), "agents-squads", "squads-cli", "docker", ".env")
   ];
   for (const envPath of envPaths2) {
-    if (existsSync6(envPath)) {
-      const content = readFileSync4(envPath, "utf-8");
+    if (existsSync7(envPath)) {
+      const content = readFileSync5(envPath, "utf-8");
       const publicMatch = content.match(/LANGFUSE_PUBLIC_KEY=(\S+)/);
       const secretMatch = content.match(/LANGFUSE_SECRET_KEY=(\S+)/);
       if (publicMatch && secretMatch) {
@@ -2992,12 +3300,12 @@ function getLangfuseKeysFromDockerEnv() {
 }
 function findDockerComposeDir() {
   const candidates = [
-    join6(process.cwd(), "docker"),
-    join6(process.cwd(), "..", "squads-cli", "docker"),
-    join6(homedir2(), "agents-squads", "squads-cli", "docker")
+    join7(process.cwd(), "docker"),
+    join7(process.cwd(), "..", "squads-cli", "docker"),
+    join7(homedir2(), "agents-squads", "squads-cli", "docker")
   ];
   for (const dir of candidates) {
-    if (existsSync6(join6(dir, "docker-compose.yml"))) {
+    if (existsSync7(join7(dir, "docker-compose.yml"))) {
       return dir;
     }
   }
@@ -3023,7 +3331,7 @@ async function stackInitCommand() {
   writeLine();
   writeLine(`  ${bold}Step 2: Docker Compose Files${RESET}`);
   let composeDir = findPackageDockerDir();
-  const targetDir = join6(SQUADS_DATA_DIR, "docker");
+  const targetDir = join7(SQUADS_DATA_DIR, "docker");
   if (!composeDir) {
     writeLine(`  ${colors.red}${icons.error}${RESET} Docker compose files not found`);
     writeLine(`  ${colors.dim}This shouldn't happen if you installed via npm.${RESET}`);
@@ -3031,20 +3339,20 @@ async function stackInitCommand() {
     writeLine();
     return;
   }
-  if (composeDir !== targetDir && !existsSync6(targetDir)) {
+  if (composeDir !== targetDir && !existsSync7(targetDir)) {
     writeLine(`  ${colors.cyan}${icons.progress}${RESET} Copying docker files to ${colors.dim}~/.squads/docker${RESET}`);
     try {
-      mkdirSync3(SQUADS_DATA_DIR, { recursive: true });
-      mkdirSync3(targetDir, { recursive: true });
+      mkdirSync4(SQUADS_DATA_DIR, { recursive: true });
+      mkdirSync4(targetDir, { recursive: true });
       const filesToCopy = [
         "docker-compose.yml",
         "docker-compose.engram.yml",
         ".env.example"
       ];
       for (const file of filesToCopy) {
-        const src = join6(composeDir, file);
-        const dst = join6(targetDir, file);
-        if (existsSync6(src)) {
+        const src = join7(composeDir, file);
+        const dst = join7(targetDir, file);
+        if (existsSync7(src)) {
           copyFileSync(src, dst);
         }
       }
@@ -3053,7 +3361,7 @@ async function stackInitCommand() {
     } catch {
       writeLine(`  ${colors.yellow}${icons.warning}${RESET} Could not copy files, using source location`);
     }
-  } else if (existsSync6(targetDir)) {
+  } else if (existsSync7(targetDir)) {
     composeDir = targetDir;
     writeLine(`  ${colors.green}${icons.success}${RESET} Using ${colors.dim}~/.squads/docker${RESET}`);
   } else {
@@ -3061,10 +3369,10 @@ async function stackInitCommand() {
   }
   writeLine();
   writeLine(`  ${bold}Step 3: Environment Configuration${RESET}`);
-  const envPath = join6(composeDir, ".env");
-  const envExamplePath = join6(composeDir, ".env.example");
-  if (!existsSync6(envPath)) {
-    if (existsSync6(envExamplePath)) {
+  const envPath = join7(composeDir, ".env");
+  const envExamplePath = join7(composeDir, ".env.example");
+  if (!existsSync7(envPath)) {
+    if (existsSync7(envExamplePath)) {
       copyFileSync(envExamplePath, envPath);
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created .env from template`);
     } else {
@@ -3093,13 +3401,13 @@ LANGFUSE_PORT=3100
 OTEL_PORT=4318
 BRIDGE_PORT=8088
 `;
-      writeFileSync4(envPath, minimalEnv);
+      writeFileSync5(envPath, minimalEnv);
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created default .env`);
     }
   } else {
     writeLine(`  ${colors.green}${icons.success}${RESET} .env exists`);
   }
-  const envContent = readFileSync4(envPath, "utf-8");
+  const envContent = readFileSync5(envPath, "utf-8");
   const missingSecrets = [];
   const llmProvider = envContent.match(/LLM_PROVIDER=(\w+)/)?.[1] || "ollama";
   if (llmProvider === "openai") {
@@ -3779,8 +4087,8 @@ async function memoryExtractCommand(options = {}) {
 
 // src/commands/sync.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join8 } from "path";
 var PATH_TO_SQUAD = {
   "squads-cli": "product",
   "agents-squads-web": "website",
@@ -3808,15 +4116,15 @@ var MESSAGE_TO_SQUAD = {
   "infra": "engineering"
 };
 function getLastSyncTime(memoryDir) {
-  const syncFile = join7(memoryDir, ".last-sync");
-  if (existsSync7(syncFile)) {
-    return readFileSync5(syncFile, "utf-8").trim();
+  const syncFile = join8(memoryDir, ".last-sync");
+  if (existsSync8(syncFile)) {
+    return readFileSync6(syncFile, "utf-8").trim();
   }
   return null;
 }
 function updateLastSyncTime(memoryDir) {
-  const syncFile = join7(memoryDir, ".last-sync");
-  writeFileSync5(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+  const syncFile = join8(memoryDir, ".last-sync");
+  writeFileSync6(syncFile, (/* @__PURE__ */ new Date()).toISOString());
 }
 function getRecentCommits(since) {
   const commits = [];
@@ -3888,22 +4196,22 @@ ${messages}
 `;
 }
 function appendToSquadMemory(memoryDir, squad, summary) {
-  const squadMemoryDir = join7(memoryDir, squad);
-  if (!existsSync7(squadMemoryDir)) {
-    mkdirSync4(squadMemoryDir, { recursive: true });
+  const squadMemoryDir = join8(memoryDir, squad);
+  if (!existsSync8(squadMemoryDir)) {
+    mkdirSync5(squadMemoryDir, { recursive: true });
   }
   let agentDir;
-  const existingDirs = existsSync7(squadMemoryDir) ? readdirSync2(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  const existingDirs = existsSync8(squadMemoryDir) ? readdirSync2(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
   if (existingDirs.length > 0) {
-    agentDir = join7(squadMemoryDir, existingDirs[0]);
+    agentDir = join8(squadMemoryDir, existingDirs[0]);
   } else {
-    agentDir = join7(squadMemoryDir, `${squad}-lead`);
-    mkdirSync4(agentDir, { recursive: true });
+    agentDir = join8(squadMemoryDir, `${squad}-lead`);
+    mkdirSync5(agentDir, { recursive: true });
   }
-  const statePath = join7(agentDir, "state.md");
+  const statePath = join8(agentDir, "state.md");
   let content = "";
-  if (existsSync7(statePath)) {
-    content = readFileSync5(statePath, "utf-8");
+  if (existsSync8(statePath)) {
+    content = readFileSync6(statePath, "utf-8");
   } else {
     content = `# ${squad} Squad - State
 
@@ -3915,7 +4223,7 @@ Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
     `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
   );
   content += summary;
-  writeFileSync5(statePath, content);
+  writeFileSync6(statePath, content);
   return true;
 }
 function gitPullMemory() {
@@ -4192,28 +4500,28 @@ async function goalProgressCommand(squadName, goalIndex, progress2) {
 }
 
 // src/commands/feedback.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
-import { join as join8, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join9, dirname as dirname4 } from "path";
 function getFeedbackPath(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
   const squad = loadSquad(squadName);
   const agentName = squad?.agents[0]?.name || `${squadName}-lead`;
-  return join8(memoryDir, squadName, agentName, "feedback.md");
+  return join9(memoryDir, squadName, agentName, "feedback.md");
 }
 function getOutputPath(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
   const squad = loadSquad(squadName);
   const agentName = squad?.agents[0]?.name || `${squadName}-lead`;
-  return join8(memoryDir, squadName, agentName, "output.md");
+  return join9(memoryDir, squadName, agentName, "output.md");
 }
 function getLastExecution(squadName) {
   const outputPath = getOutputPath(squadName);
-  if (!outputPath || !existsSync8(outputPath)) {
+  if (!outputPath || !existsSync9(outputPath)) {
     return null;
   }
-  const content = readFileSync6(outputPath, "utf-8");
+  const content = readFileSync7(outputPath, "utf-8");
   const lines = content.split("\n");
   let date = "unknown";
   let summary = lines.slice(0, 5).join("\n");
@@ -4265,9 +4573,9 @@ async function feedbackAddCommand(squadName, rating, feedback2, options) {
     return;
   }
   const lastExec = getLastExecution(squadName);
-  const dir = dirname3(feedbackPath);
-  if (!existsSync8(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname4(feedbackPath);
+  if (!existsSync9(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let entry = `
@@ -4295,15 +4603,15 @@ _Date: ${date}_
     }
   }
   let existing = "";
-  if (existsSync8(feedbackPath)) {
-    existing = readFileSync6(feedbackPath, "utf-8");
+  if (existsSync9(feedbackPath)) {
+    existing = readFileSync7(feedbackPath, "utf-8");
   } else {
     existing = `# ${squadName} - Feedback Log
 
 > Execution feedback and learnings
 `;
   }
-  writeFileSync6(feedbackPath, existing + entry);
+  writeFileSync7(feedbackPath, existing + entry);
   const stars = `${colors.yellow}${"\u2605".repeat(ratingNum)}${"\u2606".repeat(5 - ratingNum)}${RESET}`;
   writeLine();
   writeLine(`  ${icons.success} Feedback recorded for ${colors.cyan}${squadName}${RESET}`);
@@ -4317,11 +4625,11 @@ _Date: ${date}_
 async function feedbackShowCommand(squadName, options) {
   await track(Events.CLI_FEEDBACK_SHOW, { squad: squadName });
   const feedbackPath = getFeedbackPath(squadName);
-  if (!feedbackPath || !existsSync8(feedbackPath)) {
+  if (!feedbackPath || !existsSync9(feedbackPath)) {
     writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
     return;
   }
-  const content = readFileSync6(feedbackPath, "utf-8");
+  const content = readFileSync7(feedbackPath, "utf-8");
   const entries = parseFeedbackHistory(content);
   const limit = options.limit ? parseInt(options.limit) : 5;
   const recent = entries.slice(-limit).reverse();
@@ -4366,10 +4674,10 @@ async function feedbackStatsCommand() {
   writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
   for (const squad of squads) {
     const feedbackPath = getFeedbackPath(squad);
-    if (!feedbackPath || !existsSync8(feedbackPath)) {
+    if (!feedbackPath || !existsSync9(feedbackPath)) {
       continue;
     }
-    const content = readFileSync6(feedbackPath, "utf-8");
+    const content = readFileSync7(feedbackPath, "utf-8");
     const entries = parseFeedbackHistory(content);
     if (entries.length === 0) continue;
     const avgRating = entries.reduce((sum, e) => sum + e.rating, 0) / entries.length;
@@ -4391,9 +4699,252 @@ async function feedbackStatsCommand() {
   writeLine();
 }
 
+// src/commands/learn.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join10, dirname as dirname5 } from "path";
+function parseLearnings(content) {
+  const learnings = [];
+  const sections = content.split(/\n---\n/).filter((s) => s.trim());
+  for (const section of sections) {
+    if (section.startsWith("#")) continue;
+    const dateMatch = section.match(/_(\d{4}-\d{2}-\d{2})_/);
+    const categoryMatch = section.match(/\*\*(\w+)\*\*:/);
+    const tagsMatch = section.match(/Tags: `([^`]+)`/);
+    const lines = section.split("\n").filter((l) => l.trim() && !l.startsWith("_") && !l.includes("Tags:"));
+    const insight = lines.map((l) => l.replace(/^\*\*\w+\*\*:\s*/, "")).join(" ").trim();
+    if (dateMatch && insight) {
+      learnings.push({
+        date: dateMatch[1],
+        insight,
+        category: categoryMatch?.[1]?.toLowerCase() || "tip",
+        tags: tagsMatch?.[1]?.split(",").map((t) => t.trim()) || []
+      });
+    }
+  }
+  return learnings;
+}
+function formatLearning(learning) {
+  const categoryEmoji = {
+    success: "\u25CF",
+    failure: "\u2717",
+    pattern: "\u25C6",
+    tip: "\u2192"
+  };
+  let entry = `
+---
+_${learning.date}_
+
+`;
+  entry += `${categoryEmoji[learning.category]} **${learning.category.charAt(0).toUpperCase() + learning.category.slice(1)}**: ${learning.insight}
+`;
+  if (learning.tags.length > 0) {
+    entry += `Tags: \`${learning.tags.join(", ")}\`
+`;
+  }
+  if (learning.context) {
+    entry += `
+_Context: ${learning.context}_
+`;
+  }
+  return entry;
+}
+async function learnCommand(insight, options) {
+  let squadName = options.squad || "general";
+  if (options.squad) {
+    const squadsDir = findSquadsDir();
+    if (squadsDir) {
+      const squads = listSquads(squadsDir);
+      if (!squads.includes(options.squad)) {
+        writeLine();
+        writeLine(`  ${colors.yellow}${icons.warning} Squad '${options.squad}' not found${RESET}`);
+        writeLine(`  ${colors.dim}Available: ${squads.join(", ")}${RESET}`);
+        writeLine(`  ${colors.dim}Using 'general' instead${RESET}`);
+        squadName = "general";
+      }
+    }
+  }
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim().toLowerCase()) : [];
+  if (tags.length === 0) {
+    const autoTags = extractTags(insight);
+    tags.push(...autoTags);
+  }
+  const category = options.category || inferCategory(insight);
+  const learning = {
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    insight,
+    category,
+    tags,
+    squad: squadName,
+    context: options.context
+  };
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run 'squads init' first${RESET}`);
+    return;
+  }
+  const learningsPath = join10(memoryDir, squadName, "shared", "learnings.md");
+  const dir = dirname5(learningsPath);
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync10(learningsPath)) {
+    content = readFileSync8(learningsPath, "utf-8");
+  } else {
+    content = `# ${squadName} - Learnings
+
+> Accumulated knowledge from sessions
+`;
+  }
+  content += formatLearning(learning);
+  writeFileSync8(learningsPath, content);
+  await track(Events.CLI_LEARN, {
+    squad: squadName,
+    category,
+    tagCount: tags.length
+  });
+  writeLine();
+  writeLine(`  ${icons.success} Learning captured for ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Category:${RESET} ${category}`);
+  if (tags.length > 0) {
+    writeLine(`  ${colors.dim}Tags:${RESET} ${tags.map((t) => `#${t}`).join(" ")}`);
+  }
+  writeLine();
+  writeLine(`  ${colors.green}${insight}${RESET}`);
+  writeLine();
+}
+async function learnShowCommand(squadName, options) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No memory directory found${RESET}`);
+    return;
+  }
+  const learningsPath = join10(memoryDir, squadName, "shared", "learnings.md");
+  if (!existsSync10(learningsPath)) {
+    writeLine(`  ${colors.yellow}No learnings recorded for ${squadName}${RESET}`);
+    writeLine(`  ${colors.dim}Add one: squads learn "insight" --squad ${squadName}${RESET}`);
+    return;
+  }
+  const content = readFileSync8(learningsPath, "utf-8");
+  const learnings = parseLearnings(content);
+  let filtered = learnings;
+  if (options.category) {
+    filtered = filtered.filter((l) => l.category === options.category);
+  }
+  if (options.tag) {
+    const tag = options.tag.toLowerCase();
+    filtered = filtered.filter((l) => l.tags.includes(tag));
+  }
+  const limit = options.limit ? parseInt(options.limit) : 10;
+  const recent = filtered.slice(-limit).reverse();
+  await track(Events.CLI_LEARN_SHOW, { squad: squadName });
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}learnings${RESET} ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  if (recent.length === 0) {
+    writeLine(`  ${colors.dim}No learnings found${RESET}`);
+    return;
+  }
+  writeLine(`  ${colors.dim}Showing ${recent.length} of ${filtered.length} learnings${RESET}`);
+  writeLine();
+  const categoryIcon = {
+    success: `${colors.green}${icons.success}${RESET}`,
+    failure: `${colors.red}\u2717${RESET}`,
+    pattern: `${colors.purple}\u25C6${RESET}`,
+    tip: `${colors.cyan}\u2192${RESET}`
+  };
+  for (const learning of recent) {
+    writeLine(`  ${colors.dim}${learning.date}${RESET} ${categoryIcon[learning.category]} ${learning.insight}`);
+    if (learning.tags.length > 0) {
+      writeLine(`    ${colors.dim}${learning.tags.map((t) => `#${t}`).join(" ")}${RESET}`);
+    }
+  }
+  writeLine();
+}
+async function learnSearchCommand(query, options) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No memory directory found${RESET}`);
+    return;
+  }
+  const squadsDir = findSquadsDir();
+  const squads = squadsDir ? listSquads(squadsDir) : [];
+  squads.push("general");
+  const allLearnings = [];
+  for (const squad of squads) {
+    const learningsPath = join10(memoryDir, squad, "shared", "learnings.md");
+    if (existsSync10(learningsPath)) {
+      const content = readFileSync8(learningsPath, "utf-8");
+      const learnings = parseLearnings(content);
+      allLearnings.push(...learnings.map((l) => ({ ...l, squad })));
+    }
+  }
+  const queryLower = query.toLowerCase();
+  const matches = allLearnings.filter(
+    (l) => l.insight.toLowerCase().includes(queryLower) || l.tags.some((t) => t.includes(queryLower))
+  );
+  await track(Events.CLI_LEARN_SEARCH, { query, matches: matches.length });
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}search learnings${RESET} "${query}"`);
+  writeLine();
+  const limit = options.limit ? parseInt(options.limit) : 10;
+  const limited = matches.slice(0, limit);
+  if (limited.length === 0) {
+    writeLine(`  ${colors.dim}No learnings found matching "${query}"${RESET}`);
+    return;
+  }
+  writeLine(`  ${colors.dim}Found ${matches.length} matches${RESET}`);
+  writeLine();
+  const categoryIcon = {
+    success: `${colors.green}${icons.success}${RESET}`,
+    failure: `${colors.red}\u2717${RESET}`,
+    pattern: `${colors.purple}\u25C6${RESET}`,
+    tip: `${colors.cyan}\u2192${RESET}`
+  };
+  for (const learning of limited) {
+    writeLine(`  ${colors.cyan}${learning.squad}${RESET} ${categoryIcon[learning.category]} ${learning.insight}`);
+  }
+  writeLine();
+}
+function extractTags(insight) {
+  const tags = [];
+  const lowerInsight = insight.toLowerCase();
+  const patterns = {
+    "auth": ["auth", "login", "token", "session", "password"],
+    "api": ["api", "endpoint", "request", "response", "rest"],
+    "bug": ["bug", "fix", "error", "issue", "crash"],
+    "perf": ["performance", "slow", "fast", "optimize", "cache"],
+    "ux": ["user", "ui", "interface", "design", "experience"],
+    "test": ["test", "spec", "coverage", "assert"],
+    "db": ["database", "query", "sql", "postgres", "redis"],
+    "deploy": ["deploy", "release", "production", "staging"]
+  };
+  for (const [tag, keywords] of Object.entries(patterns)) {
+    if (keywords.some((kw) => lowerInsight.includes(kw))) {
+      tags.push(tag);
+    }
+  }
+  return tags.slice(0, 3);
+}
+function inferCategory(insight) {
+  const lower = insight.toLowerCase();
+  if (lower.includes("worked") || lower.includes("success") || lower.includes("fixed")) {
+    return "success";
+  }
+  if (lower.includes("failed") || lower.includes("error") || lower.includes("didn't work")) {
+    return "failure";
+  }
+  if (lower.includes("pattern") || lower.includes("always") || lower.includes("whenever")) {
+    return "pattern";
+  }
+  return "tip";
+}
+
 // src/commands/dashboard.ts
-import { readdirSync as readdirSync4, existsSync as existsSync9, statSync as statSync2 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync4, existsSync as existsSync11, statSync as statSync2 } from "fs";
+import { join as join11 } from "path";
 
 // src/lib/providers.ts
 var PROVIDERS = {
@@ -5252,16 +5803,16 @@ async function closeDatabase() {
 function getLastActivityDate(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return "unknown";
-  const squadMemory = join9(memoryDir, squadName);
-  if (!existsSync9(squadMemory)) return "\u2014";
+  const squadMemory = join11(memoryDir, squadName);
+  if (!existsSync11(squadMemory)) return "\u2014";
   let latestTime = 0;
   try {
     const agents = readdirSync4(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
     for (const agent of agents) {
-      const agentPath = join9(squadMemory, agent.name);
+      const agentPath = join11(squadMemory, agent.name);
       const files = readdirSync4(agentPath).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const filePath = join9(agentPath, file);
+        const filePath = join11(agentPath, file);
         const stats = statSync2(filePath);
         if (stats.mtimeMs > latestTime) {
           latestTime = stats.mtimeMs;
@@ -5508,11 +6059,11 @@ async function dashboardCommand(options = {}) {
   await closeDatabase();
 }
 function findAgentsSquadsDir() {
-  const parentDir = join9(process.cwd(), "..");
-  if (existsSync9(join9(parentDir, "hq"))) {
+  const parentDir = join11(process.cwd(), "..");
+  if (existsSync11(join11(parentDir, "hq"))) {
     return parentDir;
   }
-  if (existsSync9(join9(process.cwd(), ".git"))) {
+  if (existsSync11(join11(process.cwd(), ".git"))) {
     return process.cwd();
   }
   return null;
@@ -6151,7 +6702,7 @@ function executeClaudePrompt(prompt2) {
 // src/commands/open-issues.ts
 import { execSync as execSync7, spawn as spawn5 } from "child_process";
 import { readdirSync as readdirSync5 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 import ora4 from "ora";
 var ISSUE_FINDER_PATTERNS = [
   "*-eval.md",
@@ -6209,7 +6760,7 @@ function findEvalAgents(squadsDir, filterSquad) {
   const agents = [];
   const squads = readdirSync5(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => !filterSquad || d.name === filterSquad).map((d) => d.name);
   for (const squad of squads) {
-    const squadPath = join10(squadsDir, squad);
+    const squadPath = join12(squadsDir, squad);
     const files = readdirSync5(squadPath).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const isEval = ISSUE_FINDER_PATTERNS.some((pattern) => {
@@ -6220,7 +6771,7 @@ function findEvalAgents(squadsDir, filterSquad) {
         agents.push({
           name: file,
           squad,
-          path: join10(squadPath, file)
+          path: join12(squadPath, file)
         });
       }
     }
@@ -6330,8 +6881,8 @@ import open from "open";
 
 // src/lib/auth.ts
 import { createClient } from "@supabase/supabase-js";
-import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
+import { join as join13 } from "path";
 import { homedir as homedir3 } from "os";
 import "open";
 import http from "http";
@@ -6361,8 +6912,8 @@ var PERSONAL_DOMAINS = [
   "tutanota.com",
   "hey.com"
 ];
-var AUTH_DIR = join11(homedir3(), ".squads-cli");
-var AUTH_PATH = join11(AUTH_DIR, "auth.json");
+var AUTH_DIR = join13(homedir3(), ".squads-cli");
+var AUTH_PATH = join13(AUTH_DIR, "auth.json");
 function isPersonalEmail(email) {
   const domain = email.split("@")[1]?.toLowerCase();
   return PERSONAL_DOMAINS.includes(domain);
@@ -6371,22 +6922,22 @@ function getEmailDomain(email) {
   return email.split("@")[1]?.toLowerCase() || "";
 }
 function saveSession(session2) {
-  if (!existsSync10(AUTH_DIR)) {
-    mkdirSync6(AUTH_DIR, { recursive: true });
+  if (!existsSync12(AUTH_DIR)) {
+    mkdirSync8(AUTH_DIR, { recursive: true });
   }
-  writeFileSync7(AUTH_PATH, JSON.stringify(session2, null, 2));
+  writeFileSync9(AUTH_PATH, JSON.stringify(session2, null, 2));
 }
 function loadSession() {
-  if (!existsSync10(AUTH_PATH)) return null;
+  if (!existsSync12(AUTH_PATH)) return null;
   try {
-    return JSON.parse(readFileSync7(AUTH_PATH, "utf-8"));
+    return JSON.parse(readFileSync9(AUTH_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearSession() {
-  if (existsSync10(AUTH_PATH)) {
-    writeFileSync7(AUTH_PATH, "");
+  if (existsSync12(AUTH_PATH)) {
+    writeFileSync9(AUTH_PATH, "");
   }
 }
 function startAuthCallbackServer(port = 54321) {
@@ -6609,25 +7160,25 @@ async function updateCommand(options = {}) {
 
 // src/commands/progress.ts
 import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9 } from "fs";
+import { join as join14 } from "path";
 function getTasksFilePath() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     const cwd = process.cwd();
-    const agentsDir = join12(cwd, ".agents");
-    if (!existsSync11(agentsDir)) {
-      mkdirSync7(agentsDir, { recursive: true });
+    const agentsDir = join14(cwd, ".agents");
+    if (!existsSync13(agentsDir)) {
+      mkdirSync9(agentsDir, { recursive: true });
     }
-    return join12(agentsDir, "tasks.json");
+    return join14(agentsDir, "tasks.json");
   }
-  return join12(memoryDir, "..", "tasks.json");
+  return join14(memoryDir, "..", "tasks.json");
 }
 function loadTasks() {
   const tasksPath = getTasksFilePath();
-  if (existsSync11(tasksPath)) {
+  if (existsSync13(tasksPath)) {
     try {
-      return JSON.parse(readFileSync8(tasksPath, "utf-8"));
+      return JSON.parse(readFileSync10(tasksPath, "utf-8"));
     } catch {
       return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
     }
@@ -6637,7 +7188,7 @@ function loadTasks() {
 function saveTasks(data) {
   const tasksPath = getTasksFilePath();
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync8(tasksPath, JSON.stringify(data, null, 2));
+  writeFileSync10(tasksPath, JSON.stringify(data, null, 2));
 }
 function getRecentActivity() {
   const activity = [];
@@ -6989,8 +7540,8 @@ async function resultsCommand(options = {}) {
 }
 
 // src/commands/history.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 var BRIDGE_URL2 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 var FETCH_TIMEOUT_MS2 = 3e3;
 async function fetchWithTimeout2(url, timeoutMs = FETCH_TIMEOUT_MS2) {
@@ -7035,12 +7586,12 @@ async function fetchFromBridge2(days, squad) {
 function fetchFromLocal(days, squad) {
   const executions = [];
   const historyPaths = [
-    join13(process.cwd(), ".agents/sessions/history.jsonl"),
-    join13(process.env.HOME || "", "agents-squads/hq/.agents/sessions/history.jsonl")
+    join15(process.cwd(), ".agents/sessions/history.jsonl"),
+    join15(process.env.HOME || "", "agents-squads/hq/.agents/sessions/history.jsonl")
   ];
   let historyPath;
   for (const path3 of historyPaths) {
-    if (existsSync12(path3)) {
+    if (existsSync14(path3)) {
       historyPath = path3;
       break;
     }
@@ -7049,7 +7600,7 @@ function fetchFromLocal(days, squad) {
     return [];
   }
   try {
-    const content = readFileSync9(historyPath, "utf-8");
+    const content = readFileSync11(historyPath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
     for (const line of lines) {
@@ -7386,18 +7937,18 @@ async function healthCommand(options = {}) {
 
 // src/commands/workers.ts
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 function getTasksFilePath2() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join14(memoryDir, "..", "tasks.json");
+  return join16(memoryDir, "..", "tasks.json");
 }
 function loadActiveTasks() {
   const tasksPath = getTasksFilePath2();
-  if (!tasksPath || !existsSync13(tasksPath)) return [];
+  if (!tasksPath || !existsSync15(tasksPath)) return [];
   try {
-    const data = JSON.parse(readFileSync10(tasksPath, "utf-8"));
+    const data = JSON.parse(readFileSync12(tasksPath, "utf-8"));
     return data.tasks?.filter((t) => t.status === "active") || [];
   } catch {
     return [];
@@ -7544,8 +8095,8 @@ function getElapsedTime2(startTime) {
 }
 
 // src/commands/context-feed.ts
-import { existsSync as existsSync14, statSync as statSync3, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync16, statSync as statSync3, readdirSync as readdirSync6, readFileSync as readFileSync13 } from "fs";
+import { join as join17 } from "path";
 var BRIDGE_URL3 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 async function syncBriefToBridge(brief, sourcePath) {
   try {
@@ -7574,10 +8125,10 @@ async function syncBriefToBridge(brief, sourcePath) {
 }
 function readBusinessBrief(squadsDir) {
   if (!squadsDir) return void 0;
-  const briefPath = join15(squadsDir, "..", "BUSINESS_BRIEF.md");
-  if (!existsSync14(briefPath)) return void 0;
+  const briefPath = join17(squadsDir, "..", "BUSINESS_BRIEF.md");
+  if (!existsSync16(briefPath)) return void 0;
   try {
-    const content = readFileSync11(briefPath, "utf-8");
+    const content = readFileSync13(briefPath, "utf-8");
     const brief = { raw: content };
     const priorityMatch = content.match(/##\s*#1 Priority\s*\n+\*\*([^*]+)\*\*/);
     if (priorityMatch) {
@@ -7627,7 +8178,7 @@ function readBusinessBrief(squadsDir) {
 async function collectBriefingData(options) {
   const squadsDir = findSquadsDir();
   const memoryDir = findMemoryDir();
-  const baseDir = squadsDir ? join15(squadsDir, "..", "..", "..") : null;
+  const baseDir = squadsDir ? join17(squadsDir, "..", "..", "..") : null;
   const allSquads = squadsDir ? listSquads(squadsDir) : [];
   if (options.squad && !allSquads.includes(options.squad)) {
     return {
@@ -7667,14 +8218,14 @@ async function collectBriefingData(options) {
     }
     let lastActivity;
     if (memoryDir) {
-      const squadMemoryPath = join15(memoryDir, squadName);
-      if (existsSync14(squadMemoryPath)) {
+      const squadMemoryPath = join17(memoryDir, squadName);
+      if (existsSync16(squadMemoryPath)) {
         let mostRecent = 0;
         try {
           const walkDir = (dir) => {
             const entries = readdirSync6(dir, { withFileTypes: true });
             for (const entry of entries) {
-              const fullPath = join15(dir, entry.name);
+              const fullPath = join17(dir, entry.name);
               if (entry.isDirectory()) {
                 walkDir(fullPath);
               } else if (entry.name.endsWith(".md")) {
@@ -7754,7 +8305,7 @@ async function collectBriefingData(options) {
   }
   const brief = readBusinessBrief(squadsDir);
   if (brief && squadsDir) {
-    const briefPath = join15(squadsDir, "..", "BUSINESS_BRIEF.md");
+    const briefPath = join17(squadsDir, "..", "BUSINESS_BRIEF.md");
     syncBriefToBridge(brief, briefPath).catch(() => {
     });
   }
@@ -8306,7 +8857,7 @@ async function detectSquadCommand() {
 
 // src/commands/trigger.ts
 import chalk3 from "chalk";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 var SCHEDULER_URL = process.env.SCHEDULER_URL || "http://localhost:8090";
 async function fetchScheduler(path3, options) {
   const res = await fetch(`${SCHEDULER_URL}${path3}`, {
@@ -8356,7 +8907,7 @@ async function syncTriggers() {
   const hqPath = process.env.HQ_PATH || `${process.env.HOME}/agents-squads/hq`;
   try {
     const venvPython = `${hqPath}/squads-scheduler/.venv/bin/python`;
-    const pythonCmd = existsSync15(venvPython) ? venvPython : "python3";
+    const pythonCmd = existsSync17(venvPython) ? venvPython : "python3";
     const output = execSync14(
       `${pythonCmd} ${hqPath}/squads-scheduler/sync_triggers.py`,
       { encoding: "utf-8", cwd: hqPath }
@@ -8440,13 +8991,13 @@ function registerTriggerCommand(program2) {
 
 // src/commands/skill.ts
 import ora6 from "ora";
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readFileSync as readFileSync13 } from "fs";
-import { join as join17, basename as basename2, dirname as dirname4 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync15 } from "fs";
+import { join as join19, basename as basename2, dirname as dirname6 } from "path";
 
 // src/lib/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { readFileSync as readFileSync12, readdirSync as readdirSync7 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join18 } from "path";
 var client = null;
 function getClient() {
   if (!client) {
@@ -8475,12 +9026,12 @@ function loadSkillFiles(skillPath) {
   function walkDir(dir, prefix = "") {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join16(dir, entry.name);
+      const fullPath = join18(dir, entry.name);
       const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         walkDir(fullPath, relativePath);
       } else if (entry.isFile()) {
-        const content = readFileSync12(fullPath, "utf-8");
+        const content = readFileSync14(fullPath, "utf-8");
         files.push({
           name: relativePath,
           content
@@ -8644,14 +9195,14 @@ async function skillUploadCommand(skillPath) {
     writeLine();
     return;
   }
-  const fullPath = skillPath.startsWith("/") ? skillPath : join17(process.cwd(), skillPath);
-  if (!existsSync16(fullPath)) {
+  const fullPath = skillPath.startsWith("/") ? skillPath : join19(process.cwd(), skillPath);
+  if (!existsSync18(fullPath)) {
     writeLine(`  ${icons.error} ${colors.red}Directory not found: ${skillPath}${RESET}`);
     writeLine();
     return;
   }
-  const skillMdPath = join17(fullPath, "SKILL.md");
-  if (!existsSync16(skillMdPath)) {
+  const skillMdPath = join19(fullPath, "SKILL.md");
+  if (!existsSync18(skillMdPath)) {
     writeLine(`  ${icons.error} ${colors.red}SKILL.md not found in ${skillPath}${RESET}`);
     writeLine();
     writeLine(`  ${colors.dim}Create a SKILL.md file or use:${RESET}`);
@@ -8762,7 +9313,7 @@ async function skillConvertCommand(agentPath, options) {
     const [squad, agent] = agentPath.split("/");
     squadName = squad;
     agentName = agent.replace(".md", "");
-    agentFilePath = join17(squadsDir, squad, `${agentName}.md`);
+    agentFilePath = join19(squadsDir, squad, `${agentName}.md`);
   } else {
     agentName = agentPath.replace(".md", "");
     const foundPath = findAgentFile(squadsDir, agentName);
@@ -8773,22 +9324,22 @@ async function skillConvertCommand(agentPath, options) {
       return;
     }
     agentFilePath = foundPath;
-    squadName = basename2(dirname4(agentFilePath));
+    squadName = basename2(dirname6(agentFilePath));
   }
-  if (!existsSync16(agentFilePath)) {
+  if (!existsSync18(agentFilePath)) {
     writeLine(`  ${icons.error} ${colors.red}Agent file not found: ${agentFilePath}${RESET}`);
     writeLine();
     return;
   }
-  const agentContent = readFileSync13(agentFilePath, "utf-8");
+  const agentContent = readFileSync15(agentFilePath, "utf-8");
   const skillName = `${squadName}-${agentName}`;
-  const outputDir = options.output || join17(dirname4(squadsDir), "skills", skillName);
-  if (!existsSync16(outputDir)) {
-    mkdirSync8(outputDir, { recursive: true });
+  const outputDir = options.output || join19(dirname6(squadsDir), "skills", skillName);
+  if (!existsSync18(outputDir)) {
+    mkdirSync10(outputDir, { recursive: true });
   }
   const skillMd = convertAgentToSkill(agentContent, squadName, agentName);
-  const skillMdPath = join17(outputDir, "SKILL.md");
-  writeFileSync9(skillMdPath, skillMd);
+  const skillMdPath = join19(outputDir, "SKILL.md");
+  writeFileSync11(skillMdPath, skillMd);
   writeLine(`  ${icons.success} ${colors.green}Converted:${RESET} ${agentPath}`);
   writeLine();
   writeLine(`  ${colors.dim}Output:${RESET} ${outputDir}`);
@@ -8805,8 +9356,8 @@ function findAgentFile(squadsDir, agentName) {
   const { readdirSync: readdirSync9 } = __require("fs");
   const squads = readdirSync9(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("_")).map((d) => d.name);
   for (const squad of squads) {
-    const agentPath = join17(squadsDir, squad, `${agentName}.md`);
-    if (existsSync16(agentPath)) {
+    const agentPath = join19(squadsDir, squad, `${agentName}.md`);
+    if (existsSync18(agentPath)) {
       return agentPath;
     }
   }
@@ -8847,8 +9398,8 @@ function formatBytes(bytes) {
 }
 
 // src/commands/permissions.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { join as join20 } from "path";
 function registerPermissionsCommand(program2) {
   const permissions = program2.command("permissions").alias("perms").description("Manage and validate squad permissions");
   permissions.command("show <squad>").description("Show permission context for a squad").action(permissionsShowCommand);
@@ -8870,8 +9421,8 @@ async function permissionsShowCommand(squadName) {
     writeLine();
     return;
   }
-  const squadFilePath = join18(squadsDir, squadName, "SQUAD.md");
-  const squadContent = readFileSync14(squadFilePath, "utf-8");
+  const squadFilePath = join20(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync16(squadFilePath, "utf-8");
   const context = buildContextFromSquad(squadName, squadContent);
   const defaults = getDefaultContext(squadName);
   const isDefault = JSON.stringify(context.permissions) === JSON.stringify(defaults.permissions);
@@ -8965,8 +9516,8 @@ async function permissionsCheckCommand(squadName, options) {
     writeLine();
     return;
   }
-  const squadFilePath = join18(squadsDir, squadName, "SQUAD.md");
-  const squadContent = readFileSync14(squadFilePath, "utf-8");
+  const squadFilePath = join20(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync16(squadFilePath, "utf-8");
   const context = buildContextFromSquad(squadName, squadContent, options.agent);
   const request = {
     mcpServers: options.mcp,
@@ -9153,6 +9704,77 @@ async function contextListCommand(options = {}) {
   writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
   writeLine();
 }
+async function contextActivateCommand(squadName, options = {}) {
+  await track(Events.CLI_CONTEXT, { squad: squadName, action: "activate" });
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    process.exit(1);
+  }
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`${colors.red}Squad "${squadName}" not found.${RESET}`);
+    process.exit(1);
+  }
+  const execContext = resolveExecutionContext(squad, options.force);
+  if (options.json) {
+    console.log(JSON.stringify(execContext, null, 2));
+    return;
+  }
+  if (options.dryRun) {
+    writeLine();
+    writeLine(`  ${gradient("squads")} ${colors.dim}context activate${RESET} ${colors.cyan}${squadName}${RESET} ${colors.yellow}(dry run)${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Would resolve:${RESET}`);
+    writeLine();
+    writeLine(`  ${bold}MCP Config${RESET}`);
+    writeLine(`    Path:    ${execContext.resolved.mcpConfigPath}`);
+    writeLine(`    Source:  ${execContext.resolved.mcpSource}`);
+    if (execContext.resolved.mcpServers.length > 0) {
+      writeLine(`    Servers: ${execContext.resolved.mcpServers.join(", ")}`);
+    }
+    if (execContext.resolved.skillPaths.length > 0) {
+      writeLine();
+      writeLine(`  ${bold}Skills${RESET}`);
+      for (const path3 of execContext.resolved.skillPaths) {
+        writeLine(`    ${colors.dim}${path3}${RESET}`);
+      }
+    }
+    if (execContext.resolved.memoryPaths.length > 0) {
+      writeLine();
+      writeLine(`  ${bold}Memory${RESET}`);
+      for (const path3 of execContext.resolved.memoryPaths) {
+        writeLine(`    ${colors.dim}${path3}${RESET}`);
+      }
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}Run without --dry-run to generate config${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}context activate${RESET} ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  const sourceLabel = execContext.resolved.mcpSource === "generated" ? `${colors.green}generated${RESET}` : execContext.resolved.mcpSource === "user-override" ? `${colors.cyan}user override${RESET}` : `${colors.dim}fallback${RESET}`;
+  writeLine(`  ${icons.success} MCP config: ${sourceLabel}`);
+  writeLine(`    ${colors.dim}${execContext.resolved.mcpConfigPath}${RESET}`);
+  if (execContext.resolved.mcpServers.length > 0) {
+    writeLine(`    ${colors.dim}Servers: ${execContext.resolved.mcpServers.join(", ")}${RESET}`);
+  }
+  if (execContext.resolved.skillPaths.length > 0) {
+    writeLine(`  ${icons.success} Skills: ${execContext.resolved.skillPaths.length} resolved`);
+  }
+  if (execContext.resolved.memoryPaths.length > 0) {
+    writeLine(`  ${icons.success} Memory: ${execContext.resolved.memoryPaths.length} files`);
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}To use this context manually:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} claude --mcp-config '${execContext.resolved.mcpConfigPath}'`);
+  writeLine();
+  writeLine(`  ${colors.dim}Or run with squads:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+}
 
 // src/commands/cost.ts
 function getBudgetStatus(squadName, spent, dailyBudget, weeklyBudget) {
@@ -9399,8 +10021,8 @@ function createBudgetBar(percent, width = 10) {
 }
 
 // src/lib/executions.ts
-import { readFileSync as readFileSync15, existsSync as existsSync17, readdirSync as readdirSync8 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync19, readdirSync as readdirSync8 } from "fs";
+import { join as join21 } from "path";
 function parseExecutionEntry(content, squad, agent) {
   const idMatch = content.match(/<!-- exec:(\S+) -->/);
   if (!idMatch) return null;
@@ -9438,8 +10060,8 @@ function parseExecutionEntry(content, squad, agent) {
   };
 }
 function parseExecutionLog(filePath, squad, agent) {
-  if (!existsSync17(filePath)) return [];
-  const content = readFileSync15(filePath, "utf-8");
+  if (!existsSync19(filePath)) return [];
+  const content = readFileSync17(filePath, "utf-8");
   const executions = [];
   const entries = content.split(/\n---\n/);
   for (const entry of entries) {
@@ -9477,11 +10099,11 @@ function listExecutions(options = {}) {
   const squads = readdirSync8(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   for (const squad of squads) {
     if (filterSquad && squad !== filterSquad) continue;
-    const squadPath = join19(memoryDir, squad);
+    const squadPath = join21(memoryDir, squad);
     const agents = readdirSync8(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const agent of agents) {
       if (filterAgent && agent !== filterAgent) continue;
-      const logPath = join19(squadPath, agent, "executions.md");
+      const logPath = join21(squadPath, agent, "executions.md");
       const agentExecutions = parseExecutionLog(logPath, squad, agent);
       executions.push(...agentExecutions);
     }
@@ -9731,12 +10353,12 @@ async function execStatsCommand(options = {}) {
 // src/commands/tonight.ts
 import ora7 from "ora";
 import fs2 from "fs/promises";
-import path2, { dirname as dirname5 } from "path";
+import path2, { dirname as dirname7 } from "path";
 import { execSync as execSync13, spawn as spawn7 } from "child_process";
 function getProjectRoot2() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname5(dirname5(squadsDir));
+    return dirname7(dirname7(squadsDir));
   }
   return process.cwd();
 }
@@ -10065,12 +10687,12 @@ process.stderr.on("error", (err) => {
   throw err;
 });
 var envPaths = [
-  join20(process.cwd(), ".env"),
-  join20(process.cwd(), "..", "hq", ".env"),
-  join20(homedir4(), "agents-squads", "hq", ".env")
+  join22(process.cwd(), ".env"),
+  join22(process.cwd(), "..", "hq", ".env"),
+  join22(homedir4(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync18(envPath)) {
+  if (existsSync20(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
@@ -10121,6 +10743,7 @@ program.command("dashboard").alias("dash").description("Show comprehensive goals
 var env = program.command("env").description("View squad execution environment (MCP, skills, model, budget)");
 env.command("show <squad>").description("Show execution environment for a squad").option("--json", "Output as JSON").action(contextShowCommand);
 env.command("list").description("List execution environment for all squads").option("--json", "Output as JSON").action(contextListCommand);
+env.command("activate <squad>").description("Activate execution context for a squad (generates scoped MCP config)").option("-d, --dry-run", "Show what would be generated without writing files").option("-f, --force", "Force regeneration even if config exists").option("--json", "Output as JSON").action(contextActivateCommand);
 program.command("cost").description("Show cost summary (today, week, by squad)").option("-s, --squad <squad>", "Filter to specific squad").option("--json", "Output as JSON").action(costCommand);
 program.command("budget").description("Check budget status for a squad").argument("<squad>", "Squad to check").option("--json", "Output as JSON").action(budgetCheckCommand);
 var exec2 = program.command("exec").description("View execution history and statistics");
@@ -10181,6 +10804,10 @@ var feedback = program.command("feedback").description("Record and view executio
 feedback.command("add <squad> <rating> <feedback>").description("Add feedback for last execution (rating 1-5)").option("-l, --learning <learnings...>", "Learnings to extract").action(feedbackAddCommand);
 feedback.command("show <squad>").description("Show feedback history").option("-n, --limit <n>", "Number of entries to show", "5").action(feedbackShowCommand);
 feedback.command("stats").description("Show feedback summary across all squads").action(feedbackStatsCommand);
+program.command("learn <insight>").description("Capture a learning for future sessions").option("-s, --squad <squad>", "Squad to associate learning with").option("-c, --category <category>", "Category: success, failure, pattern, tip").option("-t, --tags <tags>", "Comma-separated tags").option("--context <context>", "Additional context").action(learnCommand);
+var learn = program.command("learnings").description("View and search learnings");
+learn.command("show <squad>").description("Show learnings for a squad").option("-n, --limit <n>", "Number to show", "10").option("-c, --category <category>", "Filter by category").option("--tag <tag>", "Filter by tag").action(learnShowCommand);
+learn.command("search <query>").description("Search learnings across all squads").option("-n, --limit <n>", "Max results", "10").action(learnSearchCommand);
 var sessions = program.command("sessions").description("Show active Claude Code sessions across squads").option("-v, --verbose", "Show session details").option("-j, --json", "Output as JSON").action(sessionsCommand);
 sessions.command("history").description("Show session history and statistics").option("-d, --days <days>", "Days of history to show", "7").option("-s, --squad <squad>", "Filter by squad").option("-j, --json", "Output as JSON").action((options) => sessionsHistoryCommand({
   days: parseInt(options.days, 10),
@@ -10191,8 +10818,8 @@ sessions.command("summary").description("Show pretty session summary (auto-detec
   const { buildCurrentSessionSummary } = await import("./sessions-R4VWIGFR.js");
   let data;
   if (options.file) {
-    const { readFileSync: readFileSync16 } = await import("fs");
-    data = JSON.parse(readFileSync16(options.file, "utf-8"));
+    const { readFileSync: readFileSync18 } = await import("fs");
+    data = JSON.parse(readFileSync18(options.file, "utf-8"));
   } else if (options.data) {
     data = JSON.parse(options.data);
   } else if (!process.stdin.isTTY) {