squads-cli 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,16 +1,1322 @@
 // src/version.ts
-var version = "0.1.0";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var version = pkg.version;
 
-// src/index.ts
-async function loadSquad(path) {
+// src/lib/squad-parser.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, basename, dirname as dirname2 } from "path";
+import matter from "gray-matter";
+
+// src/lib/mcp-config.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+var SERVER_REGISTRY = {};
+function getHome() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+function getContextsDir() {
+  return join(getHome(), ".claude", "contexts");
+}
+function getMcpConfigsDir() {
+  return join(getHome(), ".claude", "mcp-configs");
+}
+function generateMcpConfig(mcpServers) {
+  const config = { mcpServers: {} };
+  for (const server of mcpServers) {
+    const def = SERVER_REGISTRY[server];
+    if (def) {
+      config.mcpServers[server] = def;
+    }
+  }
+  return config;
+}
+function writeMcpConfig(config, path) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, JSON.stringify(config, null, 2));
+}
+function readMcpConfig(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function resolveMcpConfig(squadName, mcpServers, forceRegenerate = false) {
+  const home = getHome();
+  const userOverride = join(getMcpConfigsDir(), `${squadName}.json`);
+  if (existsSync(userOverride)) {
+    const config = readMcpConfig(userOverride);
+    return {
+      path: userOverride,
+      source: "user-override",
+      servers: config ? Object.keys(config.mcpServers) : void 0
+    };
+  }
+  if (mcpServers && mcpServers.length > 0) {
+    const generatedPath = join(getContextsDir(), `${squadName}.mcp.json`);
+    const shouldGenerate = forceRegenerate || !existsSync(generatedPath);
+    if (shouldGenerate) {
+      const config2 = generateMcpConfig(mcpServers);
+      writeMcpConfig(config2, generatedPath);
+      return {
+        path: generatedPath,
+        source: "generated",
+        servers: Object.keys(config2.mcpServers),
+        generated: true
+      };
+    }
+    const config = readMcpConfig(generatedPath);
+    return {
+      path: generatedPath,
+      source: "generated",
+      servers: config ? Object.keys(config.mcpServers) : mcpServers,
+      generated: false
+    };
+  }
+  return {
+    path: join(home, ".claude.json"),
+    source: "fallback"
+  };
+}
+
+// src/lib/squad-parser.ts
+function findSquadsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const squadsPath = join2(dir, ".agents", "squads");
+    if (existsSync2(squadsPath)) {
+      return squadsPath;
+    }
+    const parent = join2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findProjectRoot() {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  return join2(squadsDir, "..", "..");
+}
+function listSquads(squadsDir) {
+  const squads = [];
+  const entries = readdirSync(squadsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith("_")) {
+      const squadFile = join2(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync2(squadFile)) {
+        squads.push(entry.name);
+      }
+    }
+  }
+  return squads;
+}
+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 = join2(squadsDir, dir);
+    if (!existsSync2(squadPath)) continue;
+    const files = readdirSync(squadPath);
+    for (const file of files) {
+      if (file.endsWith(".md") && file !== "SQUAD.md") {
+        const agentName = file.replace(".md", "");
+        agents.push({
+          name: agentName,
+          role: `Agent in ${dir}`,
+          trigger: "manual",
+          filePath: join2(squadPath, file)
+        });
+      }
+    }
+  }
+  return agents;
+}
+function parseSquadFile(filePath) {
+  const rawContent = readFileSync2(filePath, "utf-8");
+  const { data: frontmatter, content: bodyContent } = matter(rawContent);
+  const fm = frontmatter;
+  const lines = bodyContent.split("\n");
+  const dirName = basename(dirname2(filePath));
+  const squad = {
+    // Display name can be different from dir (e.g., "Engineering Squad")
+    name: fm.name || dirName,
+    // Directory name for file path resolution
+    dir: dirName,
+    mission: fm.mission || "",
+    agents: [],
+    pipelines: [],
+    triggers: { scheduled: [], event: [], manual: [] },
+    routines: [],
+    dependencies: [],
+    outputPath: "",
+    goals: [],
+    // Apply frontmatter fields
+    effort: fm.effort,
+    context: fm.context,
+    repo: fm.repo,
+    stack: fm.stack,
+    providers: fm.providers,
+    // Preserve raw frontmatter for KPIs and other custom fields
+    frontmatter,
+    // Phase ordering: which squads must complete before this one
+    depends_on: Array.isArray(fm.depends_on) ? fm.depends_on : void 0
+  };
+  let currentSection = "";
+  let inTable = false;
+  let tableHeaders = [];
+  for (const line of lines) {
+    if (line.startsWith("# Squad:")) {
+      squad.name = line.replace("# Squad:", "").trim().toLowerCase();
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      inTable = false;
+      continue;
+    }
+    if (currentSection === "mission" && line.trim() && !line.startsWith("#")) {
+      if (!squad.mission) {
+        squad.mission = line.trim();
+      }
+    }
+    const effortMatch = line.match(/^effort:\s*(high|medium|low)/i);
+    if (effortMatch && !squad.effort) {
+      squad.effort = effortMatch[1].toLowerCase();
+    }
+    if (currentSection.includes("agent") || currentSection.includes("orchestrator") || currentSection.includes("evaluator") || currentSection.includes("builder") || currentSection.includes("priority")) {
+      if (line.includes("|") && line.includes("Agent")) {
+        inTable = true;
+        tableHeaders = line.split("|").map((h) => h.trim().toLowerCase());
+        continue;
+      }
+      if (inTable && line.includes("|") && !line.includes("---")) {
+        const cells = line.split("|").map((c) => c.trim().replace(/`/g, "").replace(/\*\*/g, ""));
+        const agentIdx = tableHeaders.findIndex((h) => h === "agent");
+        const roleIdx = tableHeaders.findIndex((h) => h === "role");
+        const triggerIdx = tableHeaders.findIndex((h) => h === "trigger");
+        const statusIdx = tableHeaders.findIndex((h) => h === "status");
+        const effortIdx = tableHeaders.findIndex((h) => h === "effort");
+        if (agentIdx >= 0 && cells[agentIdx]) {
+          const effortValue = effortIdx >= 0 ? cells[effortIdx]?.toLowerCase() : void 0;
+          const effort = ["high", "medium", "low"].includes(effortValue || "") ? effortValue : void 0;
+          squad.agents.push({
+            name: cells[agentIdx],
+            role: roleIdx >= 0 ? cells[roleIdx] : "",
+            trigger: triggerIdx >= 0 ? cells[triggerIdx] : "manual",
+            status: statusIdx >= 0 ? cells[statusIdx] : "active",
+            effort
+          });
+        }
+      }
+    }
+    if (line.includes("\u2192") && line.includes("`")) {
+      const pipelineMatch = line.match(/`([^`]+)`\s*→\s*`([^`]+)`/g);
+      if (pipelineMatch) {
+        const agentNames = line.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("pipeline:")) {
+      const pipelineContent = line.split(":")[1];
+      if (pipelineContent && pipelineContent.includes("\u2192")) {
+        const agentNames = pipelineContent.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("primary") && line.includes("`")) {
+      const match = line.match(/`([^`]+)`/);
+      if (match) {
+        squad.outputPath = match[1].replace(/\/$/, "");
+      }
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        const completed = goalMatch[1] === "x";
+        let description = goalMatch[2].trim();
+        let progress;
+        const progressMatch = description.match(/\(progress:\s*([^)]+)\)/i);
+        if (progressMatch) {
+          progress = progressMatch[1];
+          description = description.replace(progressMatch[0], "").trim();
+        }
+        squad.goals.push({
+          description,
+          completed,
+          progress
+        });
+      }
+    }
+  }
+  return squad;
+}
+function loadSquad(squadName) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return null;
+  return parseSquadFile(squadFile);
+}
+function loadAgentDefinition(agentPath) {
+  if (!existsSync2(agentPath)) return "";
+  return readFileSync2(agentPath, "utf-8");
+}
+function addGoalToSquad(squadName, goal) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return false;
+  let content = readFileSync2(squadFile, "utf-8");
+  if (!content.includes("## Goals")) {
+    const insertPoint = content.indexOf("## Dependencies");
+    if (insertPoint > 0) {
+      content = content.slice(0, insertPoint) + `## Goals
+
+- [ ] ${goal}
+
+` + content.slice(insertPoint);
+    } else {
+      content += `
+## Goals
+
+- [ ] ${goal}
+`;
+    }
+  } else {
+    const goalsIdx = content.indexOf("## Goals");
+    const nextSectionIdx = content.indexOf("\n## ", goalsIdx + 1);
+    const endIdx = nextSectionIdx > 0 ? nextSectionIdx : content.length;
+    const goalsSection = content.slice(goalsIdx, endIdx);
+    const lastGoalMatch = goalsSection.match(/^-\s*\[[ x]\].+$/gm);
+    if (lastGoalMatch) {
+      const lastGoal = lastGoalMatch[lastGoalMatch.length - 1];
+      const lastGoalIdx = content.lastIndexOf(lastGoal, endIdx);
+      const insertPos = lastGoalIdx + lastGoal.length;
+      content = content.slice(0, insertPos) + `
+- [ ] ${goal}` + content.slice(insertPos);
+    } else {
+      const headerEnd = goalsIdx + "## Goals".length;
+      content = content.slice(0, headerEnd) + `
+
+- [ ] ${goal}` + content.slice(headerEnd);
+    }
+  }
+  writeFileSync2(squadFile, content);
+  return true;
+}
+function updateGoalInSquad(squadName, goalIndex, updates) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync2(squadFile)) return false;
+  const content = readFileSync2(squadFile, "utf-8");
+  const lines = content.split("\n");
+  let currentSection = "";
+  let goalCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      continue;
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        if (goalCount === goalIndex) {
+          let newLine = "- [" + (updates.completed ? "x" : " ") + "] " + goalMatch[2];
+          if (updates.progress !== void 0) {
+            newLine = newLine.replace(/\s*\(progress:\s*[^)]+\)/i, "");
+            if (updates.progress) {
+              newLine += ` (progress: ${updates.progress})`;
+            }
+          }
+          lines[i] = newLine;
+          writeFileSync2(squadFile, lines.join("\n"));
+          return true;
+        }
+        goalCount++;
+      }
+    }
+  }
+  return false;
+}
+function findProjectSkillsDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const skillsDir = join2(projectRoot, ".claude", "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function findGlobalSkillsDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home) return null;
+  const skillsDir = join2(home, ".claude", "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function findSquadLocalSkillsDir(squadDir) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const skillsDir = join2(squadsDir, squadDir, "skills");
+  return existsSync2(skillsDir) ? skillsDir : null;
+}
+function listSkillsInDir(skillsDir) {
+  if (!existsSync2(skillsDir)) return [];
+  try {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillMdPath = join2(skillsDir, entry.name, "SKILL.md");
+        if (existsSync2(skillMdPath)) {
+          skills.push(entry.name);
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        skills.push(entry.name.replace(".md", ""));
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function findMemoryDir() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) return null;
+  const memoryDir = join2(projectRoot, ".agents", "memory");
+  return existsSync2(memoryDir) ? memoryDir : null;
+}
+function resolveSkill(skillName, squadDir) {
+  if (squadDir) {
+    const squadSkillsDir = findSquadLocalSkillsDir(squadDir);
+    if (squadSkillsDir) {
+      const dirPath = join2(squadSkillsDir, skillName);
+      if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+        return { name: skillName, path: dirPath, source: "squad-local" };
+      }
+      const filePath = join2(squadSkillsDir, `${skillName}.md`);
+      if (existsSync2(filePath)) {
+        return { name: skillName, path: filePath, source: "squad-local" };
+      }
+    }
+  }
+  const projectSkillsDir = findProjectSkillsDir();
+  if (projectSkillsDir) {
+    const dirPath = join2(projectSkillsDir, skillName);
+    if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+      return { name: skillName, path: dirPath, source: "project" };
+    }
+    const filePath = join2(projectSkillsDir, `${skillName}.md`);
+    if (existsSync2(filePath)) {
+      return { name: skillName, path: filePath, source: "project" };
+    }
+  }
+  const globalSkillsDir = findGlobalSkillsDir();
+  if (globalSkillsDir) {
+    const dirPath = join2(globalSkillsDir, skillName);
+    if (existsSync2(dirPath) && existsSync2(join2(dirPath, "SKILL.md"))) {
+      return { name: skillName, path: dirPath, source: "global" };
+    }
+    const filePath = join2(globalSkillsDir, `${skillName}.md`);
+    if (existsSync2(filePath)) {
+      return { name: skillName, path: filePath, source: "global" };
+    }
+  }
   return null;
 }
-async function runAgent(agent, prompt) {
-  return "";
+function getSquadLocalSkills(squadDir) {
+  const squadSkillsDir = findSquadLocalSkillsDir(squadDir);
+  if (!squadSkillsDir) return [];
+  const skillNames = listSkillsInDir(squadSkillsDir);
+  const skills = [];
+  for (const name of skillNames) {
+    const resolved = resolveSkill(name, squadDir);
+    if (resolved && resolved.source === "squad-local") {
+      skills.push(resolved);
+    }
+  }
+  return skills;
+}
+function resolveMemoryPaths(patterns) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return [];
+  const resolved = [];
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const subdir = pattern.slice(0, -2);
+      const subdirPath = join2(memoryDir, subdir);
+      if (existsSync2(subdirPath)) {
+        try {
+          const files = readdirSync(subdirPath);
+          for (const file of files) {
+            if (file.endsWith(".md")) {
+              resolved.push(join2(subdirPath, file));
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      const fullPath = join2(memoryDir, pattern);
+      if (existsSync2(fullPath)) {
+        resolved.push(fullPath);
+      }
+    }
+  }
+  return resolved;
+}
+function findSquadLocalMcpConfig(squadDir) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const mcpConfigPath = join2(squadsDir, squadDir, "mcp.json");
+  return existsSync2(mcpConfigPath) ? mcpConfigPath : null;
+}
+function resolveExecutionContext(squad, forceRegenerate = false) {
+  const ctx = squad.context || {};
+  const squadLocalMcpConfig = findSquadLocalMcpConfig(squad.dir);
+  let mcpConfigPath;
+  let mcpSource;
+  let mcpServers = [];
+  if (squadLocalMcpConfig) {
+    mcpConfigPath = squadLocalMcpConfig;
+    mcpSource = "squad-local";
+    try {
+      const content = readFileSync2(squadLocalMcpConfig, "utf-8");
+      const config = JSON.parse(content);
+      mcpServers = Object.keys(config.mcpServers || {});
+    } catch {
+    }
+  } else {
+    const mcpResolution = resolveMcpConfig(
+      squad.name,
+      ctx.mcp,
+      forceRegenerate
+    );
+    mcpConfigPath = mcpResolution.path;
+    mcpSource = mcpResolution.source;
+    mcpServers = mcpResolution.servers || [];
+  }
+  const resolvedSkills = [];
+  const skillPaths = [];
+  const squadLocalSkills = getSquadLocalSkills(squad.dir);
+  for (const skill of squadLocalSkills) {
+    resolvedSkills.push(skill);
+    skillPaths.push(skill.path);
+  }
+  if (ctx.skills) {
+    for (const skillName of ctx.skills) {
+      if (resolvedSkills.some((s) => s.name === skillName)) {
+        continue;
+      }
+      const resolved = resolveSkill(skillName, squad.dir);
+      if (resolved) {
+        resolvedSkills.push(resolved);
+        skillPaths.push(resolved.path);
+      }
+    }
+  }
+  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,
+      mcpSource,
+      mcpServers,
+      skillPaths,
+      // Backward compatible
+      skills: resolvedSkills,
+      // New detailed skill info
+      memoryPaths
+    }
+  };
+}
+
+// src/lib/condenser/tokens.ts
+var RATIOS = {
+  english: 4,
+  // Standard English text
+  code: 3.5,
+  // Code tends to have more tokens per char
+  json: 3,
+  // JSON has many punctuation tokens
+  mixed: 3.75
+  // Default for mixed content
+};
+function estimateTokens(text, type = "mixed") {
+  if (!text) return 0;
+  const ratio = RATIOS[type];
+  return Math.ceil(text.length / ratio);
+}
+function estimateMessageTokens(message) {
+  let tokens = 4;
+  if (typeof message.content === "string") {
+    tokens += estimateTokens(message.content);
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (part.text) {
+        tokens += estimateTokens(part.text);
+      }
+      tokens += 10;
+    }
+  }
+  return tokens;
+}
+var MODEL_LIMITS = {
+  // Anthropic models
+  "claude-opus-4-5-20251101": 2e5,
+  "claude-sonnet-4-20250514": 2e5,
+  "claude-3-5-haiku-20241022": 2e5,
+  // Aliases
+  opus: 2e5,
+  sonnet: 2e5,
+  haiku: 2e5,
+  // Default fallback
+  default: 2e5
+};
+function getModelLimit(model) {
+  return MODEL_LIMITS[model] ?? MODEL_LIMITS.default;
+}
+function createTracker(model = "default") {
+  return {
+    used: 0,
+    limit: getModelLimit(model),
+    percentage: 0,
+    breakdown: {
+      system: 0,
+      user: 0,
+      assistant: 0,
+      tools: 0
+    }
+  };
+}
+function updateTracker(tracker, content, category = "assistant") {
+  const tokens = estimateTokens(content);
+  tracker.used += tokens;
+  tracker.breakdown[category] += tokens;
+  tracker.percentage = tracker.used / tracker.limit;
+}
+function updateTrackerFromMessage(tracker, message) {
+  const tokens = estimateMessageTokens(message);
+  const category = mapRoleToCategory(message.role);
+  tracker.used += tokens;
+  tracker.breakdown[category] += tokens;
+  tracker.percentage = tracker.used / tracker.limit;
+}
+function mapRoleToCategory(role) {
+  switch (role) {
+    case "system":
+      return "system";
+    case "user":
+      return "user";
+    case "assistant":
+      return "assistant";
+    case "tool":
+    case "tool_result":
+      return "tools";
+    default:
+      return "assistant";
+  }
+}
+var DEFAULT_THRESHOLDS = {
+  light: 0.7,
+  medium: 0.85,
+  heavy: 0.95
+};
+function getCompressionLevel(tracker, thresholds = DEFAULT_THRESHOLDS) {
+  if (tracker.percentage >= thresholds.heavy) return "heavy";
+  if (tracker.percentage >= thresholds.medium) return "medium";
+  if (tracker.percentage >= thresholds.light) return "light";
+  return "none";
+}
+function formatTrackerStatus(tracker) {
+  const pct = (tracker.percentage * 100).toFixed(1);
+  const used = (tracker.used / 1e3).toFixed(1);
+  const limit = (tracker.limit / 1e3).toFixed(0);
+  const level = getCompressionLevel(tracker);
+  const levelIndicator = level === "none" ? "" : level === "light" ? " [!]" : level === "medium" ? " [!!]" : " [!!!]";
+  return `${used}K / ${limit}K tokens (${pct}%)${levelIndicator}`;
+}
+
+// src/lib/condenser/deduplication.ts
+function hashContent(content) {
+  const prefix = content.slice(0, 100);
+  return `${content.length}:${prefix}`;
+}
+var FileDeduplicator = class {
+  /** Map of file path to all reads of that file */
+  reads = /* @__PURE__ */ new Map();
+  /** Current turn index */
+  currentTurn = 0;
+  /**
+   * Record a file read.
+   *
+   * @param path - File path that was read
+   * @param content - File content that was read
+   */
+  trackRead(path, content) {
+    const record = {
+      path,
+      turnIndex: this.currentTurn,
+      tokenCount: estimateTokens(content, "code"),
+      contentHash: hashContent(content)
+    };
+    const existing = this.reads.get(path) || [];
+    existing.push(record);
+    this.reads.set(path, existing);
+  }
+  /**
+   * Advance to next turn.
+   */
+  nextTurn() {
+    this.currentTurn++;
+  }
+  /**
+   * Get current turn index.
+   */
+  getTurn() {
+    return this.currentTurn;
+  }
+  /**
+   * Check if a file has been read before.
+   *
+   * @param path - File path to check
+   * @returns Previous read record if exists
+   */
+  getPreviousRead(path) {
+    const reads = this.reads.get(path);
+    if (!reads || reads.length === 0) return void 0;
+    return reads[reads.length - 1];
+  }
+  /**
+   * Get all files that have been read multiple times.
+   *
+   * @returns Map of path to read count
+   */
+  getDuplicateReads() {
+    const duplicates = /* @__PURE__ */ new Map();
+    for (const [path, reads] of this.reads) {
+      if (reads.length > 1) {
+        duplicates.set(path, reads.length);
+      }
+    }
+    return duplicates;
+  }
+  /**
+   * Calculate potential token savings from deduplication.
+   */
+  getPotentialSavings() {
+    let savings = 0;
+    for (const reads of this.reads.values()) {
+      if (reads.length > 1) {
+        for (let i = 0; i < reads.length - 1; i++) {
+          savings += reads[i].tokenCount;
+        }
+      }
+    }
+    return savings;
+  }
+  /**
+   * Generate a deduplication reference message.
+   *
+   * @param path - File path
+   * @param previousTurn - Turn where file was previously read
+   */
+  static createReference(path, previousTurn) {
+    return `[File "${path}" was read at turn ${previousTurn}. Content unchanged.]`;
+  }
+  /**
+   * Reset tracker state.
+   */
+  reset() {
+    this.reads.clear();
+    this.currentTurn = 0;
+  }
+  /**
+   * Get statistics for debugging.
+   */
+  getStats() {
+    let totalReads = 0;
+    let duplicateReads = 0;
+    for (const reads of this.reads.values()) {
+      totalReads += reads.length;
+      if (reads.length > 1) {
+        duplicateReads += reads.length - 1;
+      }
+    }
+    return {
+      filesTracked: this.reads.size,
+      totalReads,
+      duplicateReads,
+      potentialSavings: this.getPotentialSavings()
+    };
+  }
+};
+
+// src/lib/condenser/pruning.ts
+var DEFAULT_CONFIG = {
+  protectRecent: 4e4,
+  minimumPrunable: 2e4,
+  protectedTools: ["skill", "memory", "goal"]
+};
+function createPrunedPlaceholder(toolName, tokensSaved) {
+  return `[Tool output pruned: ${toolName} (~${Math.round(tokensSaved / 1e3)}K tokens)]`;
+}
+var TokenPruner = class {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Prune messages to reduce token count.
+   *
+   * Strategy:
+   * 1. Scan messages backward from newest to oldest
+   * 2. Accumulate tokens for tool outputs
+   * 3. Mark outputs beyond protection window for pruning
+   * 4. Replace pruned outputs with placeholders
+   *
+   * @param messages - Messages to prune
+   * @returns Pruned messages (new array, originals not mutated)
+   */
+  pruneMessages(messages) {
+    const annotated = messages.map((msg) => ({
+      ...msg,
+      _tokens: estimateMessageTokens(msg)
+    }));
+    const analysis = this.analyzePrunability(annotated);
+    if (analysis.prunableTokens < this.config.minimumPrunable) {
+      return messages;
+    }
+    return this.applyPruning(annotated, analysis.protectionIndex);
+  }
+  /**
+   * Analyze which messages can be pruned.
+   */
+  analyzePrunability(messages) {
+    let protectedTokens = 0;
+    let protectionIndex = messages.length;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (!this.isToolResult(msg)) {
+        protectedTokens += msg._tokens;
+        continue;
+      }
+      if (this.isProtectedTool(msg)) {
+        protectedTokens += msg._tokens;
+        continue;
+      }
+      if (protectedTokens + msg._tokens <= this.config.protectRecent) {
+        protectedTokens += msg._tokens;
+      } else {
+        protectionIndex = i + 1;
+        break;
+      }
+    }
+    let prunableTokens = 0;
+    for (let i = 0; i < protectionIndex; i++) {
+      const msg = messages[i];
+      if (this.isToolResult(msg) && !this.isProtectedTool(msg)) {
+        prunableTokens += msg._tokens;
+      }
+    }
+    return { prunableTokens, protectedTokens, protectionIndex };
+  }
+  /**
+   * Apply pruning to messages before the protection index.
+   */
+  applyPruning(messages, protectionIndex) {
+    return messages.map((msg, i) => {
+      if (i >= protectionIndex) {
+        const { _tokens, _prunable, ...clean } = msg;
+        return clean;
+      }
+      if (!this.isToolResult(msg)) {
+        const { _tokens, _prunable, ...clean } = msg;
+        return clean;
+      }
+      if (this.isProtectedTool(msg)) {
+        const { _tokens, _prunable, ...clean } = msg;
+        return clean;
+      }
+      return this.createPrunedMessage(msg);
+    });
+  }
+  /**
+   * Create a pruned version of a message.
+   */
+  createPrunedMessage(msg) {
+    const toolName = this.getToolName(msg);
+    const placeholder = createPrunedPlaceholder(toolName, msg._tokens);
+    if (typeof msg.content === "string") {
+      return {
+        role: msg.role,
+        content: placeholder
+      };
+    }
+    const content = msg.content.map((part) => {
+      if (part.type === "tool_result" && part.text) {
+        return {
+          ...part,
+          text: placeholder,
+          _pruned: true,
+          _prunedAt: Date.now()
+        };
+      }
+      return part;
+    });
+    return {
+      role: msg.role,
+      content
+    };
+  }
+  /**
+   * Check if a message is a tool result.
+   */
+  isToolResult(msg) {
+    if (msg.role === "tool") return true;
+    if (Array.isArray(msg.content)) {
+      return msg.content.some((part) => part.type === "tool_result");
+    }
+    return false;
+  }
+  /**
+   * Check if a tool is in the protected list.
+   */
+  isProtectedTool(msg) {
+    const toolName = this.getToolName(msg);
+    return this.config.protectedTools.includes(toolName.toLowerCase());
+  }
+  /**
+   * Extract tool name from a message.
+   */
+  getToolName(msg) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.name) return part.name;
+      }
+    }
+    if (typeof msg.content === "string") {
+      const match = msg.content.match(/Tool (?:output|result).*?:\s*(\w+)/i);
+      if (match) return match[1];
+    }
+    return "unknown";
+  }
+  /**
+   * Get statistics about potential pruning.
+   */
+  getStats(messages) {
+    const annotated = messages.map((msg) => ({
+      ...msg,
+      _tokens: estimateMessageTokens(msg)
+    }));
+    const totalTokens = annotated.reduce((sum, msg) => sum + msg._tokens, 0);
+    const analysis = this.analyzePrunability(annotated);
+    return {
+      totalTokens,
+      prunableTokens: analysis.prunableTokens,
+      protectedTokens: analysis.protectedTokens,
+      savingsPercentage: totalTokens > 0 ? analysis.prunableTokens / totalTokens * 100 : 0
+    };
+  }
+};
+
+// src/lib/condenser/summarizer.ts
+import Anthropic from "@anthropic-ai/sdk";
+var DEFAULT_CONFIG2 = {
+  keepFirst: 4,
+  keepLast: 20,
+  model: "claude-3-5-haiku-20241022",
+  // Cheap and fast
+  maxSummaryTokens: 2e3
+};
+var SUMMARIZATION_PROMPT = `You are summarizing a conversation between a user and an AI assistant to reduce context length while preserving essential information.
+
+<conversation_to_summarize>
+{{MIDDLE_CONTENT}}
+</conversation_to_summarize>
+
+Create a concise summary that preserves:
+1. **User's goals** - What the user is trying to accomplish
+2. **Progress made** - Key actions taken and their outcomes
+3. **Current state** - What's done vs. what still needs to be done
+4. **Critical context** - File paths, error messages, decisions made
+5. **Blockers** - Any issues that need to be resolved
+
+Format your summary as a structured note that the assistant can reference to continue the work.
+
+Keep the summary under {{MAX_TOKENS}} tokens. Focus on actionable information.`;
+var ConversationSummarizer = class {
+  config;
+  client = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /**
+   * Get or create Anthropic client.
+   */
+  getClient() {
+    if (!this.client) {
+      this.client = new Anthropic();
+    }
+    return this.client;
+  }
+  /**
+   * Summarize messages to reduce token count.
+   *
+   * Strategy:
+   * 1. Keep first N messages (system prompt, initial context)
+   * 2. Keep last M messages (recent context, current task)
+   * 3. Summarize everything in between
+   *
+   * @param messages - Messages to summarize
+   * @returns Summarized messages
+   */
+  async summarize(messages) {
+    if (messages.length <= this.config.keepFirst + this.config.keepLast) {
+      return messages;
+    }
+    const firstMessages = messages.slice(0, this.config.keepFirst);
+    const middleMessages = messages.slice(this.config.keepFirst, -this.config.keepLast);
+    const lastMessages = messages.slice(-this.config.keepLast);
+    const summary = await this.generateSummary(middleMessages);
+    const summaryMessage = {
+      role: "user",
+      content: `[Context Summary - ${middleMessages.length} messages condensed]
+
+${summary}`
+    };
+    return [...firstMessages, summaryMessage, ...lastMessages];
+  }
+  /**
+   * Generate a summary of the middle messages.
+   */
+  async generateSummary(messages) {
+    const middleContent = this.formatMessagesForSummary(messages);
+    const prompt = SUMMARIZATION_PROMPT.replace("{{MIDDLE_CONTENT}}", middleContent).replace(
+      "{{MAX_TOKENS}}",
+      String(this.config.maxSummaryTokens)
+    );
+    try {
+      const client = this.getClient();
+      const response = await client.messages.create({
+        model: this.config.model,
+        max_tokens: this.config.maxSummaryTokens,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ]
+      });
+      const textBlock = response.content.find((block) => block.type === "text");
+      if (textBlock && "text" in textBlock) {
+        return textBlock.text;
+      }
+      return "[Summary generation failed - no text in response]";
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return `[Summary generation failed: ${message}]`;
+    }
+  }
+  /**
+   * Format messages for the summarization prompt.
+   */
+  formatMessagesForSummary(messages) {
+    return messages.map((msg, i) => {
+      const role = msg.role.toUpperCase();
+      const content = this.extractContent(msg);
+      return `[${i + 1}] ${role}:
+${content}`;
+    }).join("\n\n---\n\n");
+  }
+  /**
+   * Extract text content from a message.
+   */
+  extractContent(msg) {
+    if (typeof msg.content === "string") {
+      return this.truncateContent(msg.content);
+    }
+    const parts = [];
+    for (const part of msg.content) {
+      if (part.text) {
+        parts.push(this.truncateContent(part.text));
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Truncate very long content for summary input.
+   */
+  truncateContent(content, maxChars = 2e3) {
+    if (content.length <= maxChars) return content;
+    return content.slice(0, maxChars) + `
+[...truncated ${content.length - maxChars} chars]`;
+  }
+  /**
+   * Estimate the cost of summarization.
+   *
+   * @param messages - Messages that would be summarized
+   * @returns Estimated cost in USD
+   */
+  estimateCost(messages) {
+    if (messages.length <= this.config.keepFirst + this.config.keepLast) {
+      return 0;
+    }
+    const middleMessages = messages.slice(this.config.keepFirst, -this.config.keepLast);
+    const inputTokens = middleMessages.reduce((sum, msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return sum + estimateTokens(content);
+    }, 0);
+    const inputCost = inputTokens / 1e6 * 0.25;
+    const outputCost = this.config.maxSummaryTokens / 1e6 * 1.25;
+    return inputCost + outputCost;
+  }
+  /**
+   * Get statistics about potential summarization.
+   */
+  getStats(messages) {
+    const wouldKeep = Math.min(messages.length, this.config.keepFirst + this.config.keepLast);
+    const wouldSummarize = Math.max(0, messages.length - wouldKeep);
+    return {
+      totalMessages: messages.length,
+      wouldKeep,
+      wouldSummarize,
+      estimatedCost: this.estimateCost(messages)
+    };
+  }
+};
+
+// src/lib/condenser/index.ts
+var DEFAULT_CONFIG3 = {
+  enabled: true,
+  lightThreshold: 0.7,
+  mediumThreshold: 0.85,
+  heavyThreshold: 0.95,
+  modelLimit: 2e5,
+  model: "claude-sonnet-4-20250514",
+  pruning: {},
+  summarization: {}
+};
+var ContextCondenser = class {
+  config;
+  tracker;
+  deduplicator;
+  pruner;
+  summarizer;
+  /** Metrics for tracking */
+  metrics = {
+    condensationCount: 0,
+    tokensRecovered: 0,
+    lastLevel: "none"
+  };
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.tracker = createTracker(this.config.model);
+    this.tracker.limit = this.config.modelLimit;
+    this.deduplicator = new FileDeduplicator();
+    this.pruner = new TokenPruner(this.config.pruning);
+    this.summarizer = new ConversationSummarizer(this.config.summarization);
+  }
+  /**
+   * Main entry point - condense messages if needed.
+   *
+   * @param messages - Current conversation messages
+   * @returns Condensed messages and metadata
+   */
+  async condense(messages) {
+    const startTime = Date.now();
+    if (!this.config.enabled) {
+      return this.createResult(messages, messages, "none", startTime);
+    }
+    this.updateTrackerFromMessages(messages);
+    const level = getCompressionLevel(this.tracker, {
+      light: this.config.lightThreshold,
+      medium: this.config.mediumThreshold,
+      heavy: this.config.heavyThreshold
+    });
+    if (level === "none") {
+      return this.createResult(messages, messages, level, startTime);
+    }
+    let condensed;
+    switch (level) {
+      case "light":
+        condensed = this.applyDeduplication(messages);
+        break;
+      case "medium":
+        condensed = this.applyPruning(messages);
+        break;
+      case "heavy":
+        condensed = await this.applySummarization(messages);
+        break;
+    }
+    this.metrics.condensationCount++;
+    this.metrics.lastLevel = level;
+    return this.createResult(messages, condensed, level, startTime);
+  }
+  /**
+   * Apply light compression (deduplication).
+   */
+  applyDeduplication(messages) {
+    return messages;
+  }
+  /**
+   * Apply medium compression (pruning).
+   */
+  applyPruning(messages) {
+    return this.pruner.pruneMessages(messages);
+  }
+  /**
+   * Apply heavy compression (summarization).
+   */
+  async applySummarization(messages) {
+    const pruned = this.applyPruning(messages);
+    const summarized = await this.summarizer.summarize(pruned);
+    return summarized;
+  }
+  /**
+   * Update tracker from messages.
+   */
+  updateTrackerFromMessages(messages) {
+    this.tracker = createTracker(this.config.model);
+    this.tracker.limit = this.config.modelLimit;
+    for (const msg of messages) {
+      updateTrackerFromMessage(this.tracker, msg);
+    }
+  }
+  /**
+   * Create result object.
+   */
+  createResult(before, after, level, startTime) {
+    const tokensBefore = this.estimateTokens(before);
+    const tokensAfter = this.estimateTokens(after);
+    const savings = tokensBefore > 0 ? (tokensBefore - tokensAfter) / tokensBefore * 100 : 0;
+    if (level !== "none") {
+      this.metrics.tokensRecovered += tokensBefore - tokensAfter;
+    }
+    return {
+      messages: after,
+      level,
+      tokensBefore,
+      tokensAfter,
+      savingsPercentage: savings,
+      durationMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Estimate tokens for messages.
+   */
+  estimateTokens(messages) {
+    const tempTracker = createTracker(this.config.model);
+    for (const msg of messages) {
+      updateTrackerFromMessage(tempTracker, msg);
+    }
+    return tempTracker.used;
+  }
+  /**
+   * Get current tracker status.
+   */
+  getStatus() {
+    return formatTrackerStatus(this.tracker);
+  }
+  /**
+   * Get tracker for external monitoring.
+   */
+  getTracker() {
+    return { ...this.tracker };
+  }
+  /**
+   * Get metrics.
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Check if compression is needed.
+   */
+  needsCompression() {
+    return getCompressionLevel(this.tracker, {
+      light: this.config.lightThreshold,
+      medium: this.config.mediumThreshold,
+      heavy: this.config.heavyThreshold
+    });
+  }
+  /**
+   * Reset condenser state.
+   */
+  reset() {
+    this.tracker = createTracker(this.config.model);
+    this.tracker.limit = this.config.modelLimit;
+    this.deduplicator.reset();
+    this.metrics = {
+      condensationCount: 0,
+      tokensRecovered: 0,
+      lastLevel: "none"
+    };
+  }
+  /**
+   * Get file deduplicator for integration with tool layer.
+   */
+  getDeduplicator() {
+    return this.deduplicator;
+  }
+};
+function createCondenser(squadConfig) {
+  const condenserConfig = squadConfig?.condenser || {};
+  const modelConfig = squadConfig?.model || {};
+  return new ContextCondenser({
+    enabled: condenserConfig.enabled ?? true,
+    lightThreshold: condenserConfig.light_threshold ?? 0.7,
+    mediumThreshold: condenserConfig.medium_threshold ?? 0.85,
+    heavyThreshold: condenserConfig.heavy_threshold ?? 0.95,
+    model: modelConfig.default ?? "claude-sonnet-4-20250514",
+    pruning: {
+      protectRecent: condenserConfig.protect_recent ?? 4e4
+    }
+  });
 }
 export {
+  ContextCondenser,
+  ConversationSummarizer,
+  FileDeduplicator,
+  TokenPruner,
+  addGoalToSquad,
+  createCondenser,
+  createTracker,
+  estimateMessageTokens,
+  estimateTokens,
+  findProjectRoot,
+  findSquadsDir,
+  formatTrackerStatus,
+  getCompressionLevel,
+  getSquadLocalSkills,
+  listAgents,
+  listSquads,
+  loadAgentDefinition,
   loadSquad,
-  runAgent,
+  parseSquadFile,
+  resolveExecutionContext,
+  updateGoalInSquad,
+  updateTracker,
   version
 };
 //# sourceMappingURL=index.js.map