squads-cli 0.2.0 → 0.2.1

package/dist/run-I6KAXU6U.js

@@ -0,0 +1,4049 @@
+#!/usr/bin/env node
+import {
+  getCLIConfig,
+  isProviderCLIAvailable
+} from "./chunk-QHNUMM4V.js";
+import {
+  getOutcomeScoreModifier
+} from "./chunk-HF4WR7RA.js";
+import {
+  getBotGhEnv,
+  getBotGitEnv,
+  getBotPushUrl,
+  getCoAuthorTrailer
+} from "./chunk-FIWT2NMM.js";
+import {
+  detectProviderFromModel
+} from "./chunk-LOA3KWYJ.js";
+import {
+  parseCooldown
+} from "./chunk-RM6BWILN.js";
+import {
+  getApiUrl,
+  getBridgeUrl
+} from "./chunk-EHQJHRIW.js";
+import {
+  isLoggedIn,
+  loadSession
+} from "./chunk-Z2UKDBNL.js";
+import {
+  Events,
+  flushEvents,
+  track
+} from "./chunk-QJ7C7CMB.js";
+import {
+  findSimilarSquads,
+  findSquadsDir,
+  listAgents,
+  listSquads,
+  loadAgentDefinition,
+  loadSquad,
+  parseAgentProvider,
+  resolveMcpConfigPath
+} from "./chunk-TYFTF53O.js";
+import {
+  findMemoryDir
+} from "./chunk-ZTQ7ISUR.js";
+import {
+  RESET,
+  bold,
+  colors,
+  gradient,
+  icons,
+  writeLine
+} from "./chunk-M5FXNY6Y.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/commands/run.ts
+import ora from "ora";
+import { spawn, execSync as execSync3 } from "child_process";
+import { join as join5, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, cpSync, unlinkSync } from "fs";
+
+// src/lib/permissions.ts
+import { minimatch } from "minimatch";
+function getDefaultContext(squad, agent) {
+  return {
+    squad,
+    agent,
+    permissions: {
+      mode: "warn",
+      bash: ["*"],
+      // All commands allowed by default
+      write: ["**"],
+      // All paths writable by default
+      read: ["**"],
+      // All paths readable by default
+      mcp: {
+        allow: ["*"],
+        // All MCP servers allowed
+        deny: []
+      }
+    }
+  };
+}
+function validateBashCommand(command, allowedCommands) {
+  const baseCommand = command.trim().split(/\s+/)[0];
+  if (allowedCommands.includes("*")) {
+    return null;
+  }
+  const isAllowed = allowedCommands.some((allowed) => {
+    if (allowed === baseCommand) return true;
+    if (allowed.includes("*")) {
+      return minimatch(baseCommand, allowed);
+    }
+    return false;
+  });
+  if (!isAllowed) {
+    return {
+      type: "bash",
+      requested: baseCommand,
+      reason: `Bash command '${baseCommand}' not in allowlist: [${allowedCommands.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateFilePath(path, allowedGlobs, operation) {
+  if (allowedGlobs.includes("**") || allowedGlobs.includes("*")) {
+    return null;
+  }
+  const isAllowed = allowedGlobs.some((glob) => minimatch(path, glob));
+  if (!isAllowed) {
+    return {
+      type: operation,
+      requested: path,
+      reason: `${operation === "write" ? "Write" : "Read"} to '${path}' not allowed. Permitted paths: [${allowedGlobs.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateMcpServer(server, allow, deny) {
+  const isDenied = deny.some((pattern) => {
+    if (pattern === server) return true;
+    if (pattern.includes("*")) return minimatch(server, pattern);
+    return false;
+  });
+  if (isDenied) {
+    return {
+      type: "mcp",
+      requested: server,
+      reason: `MCP server '${server}' is explicitly denied`,
+      severity: "error"
+    };
+  }
+  if (allow.includes("*")) {
+    return null;
+  }
+  const isAllowed = allow.some((pattern) => {
+    if (pattern === server) return true;
+    if (pattern.includes("*")) return minimatch(server, pattern);
+    return false;
+  });
+  if (!isAllowed) {
+    return {
+      type: "mcp",
+      requested: server,
+      reason: `MCP server '${server}' not in allowlist: [${allow.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateExecution(context, request) {
+  const violations = [];
+  if (request.bashCommands) {
+    for (const cmd of request.bashCommands) {
+      const violation = validateBashCommand(cmd, context.permissions.bash);
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.writePaths) {
+    for (const path of request.writePaths) {
+      const violation = validateFilePath(path, context.permissions.write, "write");
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.readPaths) {
+    for (const path of request.readPaths) {
+      const violation = validateFilePath(path, context.permissions.read, "read");
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.mcpServers) {
+    for (const server of request.mcpServers) {
+      const violation = validateMcpServer(
+        server,
+        context.permissions.mcp.allow,
+        context.permissions.mcp.deny
+      );
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  const hasErrors = violations.some((v) => v.severity === "error");
+  const allowed = context.permissions.mode !== "strict" || !hasErrors;
+  return {
+    allowed,
+    violations,
+    mode: context.permissions.mode
+  };
+}
+function formatViolations(result) {
+  const lines = [];
+  if (result.violations.length === 0) {
+    return lines;
+  }
+  const modeLabel = {
+    warn: "\u26A0\uFE0F  PERMISSION WARNING",
+    strict: "\u{1F6AB} PERMISSION DENIED",
+    audit: "\u{1F4DD} PERMISSION AUDIT"
+  }[result.mode];
+  lines.push(modeLabel);
+  lines.push("");
+  for (const v of result.violations) {
+    const icon = v.severity === "error" ? "\u2717" : "\u26A0";
+    lines.push(`  ${icon} [${v.type}] ${v.reason}`);
+  }
+  if (result.mode === "warn") {
+    lines.push("");
+    lines.push("  Continuing with warnings (mode: warn)");
+  } else if (result.mode === "audit") {
+    lines.push("");
+    lines.push("  Logged for audit, continuing (mode: audit)");
+  } else if (!result.allowed) {
+    lines.push("");
+    lines.push("  Execution blocked (mode: strict)");
+  }
+  return lines;
+}
+function parsePermissionsYaml(content) {
+  const yamlMatch = content.match(/```ya?ml\n([\s\S]*?)```/);
+  if (!yamlMatch) return null;
+  const yamlContent = yamlMatch[1];
+  const permissions = {};
+  const modeMatch = yamlContent.match(/^\s*mode:\s*(warn|strict|audit)/m);
+  if (modeMatch) {
+    permissions.mode = modeMatch[1];
+  }
+  const bashMatch = yamlContent.match(/^\s*bash:\s*\[(.*?)\]/m);
+  if (bashMatch) {
+    permissions.bash = bashMatch[1].split(",").map((s) => s.trim());
+  }
+  const writeMatch = yamlContent.match(/^\s*write:\s*\[(.*?)\]/m);
+  if (writeMatch) {
+    permissions.write = writeMatch[1].split(",").map((s) => s.trim());
+  }
+  const readMatch = yamlContent.match(/^\s*read:\s*\[(.*?)\]/m);
+  if (readMatch) {
+    permissions.read = readMatch[1].split(",").map((s) => s.trim());
+  }
+  const mcpAllowMatch = yamlContent.match(/^\s*allow:\s*\[(.*?)\]/m);
+  const mcpDenyMatch = yamlContent.match(/^\s*deny:\s*\[(.*?)\]/m);
+  if (mcpAllowMatch || mcpDenyMatch) {
+    permissions.mcp = {
+      allow: mcpAllowMatch ? mcpAllowMatch[1].split(",").map((s) => s.trim()) : ["*"],
+      deny: mcpDenyMatch ? mcpDenyMatch[1].split(",").map((s) => s.trim()) : []
+    };
+  }
+  return Object.keys(permissions).length > 0 ? permissions : null;
+}
+function buildContextFromSquad(squadName, squadContent, agentName) {
+  const context = getDefaultContext(squadName, agentName);
+  const parsed = parsePermissionsYaml(squadContent);
+  if (parsed) {
+    if (parsed.mode) context.permissions.mode = parsed.mode;
+    if (parsed.bash) context.permissions.bash = parsed.bash;
+    if (parsed.write) context.permissions.write = parsed.write;
+    if (parsed.read) context.permissions.read = parsed.read;
+    if (parsed.mcp) context.permissions.mcp = parsed.mcp;
+  }
+  return context;
+}
+
+// src/lib/workflow.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, writeFileSync, mkdirSync } from "fs";
+import { execSync, exec } from "child_process";
+
+// src/lib/conversation.ts
+function classifyAgent(agentName, roleDescription) {
+  if (roleDescription) {
+    const lower = roleDescription.toLowerCase();
+    if (lower.includes("orchestrat") || lower.includes("triage") || lower.includes("coordinat")) return "lead";
+    if (lower.includes("scan") || lower.includes("monitor") || lower.includes("detect")) return "scanner";
+    if (lower.includes("verif") || lower.includes("review") || lower.includes("check") || lower.includes("critic")) return "verifier";
+    return "worker";
+  }
+  const name = agentName.toLowerCase();
+  if (name.includes("lead") || name.includes("orchestrator")) return "lead";
+  if (name.includes("scanner") || name.includes("scout") || name.includes("monitor")) return "scanner";
+  if (name.includes("verifier") || name.includes("critic") || name.includes("reviewer")) return "verifier";
+  if (name.includes("worker") || name.includes("solver") || name.includes("builder")) return "worker";
+  return null;
+}
+function modelForRole(role) {
+  switch (role) {
+    case "lead":
+      return "sonnet";
+    case "worker":
+      return "sonnet";
+    case "scanner":
+      return "haiku";
+    case "verifier":
+      return "haiku";
+  }
+}
+function createTranscript(squad) {
+  return {
+    squad,
+    turns: [],
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalCost: 0
+  };
+}
+function serializeTranscript(transcript) {
+  if (transcript.turns.length === 0) return "";
+  let turns = transcript.turns;
+  if (turns.length > 5) {
+    const firstBrief = turns[0];
+    let lastReviewIdx = -1;
+    for (let i = turns.length - 1; i > 0; i--) {
+      if (turns[i].role === "lead") {
+        lastReviewIdx = i;
+        break;
+      }
+    }
+    if (lastReviewIdx > 0) {
+      turns = [firstBrief, ...turns.slice(lastReviewIdx)];
+    } else {
+      turns = [firstBrief, ...turns.slice(-3)];
+    }
+  }
+  const lines = ["## Conversation So Far\n"];
+  if (turns.length < transcript.turns.length) {
+    lines.push(`*(${transcript.turns.length - turns.length} earlier turns compacted \u2014 lead review below summarizes prior work)*
+`);
+  }
+  for (const turn of turns) {
+    lines.push(`### ${turn.agent} (${turn.role}) \u2014 ${turn.timestamp}`);
+    lines.push(turn.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function addTurn(transcript, agent, role, content, estimatedCost) {
+  transcript.turns.push({
+    agent,
+    role,
+    content,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    estimatedCost
+  });
+  transcript.totalCost += estimatedCost;
+}
+var CONVERGENCE_PHRASES = [
+  "pr created",
+  "pr merged",
+  "issue closed",
+  "issue resolved",
+  "all tasks complete",
+  "all items complete",
+  "all issues resolved",
+  "nothing left to do",
+  "nothing remaining",
+  "session complete",
+  "queue empty",
+  "no open issues",
+  "no pending tasks",
+  "no pending issues"
+];
+var VERIFIER_APPROVAL_PHRASES = [
+  "approved",
+  "lgtm",
+  "looks good",
+  "all checks pass",
+  "all tests pass",
+  "tests pass",
+  "passed",
+  "quality standards met"
+];
+var VERIFIER_REJECTION_PHRASES = [
+  "failed",
+  "rejected",
+  "needs fixes",
+  "needs changes",
+  "does not pass",
+  "did not pass",
+  "failing"
+];
+var LEAD_COMPLETION_PHRASES = [
+  "session complete",
+  "session is complete",
+  "nothing to do",
+  "nothing more to do",
+  "nothing left to do",
+  "all work is done",
+  "all work complete",
+  "work is complete",
+  "work is done",
+  "all tasks complete",
+  "all tasks done",
+  "approved",
+  "approving",
+  "declaring convergence",
+  "signaling convergence",
+  "signal convergence",
+  "no further action",
+  "no further work",
+  "no action needed",
+  "no actions needed",
+  "wrapping up",
+  "closing out",
+  "conversation complete",
+  "cycle complete"
+];
+var CONTINUATION_PHRASES = [
+  "needs review",
+  "needs feedback",
+  "needs input",
+  "need clarification",
+  "todo",
+  "fixme",
+  "blocked",
+  "waiting for",
+  "waiting on",
+  "will continue",
+  "will proceed",
+  "will work on",
+  "next step",
+  "in progress"
+];
+function detectConvergence(transcript, maxTurns, costCeiling) {
+  if (transcript.turns.length >= maxTurns) {
+    return { converged: true, reason: `Max turns reached (${maxTurns})` };
+  }
+  if (transcript.totalCost >= costCeiling) {
+    return { converged: true, reason: `Cost ceiling reached ($${transcript.totalCost.toFixed(2)}/$${costCeiling})` };
+  }
+  if (transcript.turns.length === 0) {
+    return { converged: false, reason: "No turns yet" };
+  }
+  const lastTurn = transcript.turns[transcript.turns.length - 1];
+  const content = lastTurn.content;
+  const lower = content.toLowerCase();
+  if (lastTurn.role === "verifier") {
+    const rejected = VERIFIER_REJECTION_PHRASES.some((phrase) => lower.includes(phrase));
+    if (rejected) {
+      return { converged: false, reason: "Verifier rejected \u2014 continuing cycle" };
+    }
+    const approved = VERIFIER_APPROVAL_PHRASES.some((phrase) => lower.includes(phrase));
+    if (approved) {
+      return { converged: true, reason: "Verifier approved" };
+    }
+  }
+  if (lastTurn.role === "lead") {
+    const leadDone = LEAD_COMPLETION_PHRASES.some((phrase) => lower.includes(phrase));
+    if (leadDone) {
+      return { converged: true, reason: "Lead signaled completion" };
+    }
+  }
+  const hasContinuation = CONTINUATION_PHRASES.some((phrase) => lower.includes(phrase));
+  if (hasContinuation) {
+    return { converged: false, reason: "Continuation signal detected" };
+  }
+  const hasConvergence = CONVERGENCE_PHRASES.some((phrase) => lower.includes(phrase));
+  if (hasConvergence) {
+    return { converged: true, reason: "Convergence signal detected" };
+  }
+  return { converged: false, reason: "No signals detected, continuing" };
+}
+var COST_PER_TURN = {
+  opus: 2.5,
+  sonnet: 0.75,
+  haiku: 0.1
+};
+function estimateTurnCost(model) {
+  const key = model.includes("opus") ? "opus" : model.includes("haiku") ? "haiku" : "sonnet";
+  return COST_PER_TURN[key] || COST_PER_TURN.sonnet;
+}
+
+// src/lib/run-context.ts
+import { join, dirname } from "path";
+import { existsSync, readFileSync, readdirSync } from "fs";
+var ROLE_BUDGETS = {
+  scanner: 4e3,
+  // ~1000 tokens — identity + priorities + state
+  worker: 12e3,
+  // ~3000 tokens — + directives, feedback, active-work
+  lead: 24e3,
+  // ~6000 tokens — all sections
+  coo: 32e3
+  // ~8000 tokens — all sections + expanded
+};
+var ROLE_SECTIONS = {
+  scanner: /* @__PURE__ */ new Set([1, 2, 5]),
+  // SQUAD.md, priorities, state
+  worker: /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 6]),
+  // + directives, feedback, active-work
+  lead: /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+  // all sections
+  coo: /* @__PURE__ */ new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+  // all sections + expanded budget
+};
+function parseAgentFrontmatter(agentPath) {
+  if (!agentPath || !existsSync(agentPath)) return {};
+  let content;
+  try {
+    content = readFileSync(agentPath, "utf-8");
+  } catch {
+    return {};
+  }
+  if (!content) return {};
+  const lines = content.split("\n");
+  let inFrontmatter = false;
+  const yamlLines = [];
+  for (const line of lines) {
+    if (line.trim() === "---") {
+      if (inFrontmatter) break;
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      yamlLines.push(line);
+    }
+  }
+  if (yamlLines.length === 0) return {};
+  const yaml = yamlLines.join("\n");
+  const result = {};
+  const contextMatch = yaml.match(/context_from:\s*\[([^\]]+)\]/);
+  if (contextMatch) {
+    result.context_from = contextMatch[1].split(",").map((s) => s.trim());
+  }
+  const criteriaMatch = yaml.match(/acceptance_criteria:\s*\|\n((?:\s+.+\n?)*)/);
+  if (criteriaMatch) {
+    result.acceptance_criteria = criteriaMatch[1].replace(/^ {2}/gm, "").trim();
+  }
+  const retriesMatch = yaml.match(/max_retries:\s*(\d+)/);
+  if (retriesMatch) {
+    result.max_retries = parseInt(retriesMatch[1], 10);
+  }
+  const cooldownMatch = yaml.match(/cooldown:\s*["']?([^"'\n]+)["']?/);
+  if (cooldownMatch) {
+    result.cooldown = cooldownMatch[1].trim();
+  }
+  return result;
+}
+function extractMcpServersFromDefinition(definition) {
+  const servers = /* @__PURE__ */ new Set();
+  const knownServers = [
+    "chrome-devtools",
+    "firecrawl",
+    "context7",
+    "huggingface"
+  ];
+  for (const server of knownServers) {
+    if (definition.toLowerCase().includes(server)) {
+      servers.add(server);
+    }
+  }
+  const mcpMatch = definition.match(/mcp:\s*\n((?:\s*-\s*\S+\s*\n?)+)/i);
+  if (mcpMatch) {
+    const lines = mcpMatch[1].split("\n");
+    for (const line of lines) {
+      const serverMatch = line.match(/^\s*-\s*(\S+)/);
+      if (serverMatch) {
+        servers.add(serverMatch[1]);
+      }
+    }
+  }
+  return Array.from(servers);
+}
+function readAgentsFile(relativePath, warnLabel) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return "";
+  const filePath = join(dirname(squadsDir), relativePath);
+  if (!existsSync(filePath)) return "";
+  try {
+    return readFileSync(filePath, "utf-8").trim();
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: failed reading ${warnLabel}: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    return "";
+  }
+}
+function loadSystemProtocol() {
+  const systemMd = readAgentsFile("config/SYSTEM.md", "SYSTEM.md");
+  if (systemMd) return systemMd;
+  return loadApprovalInstructions();
+}
+function loadApprovalInstructions() {
+  return readAgentsFile("config/approval-instructions.md", "approval instructions");
+}
+function safeRead(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, "utf-8").trim() : "";
+  } catch {
+    return "";
+  }
+}
+function readDirMd(dirPath, maxChars) {
+  if (!existsSync(dirPath)) return "";
+  try {
+    const files = readdirSync(dirPath).filter((f) => f.endsWith(".md")).sort();
+    const parts = [];
+    let totalChars = 0;
+    for (const file of files) {
+      const content = safeRead(join(dirPath, file));
+      if (!content) continue;
+      if (totalChars + content.length > maxChars) break;
+      parts.push(content);
+      totalChars += content.length;
+    }
+    return parts.join("\n\n");
+  } catch {
+    return "";
+  }
+}
+function gatherSquadContext(squadName, agentName, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return "";
+  const memoryDir = findMemoryDir();
+  const role = options.role || "worker";
+  const budget = options.maxTokens ? options.maxTokens * 4 : ROLE_BUDGETS[role];
+  const allowedSections = ROLE_SECTIONS[role];
+  const sections = [];
+  let usedChars = 0;
+  function addSection(sectionNum, header, content, maxChars) {
+    if (!allowedSections.has(sectionNum)) return false;
+    if (!content) return false;
+    let text = content;
+    const cap = maxChars || budget - usedChars;
+    if (text.length > cap) {
+      text = text.substring(0, cap) + "\n...";
+    }
+    if (usedChars + text.length > budget) {
+      if (options.verbose) {
+        writeLine(`  ${colors.dim}Context budget exhausted at section ${sectionNum} (${header})${RESET}`);
+      }
+      return false;
+    }
+    sections.push(`## ${header}
+${text}`);
+    usedChars += text.length;
+    return true;
+  }
+  const squadFile = join(squadsDir, squadName, "SQUAD.md");
+  if (existsSync(squadFile)) {
+    try {
+      const content = readFileSync(squadFile, "utf-8");
+      const missionMatch = content.match(/## Mission[\s\S]*?(?=\n## |$)/i);
+      const squad = missionMatch ? missionMatch[0] : content.substring(0, 2e3);
+      addSection(1, `Squad: ${squadName}`, squad.trim());
+    } catch (e) {
+      if (options.verbose) writeLine(`  ${colors.dim}warn: failed reading SQUAD.md: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    }
+  }
+  if (memoryDir) {
+    const prioritiesFile = join(memoryDir, squadName, "priorities.md");
+    const goalsFile = join(memoryDir, squadName, "goals.md");
+    const file = existsSync(prioritiesFile) ? prioritiesFile : goalsFile;
+    const content = safeRead(file);
+    if (content) {
+      addSection(2, "Priorities", content);
+    }
+  }
+  if (memoryDir) {
+    const directivesFile = join(memoryDir, "company", "directives.md");
+    const content = safeRead(directivesFile);
+    if (content) {
+      addSection(3, "Directives", content);
+    }
+  }
+  if (memoryDir) {
+    const feedbackFile = join(memoryDir, squadName, "feedback.md");
+    const content = safeRead(feedbackFile);
+    if (content) {
+      addSection(4, "Feedback", content);
+    }
+  }
+  if (memoryDir) {
+    const stateFile = join(memoryDir, squadName, agentName, "state.md");
+    const content = safeRead(stateFile);
+    if (content) {
+      const stateCap = role === "scanner" ? 2e3 : void 0;
+      addSection(5, "Previous State", content, stateCap);
+    }
+  }
+  if (memoryDir) {
+    const activeWorkFile = join(memoryDir, squadName, "active-work.md");
+    const content = safeRead(activeWorkFile);
+    if (content) {
+      addSection(6, "Active Work", content);
+    }
+  }
+  if (memoryDir) {
+    const briefsDir = join(memoryDir, squadName, agentName, "briefs");
+    const content = readDirMd(briefsDir, 3e3);
+    if (content) {
+      addSection(7, "Agent Briefs", content);
+    }
+  }
+  if (memoryDir) {
+    const briefsDir = join(memoryDir, squadName, "_briefs");
+    const content = readDirMd(briefsDir, 3e3);
+    if (content) {
+      addSection(8, "Squad Briefs", content);
+    }
+  }
+  if (memoryDir) {
+    const dailyFile = join(memoryDir, "daily-briefing.md");
+    const content = safeRead(dailyFile);
+    if (content) {
+      addSection(9, "Daily Briefing", content);
+    }
+  }
+  if (memoryDir) {
+    const frontmatter = options.agentPath ? parseAgentFrontmatter(options.agentPath) : {};
+    const contextSquads = frontmatter.context_from || [];
+    const learningParts = [];
+    for (const ctx of contextSquads) {
+      const learningsFile = join(memoryDir, ctx, "shared", "learnings.md");
+      const content = safeRead(learningsFile);
+      if (content) {
+        learningParts.push(`### ${ctx}
+${content}`);
+      }
+    }
+    if (learningParts.length > 0) {
+      addSection(10, "Cross-Squad Learnings", learningParts.join("\n\n"));
+    }
+  }
+  if (sections.length === 0) return "";
+  if (options.verbose) {
+    writeLine(`  ${colors.dim}Context: ${sections.length} sections, ~${Math.ceil(usedChars / 4)} tokens (${role} role, budget: ~${Math.ceil(budget / 4)})${RESET}`);
+  }
+  return `
+# CONTEXT
+${sections.join("\n\n")}
+`;
+}
+
+// src/lib/workflow.ts
+var DEFAULT_MAX_TURNS = 20;
+var DEFAULT_COST_CEILING = 25;
+function executeAgentTurn(config) {
+  const { agentName, agentPath, role, squadName, model: _model, transcript, task } = config;
+  const transcriptContext = serializeTranscript(transcript);
+  const contextRole = agentName.includes("company-lead") ? "coo" : role;
+  const squadContext = gatherSquadContext(squadName, agentName, {
+    agentPath,
+    role: contextRole
+  });
+  let roleInstructions;
+  switch (role) {
+    case "lead":
+      if (transcript.turns.length === 0 && task) {
+        roleInstructions = `## Founder Directive
+
+${task}
+
+Brief the team on this directive. Set priorities and assign work.`;
+      } else if (transcript.turns.length === 0) {
+        roleInstructions = `## Your Role: Lead
+
+You are starting a new squad session. Brief the team:
+1. Review open issues and PRs
+2. Set priorities for this session
+3. Assign work to workers
+4. Be specific about what each worker should do`;
+      } else {
+        roleInstructions = `## Your Role: Lead (Review)
+
+Review the work done so far. Either:
+- Request specific changes from workers
+- Approve and signal completion if quality is sufficient
+- Merge PRs using \`gh pr merge --squash --delete-branch --auto\` (waits for required checks)`;
+      }
+      break;
+    case "scanner":
+      roleInstructions = `## Your Role: Scanner
+
+Scan for issues, gaps, and opportunities. Report findings concisely. Do NOT fix anything \u2014 just discover and report.`;
+      break;
+    case "worker":
+      roleInstructions = `## Your Role: Worker
+
+Execute the work assigned by the lead. Create branches, write code, open PRs to develop. Be focused and efficient.`;
+      break;
+    case "verifier":
+      roleInstructions = `## Your Role: Verifier
+
+Verify that work meets quality standards. Check PRs, run tests, validate output. Report pass/fail with specifics.`;
+      break;
+  }
+  const prompt = `You are ${agentName} (${role}) in squad ${squadName}.
+
+Read your full agent definition at ${agentPath} and follow its instructions.
+
+${roleInstructions}
+${squadContext}
+${transcriptContext}
+
+IMPORTANT:
+- Be concise. Your output becomes part of a shared transcript.
+- Reference specific issue numbers, PR numbers, and file paths.
+- If you create a PR, include the PR number in your output.
+- If there's nothing to do, say "Nothing to do" clearly.
+- When done, summarize what you did in 2-3 sentences.`;
+  const resolvedModel = config.model || modelForRole(role);
+  const { CLAUDECODE: _cc, ANTHROPIC_API_KEY: _ak, ...cleanEnv } = process.env;
+  const escapedPrompt = prompt.replace(/'/g, "'\\''");
+  try {
+    const output = execSync(
+      `claude --print --dangerously-skip-permissions --model ${resolvedModel} -- '${escapedPrompt}'`,
+      {
+        cwd: config.cwd || process.cwd(),
+        timeout: 15 * 60 * 1e3,
+        // 15 min per turn
+        maxBuffer: 10 * 1024 * 1024,
+        // 10MB
+        encoding: "utf-8",
+        env: cleanEnv
+      }
+    );
+    return output.trim();
+  } catch (err) {
+    const error = err;
+    if (error.stdout && error.stdout.trim().length > 0) {
+      return error.stdout.trim();
+    }
+    return `[ERROR] Agent ${agentName} failed: ${error.message || "unknown error"}`;
+  }
+}
+function executeAgentTurnAsync(config) {
+  const { agentName, agentPath, role, squadName, model: _model, transcript, task } = config;
+  let roleInstructions = "";
+  switch (role) {
+    case "lead":
+      roleInstructions = task ? `FOUNDER DIRECTIVE: ${task}
+
+Brief the team on this directive. Assign specific tasks to scanners and workers.` : "Review the conversation so far. Assess worker output. Direct next actions or declare convergence.";
+      break;
+    case "scanner":
+      roleInstructions = "Scan for issues, data, or signals relevant to the lead's brief. Report findings concisely.";
+      break;
+    case "worker":
+      roleInstructions = "Execute the specific task assigned by the lead. Produce concrete output (PRs, issues, content, analysis).";
+      break;
+    case "verifier":
+      roleInstructions = "Verify the worker's output meets quality standards. Check for errors, omissions, and alignment with goals.";
+      break;
+  }
+  const transcriptContext = transcript.turns.length > 0 ? `
+== CONVERSATION SO FAR ==
+${serializeTranscript(transcript)}
+== END CONVERSATION ==` : "";
+  const resolvedModel = config.model || modelForRole(role);
+  const prompt = `You are ${agentName} (${role}) in squad ${squadName}.
+
+Read your full agent definition at ${agentPath} and follow its instructions.
+
+${roleInstructions}
+
+${transcriptContext}
+
+IMPORTANT:
+- Be concise. Your output becomes part of a shared transcript.
+- Reference specific issue numbers, PR numbers, and file paths.
+- If you create a PR, include the PR number in your output.
+- If there's nothing to do, say "Nothing to do" clearly.
+- When done, summarize what you did in 2-3 sentences.`;
+  const escapedPrompt = prompt.replace(/'/g, "'\\''");
+  const { CLAUDECODE: _cc2, ANTHROPIC_API_KEY: _ak2, ...cleanEnvAsync } = process.env;
+  return new Promise((resolve) => {
+    exec(
+      `claude --print --dangerously-skip-permissions --model ${resolvedModel} -- '${escapedPrompt}'`,
+      {
+        cwd: config.cwd || process.cwd(),
+        timeout: 15 * 60 * 1e3,
+        maxBuffer: 10 * 1024 * 1024,
+        encoding: "utf-8",
+        env: cleanEnvAsync
+      },
+      (error, stdout, _stderr) => {
+        if (stdout && stdout.trim().length > 0) {
+          resolve(stdout.trim());
+        } else if (error) {
+          resolve(`[ERROR] Agent ${agentName} failed: ${error.message || "unknown error"}`);
+        } else {
+          resolve("[No output]");
+        }
+      }
+    );
+  });
+}
+function buildTurnPlan(squad, squadsDir) {
+  const agents = [];
+  for (const agent of squad.agents) {
+    const role = classifyAgent(agent.name, agent.role);
+    if (!role) continue;
+    const agentPath = join2(squadsDir, squad.dir, `${agent.name}.md`);
+    if (!existsSync2(agentPath)) continue;
+    agents.push({ name: agent.name, role, path: agentPath });
+  }
+  return agents;
+}
+async function runConversation(squad, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    return {
+      transcript: createTranscript(squad.name),
+      turnCount: 0,
+      totalCost: 0,
+      converged: true,
+      reason: "No squads directory found"
+    };
+  }
+  const maxTurns = options.maxTurns || DEFAULT_MAX_TURNS;
+  const costCeiling = options.costCeiling || DEFAULT_COST_CEILING;
+  const transcript = createTranscript(squad.name);
+  let squadCwd = process.cwd();
+  if (squad.repo) {
+    const repoName = squad.repo.split("/").pop();
+    if (repoName) {
+      const reposRoot = join2(squadsDir, "..", "..", "..");
+      const candidatePath = join2(reposRoot, repoName);
+      if (existsSync2(candidatePath)) {
+        squadCwd = candidatePath;
+      }
+    }
+  }
+  const allAgents = buildTurnPlan(squad, squadsDir);
+  const leads = allAgents.filter((a) => a.role === "lead");
+  const scanners = allAgents.filter((a) => a.role === "scanner");
+  const workers = allAgents.filter((a) => a.role === "worker");
+  const verifiers = allAgents.filter((a) => a.role === "verifier");
+  if (leads.length === 0) {
+    return {
+      transcript,
+      turnCount: 0,
+      totalCost: 0,
+      converged: true,
+      reason: "No lead agent found \u2014 cannot orchestrate conversation"
+    };
+  }
+  const lead = leads[0];
+  const log = (msg) => {
+    if (options.verbose) {
+      const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+      process.stderr.write(`  [${ts}] ${msg}
+`);
+    }
+  };
+  log(`Conversation: ${squad.name} | ${allAgents.length} agents | max ${maxTurns} turns | $${costCeiling} ceiling`);
+  log(`  Lead: ${lead.name} | Scanners: ${scanners.map((s) => s.name).join(", ") || "none"} | Workers: ${workers.map((w) => w.name).join(", ") || "none"} | Verifiers: ${verifiers.map((v) => v.name).join(", ") || "none"}`);
+  let cycleCount = 0;
+  const MAX_CYCLES = 5;
+  while (cycleCount < MAX_CYCLES) {
+    cycleCount++;
+    log(`
+--- Cycle ${cycleCount} ---`);
+    log(`Turn ${transcript.turns.length + 1}: ${lead.name} (lead)`);
+    const leadOutput = executeAgentTurn({
+      agentName: lead.name,
+      agentPath: lead.path,
+      role: "lead",
+      squadName: squad.name,
+      model: options.model || modelForRole("lead"),
+      transcript,
+      task: cycleCount === 1 ? options.task : void 0,
+      cwd: squadCwd
+    });
+    addTurn(transcript, lead.name, "lead", leadOutput, estimateTurnCost(options.model || "sonnet"));
+    let conv = detectConvergence(transcript, maxTurns, costCeiling);
+    if (conv.converged) {
+      log(`Converged after lead: ${conv.reason}`);
+      return { transcript, turnCount: transcript.turns.length, totalCost: transcript.totalCost, converged: true, reason: conv.reason };
+    }
+    if (cycleCount === 1 && scanners.length > 0) {
+      if (scanners.length === 1) {
+        log(`Turn ${transcript.turns.length + 1}: ${scanners[0].name} (scanner)`);
+        const output = executeAgentTurn({
+          agentName: scanners[0].name,
+          agentPath: scanners[0].path,
+          role: "scanner",
+          squadName: squad.name,
+          model: options.model || modelForRole("scanner"),
+          transcript,
+          cwd: squadCwd
+        });
+        addTurn(transcript, scanners[0].name, "scanner", output, estimateTurnCost(options.model || "haiku"));
+      } else {
+        log(`Turns ${transcript.turns.length + 1}-${transcript.turns.length + scanners.length}: ${scanners.map((s) => s.name).join(", ")} (scanners, parallel)`);
+        const scannerPromises = scanners.map(
+          (scanner) => executeAgentTurnAsync({
+            agentName: scanner.name,
+            agentPath: scanner.path,
+            role: "scanner",
+            squadName: squad.name,
+            model: options.model || modelForRole("scanner"),
+            transcript,
+            // snapshot — all scanners see same context
+            cwd: squadCwd
+          }).then((output) => ({ agent: scanner, output }))
+        );
+        const scannerResults = await Promise.all(scannerPromises);
+        for (const { agent, output } of scannerResults) {
+          addTurn(transcript, agent.name, "scanner", output, estimateTurnCost(options.model || "haiku"));
+        }
+      }
+      conv = detectConvergence(transcript, maxTurns, costCeiling);
+      if (conv.converged) {
+        return { transcript, turnCount: transcript.turns.length, totalCost: transcript.totalCost, converged: true, reason: conv.reason };
+      }
+    }
+    if (workers.length === 1) {
+      log(`Turn ${transcript.turns.length + 1}: ${workers[0].name} (worker)`);
+      const output = executeAgentTurn({
+        agentName: workers[0].name,
+        agentPath: workers[0].path,
+        role: "worker",
+        squadName: squad.name,
+        model: options.model || modelForRole("worker"),
+        transcript,
+        cwd: squadCwd
+      });
+      if (output.startsWith("[ERROR]")) {
+        process.stderr.write(`  [WARN] Worker ${workers[0].name} errored: ${output}
+`);
+      }
+      addTurn(transcript, workers[0].name, "worker", output, estimateTurnCost(options.model || "sonnet"));
+    } else if (workers.length > 1) {
+      log(`Turns ${transcript.turns.length + 1}-${transcript.turns.length + workers.length}: ${workers.map((w) => w.name).join(", ")} (workers, parallel)`);
+      const workerPromises = workers.map(
+        (worker) => executeAgentTurnAsync({
+          agentName: worker.name,
+          agentPath: worker.path,
+          role: "worker",
+          squadName: squad.name,
+          model: options.model || modelForRole("worker"),
+          transcript,
+          // snapshot — all workers see same context
+          cwd: squadCwd
+        }).then((output) => ({ agent: worker, output }))
+      );
+      const workerResults = await Promise.all(workerPromises);
+      for (const { agent, output } of workerResults) {
+        if (output.startsWith("[ERROR]")) {
+          process.stderr.write(`  [WARN] Worker ${agent.name} errored: ${output}
+`);
+        }
+        addTurn(transcript, agent.name, "worker", output, estimateTurnCost(options.model || "sonnet"));
+      }
+    }
+    conv = detectConvergence(transcript, maxTurns, costCeiling);
+    if (conv.converged) {
+      return { transcript, turnCount: transcript.turns.length, totalCost: transcript.totalCost, converged: true, reason: conv.reason };
+    }
+    log(`Turn ${transcript.turns.length + 1}: ${lead.name} (lead review)`);
+    const reviewOutput = executeAgentTurn({
+      agentName: lead.name,
+      agentPath: lead.path,
+      role: "lead",
+      squadName: squad.name,
+      model: options.model || modelForRole("lead"),
+      transcript,
+      cwd: squadCwd
+    });
+    addTurn(transcript, lead.name, "lead", reviewOutput, estimateTurnCost(options.model || "sonnet"));
+    conv = detectConvergence(transcript, maxTurns, costCeiling);
+    if (conv.converged) {
+      return { transcript, turnCount: transcript.turns.length, totalCost: transcript.totalCost, converged: true, reason: conv.reason };
+    }
+    if (verifiers.length === 1) {
+      log(`Turn ${transcript.turns.length + 1}: ${verifiers[0].name} (verifier)`);
+      const output = executeAgentTurn({
+        agentName: verifiers[0].name,
+        agentPath: verifiers[0].path,
+        role: "verifier",
+        squadName: squad.name,
+        model: options.model || modelForRole("verifier"),
+        transcript,
+        cwd: squadCwd
+      });
+      addTurn(transcript, verifiers[0].name, "verifier", output, estimateTurnCost(options.model || "haiku"));
+    } else if (verifiers.length > 1) {
+      log(`Turns ${transcript.turns.length + 1}-${transcript.turns.length + verifiers.length}: ${verifiers.map((v) => v.name).join(", ")} (verifiers, parallel)`);
+      const verifierPromises = verifiers.map(
+        (verifier) => executeAgentTurnAsync({
+          agentName: verifier.name,
+          agentPath: verifier.path,
+          role: "verifier",
+          squadName: squad.name,
+          model: options.model || modelForRole("verifier"),
+          transcript,
+          cwd: squadCwd
+        }).then((output) => ({ agent: verifier, output }))
+      );
+      const verifierResults = await Promise.all(verifierPromises);
+      for (const { agent, output } of verifierResults) {
+        addTurn(transcript, agent.name, "verifier", output, estimateTurnCost(options.model || "haiku"));
+      }
+    }
+    if (verifiers.length > 0) {
+      conv = detectConvergence(transcript, maxTurns, costCeiling);
+      if (conv.converged) {
+        return { transcript, turnCount: transcript.turns.length, totalCost: transcript.totalCost, converged: true, reason: conv.reason };
+      }
+    }
+  }
+  return {
+    transcript,
+    turnCount: transcript.turns.length,
+    totalCost: transcript.totalCost,
+    converged: false,
+    reason: `Max cycles reached (${MAX_CYCLES})`
+  };
+}
+function saveTranscript(transcript) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const convDir = join2(squadsDir, "..", "conversations", transcript.squad);
+  if (!existsSync2(convDir)) {
+    mkdirSync(convDir, { recursive: true });
+  }
+  const id = Date.now().toString(36);
+  const filePath = join2(convDir, `${id}.md`);
+  const lines = [
+    `# Conversation: ${transcript.squad}`,
+    `Started: ${transcript.startedAt}`,
+    `Turns: ${transcript.turns.length}`,
+    `Estimated cost: $${transcript.totalCost.toFixed(2)}`,
+    "",
+    "---",
+    ""
+  ];
+  for (const turn of transcript.turns) {
+    lines.push(`## ${turn.agent} (${turn.role}) \u2014 ${turn.timestamp}`);
+    lines.push("");
+    lines.push(turn.content);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  writeFileSync(filePath, lines.join("\n"));
+  return filePath;
+}
+
+// src/lib/api-client.ts
+var API_TIMEOUT_MS = 5e3;
+function getApiConfig() {
+  const session = loadSession();
+  if (!session?.accessToken || session.status !== "active") return null;
+  const apiUrl = getApiUrl();
+  return { apiUrl, token: session.accessToken };
+}
+async function apiRequest(path, method, body) {
+  const config = getApiConfig();
+  if (!config) return false;
+  try {
+    const response = await fetch(`${config.apiUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(API_TIMEOUT_MS)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function reportExecutionStart(squad, agent, executionId, metadata) {
+  const config = getApiConfig();
+  if (!config) return null;
+  try {
+    const response = await fetch(`${config.apiUrl}/agent-executions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify({
+        squad,
+        agent,
+        executor: "cli",
+        brief: metadata?.brief,
+        model: metadata?.model,
+        metadata: {
+          local_execution_id: executionId,
+          trigger: metadata?.trigger || "manual"
+        }
+      }),
+      signal: AbortSignal.timeout(API_TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.execution_id;
+  } catch {
+    return null;
+  }
+}
+async function reportConversationResult(executionId, result) {
+  return apiRequest(`/agent-executions/${executionId}`, "PATCH", {
+    status: result.converged ? "completed" : "stopped",
+    summary: `${result.converged ? "Converged" : "Stopped"}: ${result.reason}`,
+    cost_usd: result.totalCost,
+    extra_data: {
+      conversation: {
+        turn_count: result.turnCount,
+        total_cost: result.totalCost,
+        converged: result.converged,
+        reason: result.reason,
+        agents_involved: result.agentsInvolved
+      }
+    }
+  });
+}
+async function pushCognitionSignal(signal) {
+  return apiRequest("/cognition/signals", "POST", signal);
+}
+async function ingestMemorySignal(body) {
+  const config = getApiConfig();
+  if (!config) return null;
+  try {
+    const response = await fetch(`${config.apiUrl}/cognition/signals/ingest-memory`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(API_TIMEOUT_MS)
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/squad-loop.ts
+import { createHash } from "crypto";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+var MIN_PHANTOM_DURATION_MS = 30 * 1e3;
+var INGESTIBLE_FILES = ["state", "learnings", "executions"];
+var STATE_DIR = join3(homedir(), ".squads", "daemon");
+var STATE_FILE = join3(STATE_DIR, "state.json");
+function defaultState() {
+  return {
+    lastCycle: "",
+    dailyCost: 0,
+    dailyCostDate: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    recentRuns: [],
+    failCounts: {},
+    memoryHashes: {},
+    cooldowns: {}
+  };
+}
+function loadLoopState() {
+  if (!existsSync3(STATE_DIR)) mkdirSync2(STATE_DIR, { recursive: true });
+  if (!existsSync3(STATE_FILE)) return defaultState();
+  try {
+    const raw = JSON.parse(readFileSync2(STATE_FILE, "utf-8"));
+    if (!raw.cooldowns) raw.cooldowns = {};
+    if (!raw.memoryHashes) raw.memoryHashes = {};
+    return raw;
+  } catch {
+    return defaultState();
+  }
+}
+function saveLoopState(state) {
+  if (!existsSync3(STATE_DIR)) mkdirSync2(STATE_DIR, { recursive: true });
+  writeFileSync2(STATE_FILE, JSON.stringify(state, null, 2));
+}
+function classifyRunOutcome(exitCode, durationMs) {
+  if (exitCode !== 0) return "failed";
+  if (durationMs < MIN_PHANTOM_DURATION_MS) return "skipped";
+  return "completed";
+}
+function checkCooldown(state, squad, agentType, cooldownMs) {
+  const key = `${squad}:${agentType}`;
+  const lastDispatch = state.cooldowns[key];
+  if (lastDispatch === void 0) return true;
+  return Date.now() - lastDispatch >= cooldownMs;
+}
+function getOpenIssues(repo, ghEnv = {}) {
+  try {
+    const raw = execSync2(
+      `gh issue list -R ${repo} --state open --json number,title,labels --limit 20`,
+      { encoding: "utf-8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...ghEnv } }
+    );
+    const issues = JSON.parse(raw);
+    return issues.map((i) => ({
+      number: i.number,
+      title: i.title,
+      labels: i.labels.map((l) => l.name),
+      repo
+    }));
+  } catch {
+    return [];
+  }
+}
+function getLastRunAge(squad, agent) {
+  const memDir = findMemoryDir();
+  if (!memDir) return null;
+  const execPath = join3(memDir, squad, agent, "executions.md");
+  if (!existsSync3(execPath)) return null;
+  try {
+    const content = readFileSync2(execPath, "utf-8");
+    const timestamps = content.match(/\*\*(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\*\*/g);
+    if (!timestamps || timestamps.length === 0) return null;
+    const last = timestamps[timestamps.length - 1].replace(/\*\*/g, "");
+    const lastDate = new Date(last);
+    return Date.now() - lastDate.getTime();
+  } catch {
+    return null;
+  }
+}
+function hasUnresolvedEscalation(repo, ghEnv = {}) {
+  try {
+    const raw = execSync2(
+      `gh issue list -R ${repo} --label "blocked" --state open --json number,title --limit 1`,
+      { encoding: "utf-8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...ghEnv } }
+    );
+    const issues = JSON.parse(raw);
+    if (issues.length > 0) {
+      return { blocked: true, issue: issues[0] };
+    }
+    const raw2 = execSync2(
+      `gh issue list -R ${repo} --label "needs-human" --state open --json number,title --limit 1`,
+      { encoding: "utf-8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...ghEnv } }
+    );
+    const issues2 = JSON.parse(raw2);
+    if (issues2.length > 0) {
+      return { blocked: true, issue: issues2[0] };
+    }
+    return { blocked: false };
+  } catch {
+    return { blocked: false };
+  }
+}
+function getSquadRepos() {
+  const repos = {};
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return repos;
+  try {
+    const squads = listSquads(squadsDir);
+    for (const squad of squads) {
+      const squadMd = join3(squadsDir, squad, "SQUAD.md");
+      if (!existsSync3(squadMd)) continue;
+      const content = readFileSync2(squadMd, "utf-8");
+      const repoMatch = content.match(/^repo:\s*(.+)/m);
+      if (repoMatch) {
+        repos[squad] = repoMatch[1].trim();
+      }
+    }
+  } catch {
+  }
+  return repos;
+}
+function scoreSquads(state, squadRepos, ghEnv = {}) {
+  const signals = [];
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return signals;
+  let squads;
+  try {
+    squads = listSquads(squadsDir);
+  } catch {
+    return signals;
+  }
+  for (const squadName of squads) {
+    try {
+      const repo = squadRepos[squadName];
+      if (repo) {
+        const escalation = hasUnresolvedEscalation(repo, ghEnv);
+        if (escalation.blocked) {
+          signals.push({
+            squad: squadName,
+            score: 0,
+            reason: `PAUSED: unresolved escalation #${escalation.issue?.number} \u2014 ${escalation.issue?.title}`,
+            issues: []
+          });
+          continue;
+        }
+      }
+      const issues = repo ? getOpenIssues(repo, ghEnv) : [];
+      let score = 0;
+      let reason = "";
+      const CONVERSATION_ISSUE_THRESHOLD = 3;
+      const CONVERSATION_COOLDOWN_MS = 48 * 60 * 60 * 1e3;
+      const lastConvAge = getLastRunAge(squadName, "conversation");
+      const conversationStale = lastConvAge === null || lastConvAge > CONVERSATION_COOLDOWN_MS;
+      const useConversation = issues.length >= CONVERSATION_ISSUE_THRESHOLD && conversationStale;
+      const targetAgent = useConversation ? void 0 : "issue-solver";
+      if (repo) {
+        const p0Issues = issues.filter(
+          (i) => i.labels.some((l) => l.includes("P0") || l.includes("priority:P0"))
+        );
+        const p1Issues = issues.filter(
+          (i) => i.labels.some((l) => l.includes("P1") || l.includes("priority:P1"))
+        );
+        if (p0Issues.length > 0) {
+          score += 80;
+          reason = `${p0Issues.length} P0 issues: ${p0Issues[0].title}`;
+        } else if (p1Issues.length > 0) {
+          score += 60;
+          reason = `${p1Issues.length} P1 issues: ${p1Issues[0].title}`;
+        } else if (issues.length > 0) {
+          score += 30;
+          reason = `${issues.length} open issues`;
+        }
+      } else {
+        reason = "no repo configured \u2014 staleness-based dispatch";
+      }
+      if (useConversation) {
+        score += 10;
+        reason += " \u2192 conversation mode";
+      }
+      const agentForStaleness = targetAgent ?? "conversation";
+      const lastAge = getLastRunAge(squadName, agentForStaleness);
+      if (lastAge !== null) {
+        const hoursAgo = lastAge / (1e3 * 60 * 60);
+        if (hoursAgo > 48) {
+          score += 20;
+          reason += ` (stale: ${Math.floor(hoursAgo)}h since last run)`;
+        } else if (hoursAgo > 24) {
+          score += 10;
+          reason += ` (${Math.floor(hoursAgo)}h since last run)`;
+        } else if (hoursAgo < 2) {
+          score -= 30;
+          reason += ` (ran ${Math.floor(hoursAgo * 60)}m ago)`;
+        }
+      } else if (!repo) {
+        score += 15;
+        reason += " (never run)";
+      }
+      const failKey = `${squadName}:${agentForStaleness}`;
+      const failures = state.failCounts[failKey] || 0;
+      if (failures >= 3) {
+        score -= 40;
+        reason += ` (${failures} consecutive failures \u2014 needs human)`;
+      } else if (failures >= 1) {
+        score -= 10 * failures;
+      }
+      const outcomeModifier = getOutcomeScoreModifier(squadName, agentForStaleness);
+      if (outcomeModifier !== 0) {
+        score += outcomeModifier;
+        reason += ` (outcome: ${outcomeModifier > 0 ? "+" : ""}${outcomeModifier})`;
+      }
+      if (score > 0 && (issues.length > 0 || !repo)) {
+        signals.push({ squad: squadName, score, reason, agent: targetAgent, issues });
+      }
+    } catch {
+      continue;
+    }
+  }
+  signals.sort((a, b) => b.score - a.score);
+  return signals;
+}
+async function slackNotify(message) {
+  try {
+    const envPath = join3(homedir(), "agents-squads", "hq", ".env");
+    if (!existsSync3(envPath)) return;
+    const env = readFileSync2(envPath, "utf-8");
+    const tokenMatch = env.match(/SLACK_BOT_TOKEN=(.+)/);
+    if (!tokenMatch) return;
+    const token = tokenMatch[1].trim();
+    const founderId = "U0A6NQ3U0JG";
+    await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ channel: founderId, text: message }),
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch {
+  }
+}
+async function pushMemorySignals(squads, state, verbose) {
+  const memDir = findMemoryDir();
+  if (!memDir) return;
+  if (!state.memoryHashes) {
+    state.memoryHashes = {};
+  }
+  const promises = [];
+  for (const squad of squads) {
+    const squadPath = join3(memDir, squad);
+    if (!existsSync3(squadPath)) continue;
+    let agents;
+    try {
+      agents = readdirSync2(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      continue;
+    }
+    for (const agent of agents) {
+      for (const fileType of INGESTIBLE_FILES) {
+        const filePath = join3(squadPath, agent, `${fileType}.md`);
+        if (!existsSync3(filePath)) continue;
+        let content;
+        try {
+          content = readFileSync2(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        if (!content.trim()) continue;
+        const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+        const key = `${squad}/${agent}/${fileType}`;
+        if (state.memoryHashes[key] === hash) continue;
+        const p = ingestMemorySignal({
+          squad,
+          agent,
+          file_type: fileType,
+          content,
+          content_hash: hash
+        }).then((result) => {
+          if (result) {
+            state.memoryHashes[key] = hash;
+            if (verbose && result.status === "ingested") {
+              writeLine(`  ${colors.dim}Memory: ${key} \u2192 ${result.signals_created || 0} signals${RESET}`);
+            }
+          }
+        }).catch(() => {
+        });
+        promises.push(p);
+      }
+    }
+  }
+  if (promises.length > 0) {
+    await Promise.race([
+      Promise.allSettled(promises),
+      new Promise((resolve) => setTimeout(resolve, 1e4))
+    ]);
+  }
+}
+function computePhases(squadNames) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return /* @__PURE__ */ new Map([[0, squadNames || []]]);
+  const names = squadNames || listSquads(squadsDir);
+  const deps = /* @__PURE__ */ new Map();
+  const starSquads = [];
+  for (const name of names) {
+    const squad = loadSquad(name);
+    if (!squad) continue;
+    if (squad.depends_on && squad.depends_on.length === 1 && squad.depends_on[0] === "*") {
+      starSquads.push(name);
+      continue;
+    }
+    const validDeps = (squad.depends_on || []).filter((d) => names.includes(d));
+    if (squad.depends_on) {
+      const invalid = squad.depends_on.filter((d) => d !== "*" && !names.includes(d));
+      if (invalid.length > 0) {
+        writeLine(`  ${colors.dim}warn: ${name} depends_on unknown squads: ${invalid.join(", ")}${RESET}`);
+      }
+    }
+    deps.set(name, validDeps);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const [squad, squadDeps] of deps) {
+    if (!inDegree.has(squad)) inDegree.set(squad, 0);
+    for (const dep of squadDeps) {
+      if (!adjList.has(dep)) adjList.set(dep, []);
+      adjList.get(dep).push(squad);
+      inDegree.set(squad, (inDegree.get(squad) || 0) + 1);
+      if (!inDegree.has(dep)) inDegree.set(dep, 0);
+    }
+  }
+  for (const [squad] of deps) {
+    if (!inDegree.has(squad)) inDegree.set(squad, 0);
+  }
+  const phases = /* @__PURE__ */ new Map();
+  let phase = 0;
+  const processed = /* @__PURE__ */ new Set();
+  const remaining = /* @__PURE__ */ new Set([...deps.keys()]);
+  while (remaining.size > 0) {
+    const ready = [];
+    for (const squad of remaining) {
+      if ((inDegree.get(squad) || 0) <= 0) {
+        ready.push(squad);
+      }
+    }
+    if (ready.length === 0) {
+      const cycled = [...remaining];
+      if (!phases.has(phase)) phases.set(phase, []);
+      phases.get(phase).push(...cycled);
+      for (const s of cycled) processed.add(s);
+      break;
+    }
+    phases.set(phase, ready);
+    for (const squad of ready) {
+      processed.add(squad);
+      remaining.delete(squad);
+      for (const dependent of adjList.get(squad) || []) {
+        inDegree.set(dependent, (inDegree.get(dependent) || 0) - 1);
+      }
+    }
+    phase++;
+  }
+  if (starSquads.length > 0) {
+    phases.set(phase, starSquads);
+  }
+  return phases;
+}
+function scoreSquadsForPhase(phaseSquads, state, squadRepos, ghEnv) {
+  const allSignals = scoreSquads(state, squadRepos, ghEnv);
+  return allSignals.filter((s) => phaseSquads.includes(s.squad));
+}
+
+// src/lib/cognition.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { spawnSync } from "child_process";
+var COGNITION_DIR_NAME = "cognition";
+var STATE_FILE2 = "state.json";
+var SYNTHESIZE_INTERVAL_MS = 30 * 60 * 1e3;
+var REFLECT_INTERVAL_MS = 4 * 60 * 60 * 1e3;
+var MAX_SIGNALS_KEPT = 500;
+var MAX_REFLECTIONS_KEPT = 50;
+var CONFIDENCE_PRIOR_WEIGHT = 0.7;
+var CONFIDENCE_EVIDENCE_WEIGHT = 0.3;
+var CONFIDENCE_MIN = 0.05;
+var CONFIDENCE_MAX = 0.95;
+var BELIEF_SHIFT_THRESHOLD = 0.15;
+var MAX_SUPPORTING_IDS = 20;
+var INGESTIBLE_FILES2 = ["state", "learnings", "executions"];
+var FILE_TYPE_MAPPING = {
+  state: { source: "memory", signal_type: "state_update" },
+  learnings: { source: "memory", signal_type: "learning" },
+  executions: { source: "execution", signal_type: "execution_log" },
+  events: { source: "market", signal_type: "external_event" },
+  directives: { source: "execution", signal_type: "directive" }
+};
+function callClaude(prompt, model, timeoutMs) {
+  const { CLAUDECODE: _, ANTHROPIC_API_KEY: _k, ...cleanEnv } = process.env;
+  const result = spawnSync("claude", ["--print", "--model", model], {
+    input: prompt,
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    env: cleanEnv,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0 || !result.stdout) return null;
+  return result.stdout;
+}
+function getCognitionDir() {
+  const memDir = findMemoryDir();
+  const dir = memDir ? join4(memDir, COGNITION_DIR_NAME) : join4(process.cwd(), ".agents", "memory", COGNITION_DIR_NAME);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  return dir;
+}
+function defaultState2() {
+  return {
+    signals: [],
+    beliefs: [],
+    decisions: [],
+    reflections: [],
+    last_synthesize: null,
+    last_reflect: null,
+    next_signal_id: 1,
+    next_decision_id: 1,
+    next_reflection_id: 1,
+    memory_hashes: {}
+  };
+}
+function loadCognitionState() {
+  const dir = getCognitionDir();
+  const path = join4(dir, STATE_FILE2);
+  if (!existsSync4(path)) return defaultState2();
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return defaultState2();
+  }
+}
+function saveCognitionState(state) {
+  const dir = getCognitionDir();
+  writeFileSync3(join4(dir, STATE_FILE2), JSON.stringify(state, null, 2));
+}
+function addSignal(state, signal) {
+  const newSignal = {
+    ...signal,
+    id: state.next_signal_id++,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state.signals.push(newSignal);
+  if (state.signals.length > MAX_SIGNALS_KEPT) {
+    state.signals = state.signals.slice(-MAX_SIGNALS_KEPT);
+  }
+  pushCognitionSignal({
+    source: signal.source,
+    signal_type: signal.signal_type,
+    value: signal.value ?? void 0,
+    unit: signal.unit ?? void 0,
+    data: signal.data,
+    entity_type: signal.entity_type ?? void 0,
+    entity_id: signal.entity_id ?? void 0,
+    confidence: signal.confidence
+  });
+  return newSignal;
+}
+function ingestMemoryFiles(state, squads, verbose = false) {
+  const memDir = findMemoryDir();
+  if (!memDir) return 0;
+  let signalsCreated = 0;
+  for (const squad of squads) {
+    const squadPath = join4(memDir, squad);
+    if (!existsSync4(squadPath)) continue;
+    let agents;
+    try {
+      agents = readdirSync3(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== COGNITION_DIR_NAME).map((e) => e.name);
+    } catch {
+      continue;
+    }
+    for (const agent of agents) {
+      for (const fileType of INGESTIBLE_FILES2) {
+        const filePath = join4(squadPath, agent, `${fileType}.md`);
+        if (!existsSync4(filePath)) continue;
+        let content;
+        try {
+          content = readFileSync3(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        if (!content.trim()) continue;
+        const hash = createHash2("sha256").update(content).digest("hex").slice(0, 16);
+        const key = `${squad}/${agent}/${fileType}`;
+        if (state.memory_hashes[key] === hash) continue;
+        state.memory_hashes[key] = hash;
+        const mapping = FILE_TYPE_MAPPING[fileType] || FILE_TYPE_MAPPING.state;
+        const bullets = content.split("\n").filter((line) => line.trim().startsWith("- ") || line.trim().startsWith("* ")).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 10);
+        if (bullets.length === 0) {
+          addSignal(state, {
+            source: mapping.source,
+            signal_type: mapping.signal_type,
+            value: null,
+            unit: null,
+            data: { content: content.slice(0, 500), content_hash: hash },
+            entity_type: "memory_file",
+            entity_id: key,
+            confidence: 0.8
+          });
+          signalsCreated++;
+        } else {
+          for (const bullet of bullets.slice(0, 10)) {
+            addSignal(state, {
+              source: mapping.source,
+              signal_type: mapping.signal_type,
+              value: null,
+              unit: null,
+              data: { content: bullet, file: key, content_hash: hash },
+              entity_type: "memory_file",
+              entity_id: key,
+              confidence: 0.8
+            });
+            signalsCreated++;
+          }
+        }
+        ingestMemorySignal({ squad, agent, file_type: fileType, content, content_hash: hash });
+        if (verbose) {
+          writeLine(`    ${colors.dim}Cognition: ${key} \u2192 ${bullets.length || 1} signals${RESET}`);
+        }
+      }
+    }
+  }
+  return signalsCreated;
+}
+async function synthesizeSignals(state, verbose = false) {
+  if (state.beliefs.length === 0) return 0;
+  const cutoff = state.last_synthesize ? new Date(state.last_synthesize).getTime() : 0;
+  const recentSignals = state.signals.filter(
+    (s) => new Date(s.created_at).getTime() > cutoff
+  );
+  if (recentSignals.length === 0) return 0;
+  let beliefsUpdated = 0;
+  for (const belief of state.beliefs) {
+    const signalList = recentSignals.map((s, i) => `${i + 1}. [${s.source}] ${s.signal_type}${s.value !== null ? " = " + s.value : ""}${s.unit ? " " + s.unit : ""}: ${(s.data.content || "").slice(0, 100)}`).join("\n");
+    const prompt = `Given this belief: "${belief.statement}"
+
+Classify each signal as SUPPORTING or CONTRADICTING or NEUTRAL.
+
+Signals:
+${signalList}
+
+Respond with JSON only: {"supporting": [indexes], "contradicting": [indexes], "neutral": [indexes]}`;
+    try {
+      const result = callClaude(prompt, "haiku", 3e4);
+      if (!result) continue;
+      const jsonMatch = result.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) continue;
+      const classification = JSON.parse(jsonMatch[0]);
+      const supportingCount = classification.supporting?.length || 0;
+      const contradictingCount = classification.contradicting?.length || 0;
+      if (supportingCount + contradictingCount === 0) continue;
+      const supportingIds = (classification.supporting || []).map((i) => recentSignals[i - 1]?.id).filter((id) => id !== void 0);
+      const contradictingIds = (classification.contradicting || []).map((i) => recentSignals[i - 1]?.id).filter((id) => id !== void 0);
+      const oldConfidence = belief.confidence;
+      const evidenceRatio = supportingCount / (supportingCount + contradictingCount);
+      let newConfidence = oldConfidence * CONFIDENCE_PRIOR_WEIGHT + evidenceRatio * CONFIDENCE_EVIDENCE_WEIGHT;
+      newConfidence = Math.max(CONFIDENCE_MIN, Math.min(CONFIDENCE_MAX, newConfidence));
+      belief.confidence = newConfidence;
+      belief.supporting_signals = [...belief.supporting_signals, ...supportingIds].slice(-MAX_SUPPORTING_IDS);
+      belief.contradicting_signals = [...belief.contradicting_signals, ...contradictingIds].slice(-MAX_SUPPORTING_IDS);
+      belief.revision++;
+      belief.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      belief.temperature = "hot";
+      beliefsUpdated++;
+      const shift = Math.abs(newConfidence - oldConfidence);
+      if (shift >= BELIEF_SHIFT_THRESHOLD) {
+        const direction = newConfidence > oldConfidence ? "\u2191" : "\u2193";
+        slackNotify(
+          `*Belief shift* ${direction} ${belief.belief_key}: ${(oldConfidence * 100).toFixed(0)}% \u2192 ${(newConfidence * 100).toFixed(0)}%
+${belief.statement}`
+        );
+      }
+      if (verbose) {
+        writeLine(`    ${colors.dim}Belief: ${belief.belief_key} ${(oldConfidence * 100).toFixed(0)}% \u2192 ${(newConfidence * 100).toFixed(0)}% (+${supportingCount}/-${contradictingCount})${RESET}`);
+      }
+    } catch {
+      continue;
+    }
+  }
+  state.last_synthesize = (/* @__PURE__ */ new Date()).toISOString();
+  return beliefsUpdated;
+}
+function evaluateDecisions(state) {
+  const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1e3;
+  let evaluated = 0;
+  for (const decision of state.decisions) {
+    if (decision.outcome_score !== null) continue;
+    if (new Date(decision.decided_at).getTime() > twoHoursAgo) continue;
+    const decisionTime = new Date(decision.decided_at).getTime();
+    const relevantSignals = state.signals.filter(
+      (s) => new Date(s.created_at).getTime() > decisionTime
+    );
+    const completed = relevantSignals.filter(
+      (s) => s.signal_type === "agent_completed" || s.signal_type === "conversation_converged"
+    ).length;
+    const failed = relevantSignals.filter(
+      (s) => s.signal_type === "agent_failed" || s.signal_type === "conversation_stopped"
+    ).length;
+    if (completed + failed < 3) continue;
+    decision.outcome_score = completed / (completed + failed) * 2 - 1;
+    decision.actual_outcome = { completed, failed, total: completed + failed };
+    evaluated++;
+  }
+  return evaluated;
+}
+async function reflect(state, verbose = false) {
+  if (state.last_reflect) {
+    const elapsed = Date.now() - new Date(state.last_reflect).getTime();
+    if (elapsed < REFLECT_INTERVAL_MS) return null;
+  }
+  const lastReflectTime = state.last_reflect ? new Date(state.last_reflect).getTime() : 0;
+  const newSignals = state.signals.filter((s) => new Date(s.created_at).getTime() > lastReflectTime);
+  if (newSignals.length === 0) return null;
+  const beliefsText = state.beliefs.map((b) => `- [${b.domain}] ${b.belief_key} (${(b.confidence * 100).toFixed(0)}%, ${b.temperature}, r${b.revision}): ${b.statement}`).join("\n");
+  const signalsText = newSignals.slice(-30).map((s) => `- [${s.source}] ${s.signal_type}: ${(s.data.content || "").slice(0, 80)} (${new Date(s.created_at).toLocaleTimeString()})`).join("\n");
+  const decisionsText = state.decisions.map((d) => `- ${d.title} (score: ${d.outcome_score !== null ? d.outcome_score.toFixed(2) : "pending"})`).join("\n");
+  const lastReflection = state.reflections.length > 0 ? state.reflections[state.reflections.length - 1] : null;
+  const prompt = `You are the cognition engine for an AI-native company called Agents Squads.
+Your job is to reflect on the current state of the business and produce actionable insights.
+
+## Current Beliefs (world model)
+${beliefsText || "(none)"}
+
+## Recent Signals (since last reflection)
+${signalsText || "(none)"}
+
+## Decision Journal
+${decisionsText || "(none)"}
+
+${lastReflection ? `Previous reflection (${lastReflection.created_at}):
+${lastReflection.assessment}
+` : ""}
+
+## Your Task
+Produce a business reflection. Respond as JSON only:
+{
+  "assessment": "2-3 sentence summary of business state",
+  "insights": [{"type": "highlight|warning|recommendation", "message": "..."}],
+  "belief_updates": [{"belief_key": "...", "suggested_confidence": 0.X, "reason": "..."}],
+  "priority_adjustments": [{"description": "...", "urgency": "high|medium|low"}],
+  "founder_escalations": [{"issue": "...", "why_human_needed": "...", "suggested_action": "...", "urgency": "immediate|today|this_week"}]
+}`;
+  try {
+    const result = callClaude(prompt, "sonnet", 6e4);
+    if (!result) return null;
+    const jsonMatch = result.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    const parsed = JSON.parse(jsonMatch[0]);
+    const reflection = {
+      id: state.next_reflection_id++,
+      scope: "business",
+      assessment: parsed.assessment || "",
+      insights: parsed.insights || [],
+      belief_updates: parsed.belief_updates || [],
+      priority_adjustments: parsed.priority_adjustments || [],
+      founder_escalations: parsed.founder_escalations || [],
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.reflections.push(reflection);
+    if (state.reflections.length > MAX_REFLECTIONS_KEPT) {
+      state.reflections = state.reflections.slice(-MAX_REFLECTIONS_KEPT);
+    }
+    for (const update of reflection.belief_updates) {
+      const belief = state.beliefs.find((b) => b.belief_key === update.belief_key);
+      if (belief && update.suggested_confidence >= 0 && update.suggested_confidence <= 1) {
+        belief.confidence = update.suggested_confidence;
+        belief.revision++;
+        belief.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+        belief.temperature = "hot";
+      }
+    }
+    if (reflection.founder_escalations.length > 0) {
+      const escalationText = reflection.founder_escalations.map((e) => `\u2022 *${e.issue}*: ${e.suggested_action} (${e.urgency})`).join("\n");
+      slackNotify(`\u{1F9E0} *Cognition reflection*
+${reflection.assessment}
+
+*Escalations:*
+${escalationText}`);
+    } else if (verbose) {
+      slackNotify(`\u{1F9E0} *Cognition reflection*
+${reflection.assessment}`);
+    }
+    state.last_reflect = (/* @__PURE__ */ new Date()).toISOString();
+    if (verbose) {
+      writeLine(`    ${colors.dim}Reflection: ${reflection.insights.length} insights, ${reflection.belief_updates.length} belief updates, ${reflection.founder_escalations.length} escalations${RESET}`);
+    }
+    return reflection;
+  } catch {
+    return null;
+  }
+}
+function updateBeliefTemperatures(state) {
+  const now = Date.now();
+  for (const belief of state.beliefs) {
+    const age = now - new Date(belief.updated_at).getTime();
+    if (age < 4 * 60 * 60 * 1e3) {
+      belief.temperature = "hot";
+    } else if (age < 24 * 60 * 60 * 1e3) {
+      belief.temperature = "warm";
+    } else {
+      belief.temperature = "cold";
+    }
+  }
+}
+async function runCognitionCycle(squads, verbose = false) {
+  const state = loadCognitionState();
+  const signalsIngested = ingestMemoryFiles(state, squads, verbose);
+  let beliefsUpdated = 0;
+  const timeSinceSynthesize = state.last_synthesize ? Date.now() - new Date(state.last_synthesize).getTime() : Infinity;
+  if (timeSinceSynthesize >= SYNTHESIZE_INTERVAL_MS && state.signals.length > 0) {
+    beliefsUpdated = await synthesizeSignals(state, verbose);
+  }
+  const decisionsEvaluated = evaluateDecisions(state);
+  const reflection = await reflect(state, verbose);
+  updateBeliefTemperatures(state);
+  saveCognitionState(state);
+  if (verbose || signalsIngested > 0 || beliefsUpdated > 0 || reflection) {
+    writeLine(`  ${colors.dim}Cognition: ${signalsIngested} signals, ${beliefsUpdated} beliefs updated${reflection ? ", reflected" : ""}${RESET}`);
+  }
+  return {
+    signalsIngested,
+    beliefsUpdated,
+    decisionsEvaluated,
+    reflected: !!reflection
+  };
+}
+function seedBeliefsIfEmpty(state) {
+  if (state.beliefs.length > 0) return;
+  const seeds = [
+    { belief_key: "retention_critical", domain: "product", statement: "D1 retention (10%) is the primary blocker to product-market fit. Must reach 30% before monetizing.", confidence: 0.9 },
+    { belief_key: "cli_is_os", domain: "product", statement: "The CLI is our operating system. Every improvement multiplies autonomous capability.", confidence: 0.85 },
+    { belief_key: "zero_revenue", domain: "revenue", statement: "Revenue is $0. Consulting is the near-term path. Pro tier gated on retention.", confidence: 0.95 },
+    { belief_key: "agent_autonomy_low", domain: "operations", statement: "Agents run but do not think autonomously. Scanners and leads never fire. Intelligence loop is broken.", confidence: 0.8 },
+    { belief_key: "first_run_broken", domain: "product", statement: "First-run experience is broken. v0.7.0 crashes on squads run. Users cannot complete the core flow.", confidence: 0.9 },
+    { belief_key: "global_developer_focus", domain: "market", statement: "Target market is global developers, not Chilean enterprises. Product-first, not consulting-first.", confidence: 0.75 },
+    { belief_key: "test_user_simulation", domain: "operations", statement: "Simulating test users (fresh install \u2192 init \u2192 run \u2192 evaluate friction) is the most effective way to find and fix retention blockers.", confidence: 0.7 },
+    { belief_key: "cognition_engine_needed", domain: "operations", statement: "Without a working cognition engine, the organization cannot learn or improve autonomously. This is the difference between a cron job and intelligence.", confidence: 0.85 }
+  ];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const seed of seeds) {
+    state.beliefs.push({
+      ...seed,
+      supporting_signals: [],
+      contradicting_signals: [],
+      temperature: "warm",
+      revision: 1,
+      updated_at: now
+    });
+  }
+}
+
+// src/commands/run.ts
+var CLOUD_POLL_INTERVAL_MS = 3e3;
+var CLOUD_POLL_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_LEARNINGS_LIMIT = 5;
+var EXECUTION_EVENT_TIMEOUT_MS = 5e3;
+var VERIFICATION_STATE_MAX_CHARS = 2e3;
+var VERIFICATION_EXEC_TIMEOUT_MS = 3e4;
+var DRYRUN_DEF_MAX_CHARS = 500;
+var DRYRUN_CONTEXT_MAX_CHARS = 800;
+var DEFAULT_SCHEDULED_COOLDOWN_MS = 6 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MINUTES = 30;
+var SOFT_DEADLINE_RATIO = 0.7;
+var LOG_FILE_INIT_DELAY_MS = 500;
+var VERBOSE_COMMAND_MAX_CHARS = 50;
+async function registerContextWithBridge(ctx) {
+  const bridgeUrl = getBridgeUrl();
+  try {
+    const response = await fetch(`${bridgeUrl}/api/context/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        execution_id: ctx.executionId,
+        squad: ctx.squad,
+        agent: ctx.agent,
+        task_type: ctx.taskType,
+        trigger: ctx.trigger
+      }),
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) {
+      return false;
+    }
+    return true;
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: bridge registration failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    return false;
+  }
+}
+async function checkPreflightGates(squad, agent) {
+  const bridgeUrl = getBridgeUrl();
+  try {
+    const response = await fetch(`${bridgeUrl}/api/execution/preflight`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ squad, agent }),
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!response.ok) {
+      return { allowed: true, gates: {} };
+    }
+    return await response.json();
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: preflight gate check failed (allowing execution): ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    return { allowed: true, gates: {} };
+  }
+}
+async function fetchLearnings(squad, limit = DEFAULT_LEARNINGS_LIMIT) {
+  const bridgeUrl = getBridgeUrl();
+  try {
+    const response = await fetch(
+      `${bridgeUrl}/api/learnings/relevant?squad=${encodeURIComponent(squad)}&limit=${limit}`,
+      { signal: AbortSignal.timeout(3e3) }
+    );
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return data.learnings || [];
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: learnings fetch failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    return [];
+  }
+}
+function generateExecutionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `exec_${timestamp}_${random}`;
+}
+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 = join5(home, ".claude", "mcp-configs");
+  const squadConfigs = {
+    website: "website.json",
+    research: "research.json",
+    intelligence: "research.json",
+    analytics: "data.json",
+    engineering: "data.json"
+  };
+  const configFile = squadConfigs[squadName.toLowerCase()];
+  if (configFile) {
+    const configPath = join5(configsDir, configFile);
+    if (existsSync5(configPath)) {
+      return configPath;
+    }
+  }
+  return "";
+}
+function detectTaskType(agentName) {
+  const name = agentName.toLowerCase();
+  if (name.includes("eval") || name.includes("critic") || name.includes("review") || name.includes("test")) {
+    return "evaluation";
+  }
+  if (name.includes("lead") || name.includes("orchestrator")) {
+    return "lead";
+  }
+  if (name.includes("research") || name.includes("analyst") || name.includes("intel")) {
+    return "research";
+  }
+  return "execution";
+}
+function getClaudeModelAlias(model) {
+  const lower = model.toLowerCase();
+  if (lower === "opus" || lower === "sonnet" || lower === "haiku") {
+    return lower;
+  }
+  if (lower.includes("opus")) return "opus";
+  if (lower.includes("sonnet")) return "sonnet";
+  if (lower.includes("haiku")) return "haiku";
+  return void 0;
+}
+function resolveModel(explicitModel, squad, taskType) {
+  if (explicitModel) {
+    return explicitModel;
+  }
+  const modelConfig = squad?.context?.model;
+  if (!modelConfig) {
+    return void 0;
+  }
+  switch (taskType) {
+    case "evaluation":
+      return modelConfig.cheap || modelConfig.default;
+    case "lead":
+      return modelConfig.expensive || modelConfig.default;
+    case "research":
+    case "execution":
+    default:
+      return modelConfig.default;
+  }
+}
+function ensureProjectTrusted(projectPath) {
+  const configPath = join5(process.env.HOME || "", ".claude.json");
+  if (!existsSync5(configPath)) {
+    return;
+  }
+  try {
+    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    if (!config.projects) {
+      config.projects = {};
+    }
+    if (!config.projects[projectPath]) {
+      config.projects[projectPath] = {};
+    }
+    if (!config.projects[projectPath].hasTrustDialogAccepted) {
+      config.projects[projectPath].hasTrustDialogAccepted = true;
+      writeFileSync4(configPath, JSON.stringify(config, null, 2));
+    }
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: config update failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+  }
+}
+function getProjectRoot() {
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    return dirname2(dirname2(squadsDir));
+  }
+  return process.cwd();
+}
+function getExecutionLogPath(squadName, agentName) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return null;
+  return join5(memoryDir, squadName, agentName, "executions.md");
+}
+function logExecution(record) {
+  const logPath = getExecutionLogPath(record.squadName, record.agentName);
+  if (!logPath) return;
+  const dir = dirname2(logPath);
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync5(logPath)) {
+    content = readFileSync4(logPath, "utf-8").trimEnd();
+  } else {
+    content = `# ${record.squadName}/${record.agentName} - Execution Log`;
+  }
+  const entry = `
+
+---
+<!-- exec:${record.executionId} -->
+**${record.startTime}** | Status: ${record.status}
+- ID: \`${record.executionId}\`
+- Trigger: ${record.trigger || "manual"}
+- Task Type: ${record.taskType || "execution"}
+`;
+  writeFileSync4(logPath, content + entry);
+}
+function updateExecutionStatus(squadName, agentName, executionId, status, details) {
+  const logPath = getExecutionLogPath(squadName, agentName);
+  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);
+  if (markerIndex === -1) return;
+  const nextEntryIndex = content.indexOf("\n---\n", markerIndex + 1);
+  const entryEnd = nextEntryIndex === -1 ? content.length : nextEntryIndex;
+  const entryStart = content.lastIndexOf("\n---\n", markerIndex);
+  const currentEntry = content.slice(entryStart, entryEnd);
+  const durationStr = details?.durationMs ? `${(details.durationMs / 1e3).toFixed(1)}s` : "unknown";
+  let updatedEntry = currentEntry.replace(/Status: running/, `Status: ${status}`) + `- Completed: ${endTime}
+- Duration: ${durationStr}`;
+  if (details?.outcome) {
+    updatedEntry += `
+- Outcome: ${details.outcome}`;
+  }
+  if (details?.error) {
+    updatedEntry += `
+- Error: ${details.error}`;
+  }
+  content = content.slice(0, entryStart) + updatedEntry + content.slice(entryEnd);
+  writeFileSync4(logPath, content);
+}
+async function autoCommitAgentWork(squadName, agentName, executionId, provider) {
+  const { execSync: execSync4 } = await import("child_process");
+  const { detectGitHubRepo } = await import("./github-UQTM5KMS.js");
+  const projectRoot = getProjectRoot();
+  try {
+    const status = execSync4("git status --porcelain", {
+      encoding: "utf-8",
+      cwd: projectRoot
+    }).trim();
+    if (!status) {
+      return { committed: false };
+    }
+    const botEnv = await getBotGitEnv();
+    const execOpts = {
+      cwd: projectRoot,
+      env: { ...process.env, ...botEnv }
+    };
+    execSync4("git add -A", execOpts);
+    const shortExecId = executionId.slice(0, 12);
+    const coAuthor = getCoAuthorTrailer(provider || "claude");
+    const msgFile = join5(projectRoot, ".git", "SQUADS_COMMIT_MSG");
+    writeFileSync4(msgFile, `feat(${squadName}/${agentName}): execution ${shortExecId}
+
+${coAuthor}
+`);
+    try {
+      execSync4(`git commit --file "${msgFile}"`, execOpts);
+    } finally {
+      try {
+        unlinkSync(msgFile);
+      } catch {
+      }
+    }
+    try {
+      const { spawnSync: spawnSync2 } = await import("child_process");
+      const repo = detectGitHubRepo(projectRoot);
+      if (repo && /^[\w.-]+\/[\w.-]+$/.test(repo)) {
+        const pushUrl = await getBotPushUrl(repo);
+        if (pushUrl) {
+          spawnSync2("git", ["push", pushUrl, "HEAD"], { ...execOpts, stdio: "pipe" });
+        } else {
+          spawnSync2("git", ["push", "origin", "HEAD"], { ...execOpts, stdio: "pipe" });
+        }
+      } else {
+        spawnSync2("git", ["push", "origin", "HEAD"], { ...execOpts, stdio: "pipe" });
+      }
+    } catch (e) {
+      writeLine(`  ${colors.dim}warn: git push failed (commit is still local): ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    }
+    return { committed: true, message: `Committed changes from ${agentName}` };
+  } catch (error) {
+    return { committed: false, error: String(error) };
+  }
+}
+function getLastExecutionTime(squadName, agentName) {
+  const logPath = getExecutionLogPath(squadName, agentName);
+  if (!logPath || !existsSync5(logPath)) return null;
+  const content = readFileSync4(logPath, "utf-8");
+  const timestamps = content.match(/\*\*(\d{4}-\d{2}-\d{2}T[\d:.]+Z)\*\*/g);
+  if (!timestamps || timestamps.length === 0) return null;
+  const lastTimestamp = timestamps[timestamps.length - 1].replace(/\*\*/g, "");
+  return new Date(lastTimestamp);
+}
+function checkLocalCooldown(squadName, agentName, cooldownMs) {
+  const lastExec = getLastExecutionTime(squadName, agentName);
+  if (!lastExec) return { ok: true, cooldownMs };
+  const elapsedMs = Date.now() - lastExec.getTime();
+  if (elapsedMs < cooldownMs) {
+    return { ok: false, elapsedMs, cooldownMs };
+  }
+  return { ok: true, elapsedMs, cooldownMs };
+}
+function formatDuration(ms) {
+  const hours = Math.floor(ms / (60 * 60 * 1e3));
+  const minutes = Math.floor(ms % (60 * 60 * 1e3) / (60 * 1e3));
+  if (hours >= 24) {
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+  }
+  if (hours > 0) {
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  }
+  return `${minutes}m`;
+}
+async function emitExecutionEvent(eventType, data) {
+  const apiUrl = getApiUrl();
+  if (apiUrl) {
+    try {
+      await fetch(`${apiUrl}/events/ingest`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          source: "scheduler",
+          event_type: eventType,
+          data: {
+            squad: data.squad,
+            agent: data.agent,
+            execution_id: data.executionId,
+            ...data.error ? { error: data.error } : {}
+          }
+        }),
+        signal: AbortSignal.timeout(EXECUTION_EVENT_TIMEOUT_MS)
+      });
+      return;
+    } catch {
+    }
+  }
+  try {
+    const memDir = findMemoryDir();
+    if (!memDir) return;
+    const eventsDir = join5(memDir, data.squad, data.agent);
+    if (!existsSync5(eventsDir)) {
+      mkdirSync4(eventsDir, { recursive: true });
+    }
+    const eventsPath = join5(eventsDir, "events.md");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = `
+## ${timestamp}: ${eventType}
+- execution_id: ${data.executionId}
+${data.error ? `- error: ${data.error}
+` : ""}`;
+    let existing = "";
+    if (existsSync5(eventsPath)) {
+      existing = readFileSync4(eventsPath, "utf-8");
+    }
+    writeFileSync4(eventsPath, existing + entry);
+  } catch {
+  }
+}
+async function verifyExecution(squadName, agentName, criteria, options = {}) {
+  const { execSync: execSync4 } = await import("child_process");
+  const projectRoot = getProjectRoot();
+  let stateContent = "";
+  const memDir = findMemoryDir();
+  if (memDir) {
+    const statePath = join5(memDir, squadName, agentName, "state.md");
+    if (existsSync5(statePath)) {
+      stateContent = readFileSync4(statePath, "utf-8").slice(0, VERIFICATION_STATE_MAX_CHARS);
+    }
+  }
+  let recentCommits = "";
+  try {
+    recentCommits = execSync4("git log --oneline -5 --no-color", {
+      encoding: "utf-8",
+      cwd: projectRoot
+    }).trim();
+  } catch (e) {
+    if (options.verbose) writeLine(`  ${colors.dim}warn: git log failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    recentCommits = "(no commits found)";
+  }
+  const verifyPrompt = `You are verifying whether an agent completed its task successfully.
+
+Agent: ${squadName}/${agentName}
+
+## Acceptance Criteria
+${criteria}
+
+## Evidence
+
+### Agent State File
+${stateContent || "(empty or not found)"}
+
+### Recent Git Commits
+${recentCommits}
+
+## Instructions
+Evaluate whether the acceptance criteria are met based on the evidence.
+Respond with EXACTLY one line:
+PASS: <brief reason>
+or
+FAIL: <brief reason>`;
+  try {
+    const escapedPrompt = verifyPrompt.replace(/'/g, "'\\''");
+    const result = execSync4(
+      `unset CLAUDECODE; claude --print --model haiku -- '${escapedPrompt}'`,
+      { encoding: "utf-8", cwd: projectRoot, timeout: VERIFICATION_EXEC_TIMEOUT_MS, shell: "/bin/sh" }
+    ).trim();
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Verification: ${result}${RESET}`);
+    }
+    if (result.startsWith("PASS")) {
+      return { passed: true, reason: result.replace(/^PASS:\s*/, "") };
+    }
+    return { passed: false, reason: result.replace(/^FAIL:\s*/, "") };
+  } catch (error) {
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Verification error (defaulting to PASS): ${error}${RESET}`);
+    }
+    return { passed: true, reason: "Verification unavailable \u2014 defaulting to pass" };
+  }
+}
+async function runCloudDispatch(squadName, agentName, options) {
+  const apiUrl = getApiUrl();
+  if (!apiUrl) {
+    writeLine(`  ${colors.red}${icons.error} API URL not configured${RESET}`);
+    writeLine(`  ${colors.dim}Run: squads config use staging  (or set SQUADS_API_URL)${RESET}`);
+    process.exit(1);
+  }
+  if (!isLoggedIn()) {
+    writeLine(`  ${colors.red}${icons.error} Not logged in${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads login\` to authenticate before using --cloud${RESET}`);
+    process.exit(1);
+  }
+  const session = loadSession();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (session?.accessToken) {
+    headers["Authorization"] = `Bearer ${session.accessToken}`;
+  }
+  const apiKey = process.env.SQUADS_PLATFORM_API_TOKEN || process.env.SCHEDULER_API_KEY;
+  if (apiKey) {
+    headers["X-API-Key"] = apiKey;
+  }
+  const spinner = ora(`Dispatching ${squadName}/${agentName} to cloud...`).start();
+  try {
+    const dispatchRes = await fetch(`${apiUrl}/agent-dispatch`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        squad: squadName,
+        agent: agentName,
+        trigger_type: "manual",
+        trigger_data: {
+          source: "cli",
+          cloud: true,
+          model: options.model,
+          provider: options.provider,
+          effort: options.effort
+        }
+      })
+    });
+    if (!dispatchRes.ok) {
+      const error = await dispatchRes.text();
+      spinner.fail(`Dispatch failed: ${dispatchRes.status}`);
+      writeLine(`  ${colors.dim}${error}${RESET}`);
+      process.exit(1);
+    }
+    const dispatch = await dispatchRes.json();
+    spinner.succeed(`Dispatched to cloud`);
+    writeLine();
+    writeLine(`  ${colors.cyan}Dispatch ID${RESET}  ${dispatch.dispatch_id}`);
+    writeLine(`  ${colors.cyan}Squad${RESET}        ${squadName}`);
+    writeLine(`  ${colors.cyan}Agent${RESET}        ${agentName}`);
+    writeLine();
+    const pollSpinner = ora("Waiting for execution to start...").start();
+    const pollStart = Date.now();
+    let executionId = null;
+    let lastStatus = "";
+    while (Date.now() - pollStart < CLOUD_POLL_TIMEOUT_MS) {
+      try {
+        const execRes = await fetch(
+          `${apiUrl}/agent-executions?squad=${encodeURIComponent(squadName)}&agent=${encodeURIComponent(agentName)}&limit=1`,
+          { headers }
+        );
+        if (execRes.ok) {
+          const executions = await execRes.json();
+          if (executions.length > 0) {
+            const exec2 = executions[0];
+            if (!executionId && exec2.status === "running") {
+              executionId = exec2.execution_id;
+              pollSpinner.text = `Running (${exec2.execution_id})`;
+            }
+            if (executionId && exec2.execution_id === executionId) {
+              if (exec2.status !== lastStatus) {
+                lastStatus = exec2.status;
+                pollSpinner.text = `Status: ${exec2.status}`;
+              }
+              if (exec2.status === "completed") {
+                pollSpinner.succeed("Execution completed");
+                writeLine();
+                writeLine(`  ${colors.cyan}Execution${RESET}    ${exec2.execution_id}`);
+                if (exec2.summary) {
+                  writeLine(`  ${colors.cyan}Summary${RESET}      ${exec2.summary}`);
+                }
+                if (exec2.duration_seconds) {
+                  writeLine(`  ${colors.cyan}Duration${RESET}     ${Math.round(exec2.duration_seconds)}s`);
+                }
+                if (exec2.cost_usd) {
+                  writeLine(`  ${colors.cyan}Cost${RESET}         $${exec2.cost_usd.toFixed(4)}`);
+                }
+                writeLine();
+                return;
+              }
+              if (exec2.status === "failed") {
+                pollSpinner.fail("Execution failed");
+                writeLine();
+                if (exec2.error) {
+                  writeLine(`  ${colors.red}Error: ${exec2.error}${RESET}`);
+                }
+                writeLine();
+                process.exit(1);
+              }
+              if (exec2.status === "cancelled") {
+                pollSpinner.warn("Execution cancelled");
+                return;
+              }
+            }
+          }
+        }
+      } catch (e) {
+        if (options.verbose) writeLine(`  ${colors.dim}warn: cloud poll failed (retrying): ${e instanceof Error ? e.message : String(e)}${RESET}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, CLOUD_POLL_INTERVAL_MS));
+    }
+    pollSpinner.warn("Poll timeout \u2014 execution may still be running");
+    writeLine(`  ${colors.dim}Check status: squads trigger status${RESET}`);
+    if (executionId) {
+      writeLine(`  ${colors.dim}Execution ID: ${executionId}${RESET}`);
+    }
+  } catch (error) {
+    spinner.fail("Cloud dispatch failed");
+    writeLine(`  ${colors.red}${error instanceof Error ? error.message : String(error)}${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Check your network and SQUADS_API_URL setting${RESET}`);
+    process.exit(1);
+  }
+}
+async function runCommand(target, options) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  if (!options.dryRun && options.execute === void 0) {
+    options.execute = true;
+  }
+  if (!target) {
+    await runAutopilot(squadsDir, options);
+    return;
+  }
+  let squadName = target;
+  let agentFromSlash;
+  if (target.includes("/")) {
+    const parts = target.split("/");
+    squadName = parts[0];
+    agentFromSlash = parts[1];
+    if (!options.agent) {
+      options.agent = agentFromSlash;
+    }
+  }
+  if (options.cloud) {
+    const agentName = options.agent || agentFromSlash;
+    if (!agentName) {
+      writeLine(`  ${colors.red}${icons.error} --cloud requires a specific agent${RESET}`);
+      writeLine(`  ${colors.dim}Usage: squads run ${squadName} --cloud -a <agent>${RESET}`);
+      writeLine(`  ${colors.dim}   or: squads run ${squadName}/<agent> --cloud${RESET}`);
+      process.exit(1);
+    }
+    await track(Events.CLI_RUN, { type: "cloud", target: `${squadName}/${agentName}` });
+    await flushEvents();
+    await runCloudDispatch(squadName, agentName, options);
+    return;
+  }
+  const squad = loadSquad(squadName);
+  if (options.execute && !options.dryRun) {
+    const provider = options.provider || squad?.providers?.default || "anthropic";
+    const checksOk = await preflightExecutorCheck(provider);
+    if (!checksOk) {
+      process.exit(1);
+    }
+  }
+  if (squad) {
+    await track(Events.CLI_RUN, { type: "squad", target: squad.name });
+    await flushEvents();
+    await runSquad(squad, squadsDir, options);
+    await runPostEvaluation([squad.name], options);
+  } else {
+    const agents = listAgents(squadsDir);
+    const agent = agents.find((a) => a.name === target);
+    if (agent && agent.filePath) {
+      const pathParts = agent.filePath.split("/");
+      const squadIdx = pathParts.indexOf("squads");
+      const resolvedSquadName = squadIdx >= 0 ? pathParts[squadIdx + 1] : "unknown";
+      await runAgent(agent.name, agent.filePath, resolvedSquadName, options);
+      await runPostEvaluation([resolvedSquadName], options);
+    } else {
+      writeLine(`  ${colors.red}Squad or agent "${target}" not found${RESET}`);
+      const similar = findSimilarSquads(target, listSquads(squadsDir));
+      if (similar.length > 0) {
+        writeLine(`  ${colors.dim}Did you mean: ${similar.join(", ")}?${RESET}`);
+      }
+      writeLine(`  ${colors.dim}Run \`squads status\` to see available squads and agents.${RESET}`);
+      process.exit(1);
+    }
+  }
+}
+async function runSquad(squad, squadsDir, options) {
+  if (!squad) return;
+  if (!options.effort && squad.effort) {
+    options.effort = squad.effort;
+  }
+  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}run${RESET} ${colors.cyan}${squad.name}${RESET}`);
+  writeLine();
+  if (squad.mission) {
+    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}Started: ${startTime}${RESET}`);
+  writeLine();
+  if (options.lead) {
+    await runLeadMode(squad, squadsDir, options);
+    return;
+  }
+  if (options.parallel) {
+    const agentFiles = squad.agents.map((a) => ({
+      name: a.name,
+      path: join5(squadsDir, squad.dir, `${a.name}.md`)
+    })).filter((a) => existsSync5(a.path));
+    if (agentFiles.length === 0) {
+      writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
+      return;
+    }
+    writeLine(`  ${bold}Parallel execution${RESET} ${colors.dim}${agentFiles.length} agents${RESET}`);
+    writeLine();
+    if (!options.execute) {
+      for (const agent of agentFiles) {
+        writeLine(`  ${icons.empty} ${colors.cyan}${agent.name}${RESET}`);
+      }
+      writeLine();
+      writeLine(`  ${colors.dim}Launch all agents in parallel:${RESET}`);
+      writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --parallel`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${gradient("Launching")} ${agentFiles.length} agents in parallel...`);
+    writeLine();
+    const launches = agentFiles.map(
+      (agent) => runAgent(agent.name, agent.path, squad.dir, options)
+    );
+    await Promise.all(launches);
+    writeLine();
+    writeLine(`  ${icons.success} All ${agentFiles.length} agents launched`);
+    writeLine(`  ${colors.dim}Monitor: tmux ls | grep squads-${squad.name}${RESET}`);
+    writeLine(`  ${colors.dim}Attach:  tmux attach -t <session>${RESET}`);
+    writeLine();
+    return;
+  }
+  if (squad.pipelines.length > 0) {
+    const pipeline = squad.pipelines[0];
+    writeLine(`  ${bold}Pipeline${RESET} ${colors.dim}${pipeline.agents.join(" \u2192 ")}${RESET}`);
+    writeLine();
+    for (let i = 0; i < pipeline.agents.length; i++) {
+      const agentName = pipeline.agents[i];
+      const agentPath = join5(squadsDir, squad.dir, `${agentName}.md`);
+      if (existsSync5(agentPath)) {
+        writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
+        await runAgent(agentName, agentPath, squad.dir, options);
+        writeLine();
+      } else {
+        writeLine(`  ${icons.warning} ${colors.yellow}Agent ${agentName} not found, skipping${RESET}`);
+      }
+    }
+  } else {
+    if (options.agent) {
+      const agentPath = join5(squadsDir, squad.dir, `${options.agent}.md`);
+      if (existsSync5(agentPath)) {
+        await runAgent(options.agent, agentPath, squad.dir, options);
+      } else {
+        writeLine(`  ${icons.error} ${colors.red}Agent ${options.agent} not found${RESET}`);
+        return;
+      }
+    } else {
+      if (options.execute) {
+        writeLine(`  ${bold}Conversation mode${RESET} ${colors.dim}(lead \u2192 scan \u2192 work \u2192 review \u2192 verify)${RESET}`);
+        writeLine();
+        const convOptions = {
+          task: options.task,
+          maxTurns: options.maxTurns,
+          costCeiling: options.costCeiling,
+          verbose: options.verbose,
+          model: options.model
+        };
+        const apiExecId = await reportExecutionStart(squad.name, "conversation", `conv-${Date.now()}`);
+        const result = await runConversation(squad, convOptions);
+        const transcriptPath = saveTranscript(result.transcript);
+        if (apiExecId) {
+          reportConversationResult(apiExecId, {
+            turnCount: result.turnCount,
+            totalCost: result.totalCost,
+            converged: result.converged,
+            reason: result.reason,
+            agentsInvolved: [...new Set(result.transcript.turns.map((t) => t.agent))]
+          });
+        }
+        pushCognitionSignal({
+          source: "execution",
+          signal_type: result.converged ? "conversation_converged" : "conversation_stopped",
+          value: result.totalCost,
+          unit: "usd",
+          data: {
+            turn_count: result.turnCount,
+            converged: result.converged,
+            reason: result.reason,
+            agents_involved: [...new Set(result.transcript.turns.map((t) => t.agent))]
+          },
+          entity_type: "squad",
+          entity_id: squad.name,
+          confidence: 0.9
+        });
+        writeLine();
+        writeLine(`  ${result.converged ? icons.success : icons.warning} ${result.converged ? "Converged" : "Stopped"}: ${result.reason}`);
+        writeLine(`  ${colors.dim}Turns: ${result.turnCount} | Cost: ~$${result.totalCost.toFixed(2)}${RESET}`);
+        if (transcriptPath) {
+          writeLine(`  ${colors.dim}Transcript: ${transcriptPath}${RESET}`);
+        }
+        writeLine();
+      } else {
+        writeLine(`  ${colors.dim}Default mode: conversation (lead \u2192 scan \u2192 work \u2192 review \u2192 verify)${RESET}`);
+        writeLine();
+        for (const agent of squad.agents) {
+          writeLine(`  ${icons.empty} ${colors.cyan}${agent.name}${RESET} ${colors.dim}${agent.role}${RESET}`);
+        }
+        writeLine();
+        writeLine(`  ${colors.dim}Run conversation:${RESET}`);
+        writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET}`);
+        writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --task "review and merge open PRs"`);
+        writeLine();
+        writeLine(`  ${colors.dim}Run single agent:${RESET}`);
+        writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} -a ${colors.cyan}<agent>${RESET}`);
+      }
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}After execution, record outcome:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads feedback add ${colors.cyan}${squad.name}${RESET} ${colors.cyan}<1-5>${RESET} ${colors.cyan}"<feedback>"${RESET}`);
+  writeLine();
+}
+var EVAL_TIMEOUT_MINUTES = 15;
+async function runPostEvaluation(squadsRun, options) {
+  if (squadsRun.length === 1 && squadsRun[0] === "company") return;
+  if (options.eval === false) return;
+  if (options.dryRun) return;
+  if (options.background) return;
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return;
+  const cooPath = join5(squadsDir, "company", "company-lead.md");
+  if (!existsSync5(cooPath)) {
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Skipping evaluation: company-lead.md not found${RESET}`);
+    }
+    return;
+  }
+  const squadList = squadsRun.join(", ");
+  writeLine();
+  writeLine(`  ${gradient("eval")} ${colors.dim}COO evaluating: ${squadList}${RESET}`);
+  const evalTask = `Post-run evaluation for: ${squadList}.
+
+## Evaluation Process
+
+For each squad (${squadList}):
+
+### 1. Read previous feedback FIRST
+Read \`.agents/memory/{squad}/feedback.md\` if it exists. Note the previous grade, identified patterns, and priorities. This is your baseline \u2014 you are measuring CHANGE, not just current state.
+
+### 2. Gather current evidence
+- PRs (last 7 days): \`gh pr list --state all --limit 20 --json number,title,state,mergedAt,createdAt\`
+- Recent commits (last 7 days): \`gh api repos/{owner}/{repo}/commits?since=YYYY-MM-DDT00:00:00Z&per_page=20 --jq '.[].commit.message'\`
+- Open issues: \`gh issue list --state open --limit 15 --json number,title,labels\`
+- Read \`.agents/memory/{squad}/priorities.md\` and \`.agents/memory/company/directives.md\`
+- Read \`.agents/memory/{squad}/active-work.md\` (previous cycle's work tracking)
+
+### 3. Write feedback.md (APPEND history, don't overwrite)
+\`\`\`markdown
+# Feedback \u2014 {squad}
+
+## Current Assessment (YYYY-MM-DD): [A-F]
+Merge rate: X% | Noise ratio: Y% | Priority alignment: Z%
+
+## Trajectory: [improving | stable | declining | new]
+Previous grade: [grade] \u2192 Current: [grade]. [1-line explanation of why]
+
+## Valuable (continue)
+- [specific PR/issue that advanced priorities]
+
+## Noise (stop)
+- [specific anti-pattern observed]
+
+## Next Cycle Priorities
+1. [specific actionable item]
+
+## History
+| Date | Grade | Key Signal |
+|------|-------|------------|
+| YYYY-MM-DD | X | [what drove this grade] |
+[keep last 10 entries, append new row]
+\`\`\`
+
+### 4. Write active-work.md
+\`\`\`markdown
+# Active Work \u2014 {squad} (YYYY-MM-DD)
+## Continue (open PRs)
+- #{number}: {title} \u2014 {status/next action}
+## Backlog (assigned issues)
+- #{number}: {title} \u2014 {priority}
+## Do NOT Create
+- {description of known duplicate patterns from feedback history}
+\`\`\`
+
+### 5. Commit to hq main
+${squadsRun.length > 1 ? `
+### 6. Cross-squad assessment
+Evaluate how outputs from ${squadList} connect:
+- Duplicated efforts across squads?
+- Missing handoffs (one squad's output should feed another)?
+- Coordination gaps (conflicting PRs, redundant issues)?
+- Combined trajectory: is the org getting more effective or more noisy?
+Write cross-squad findings to \`.agents/memory/company/cross-squad-review.md\`.
+` : ""}
+CRITICAL: You are measuring DIRECTION not just position. A C-grade squad improving from F is better than a B-grade squad declining from A. The history table IS the feedback loop \u2014 agents read it next cycle.`;
+  await runAgent("company-lead", cooPath, "company", {
+    ...options,
+    task: evalTask,
+    timeout: EVAL_TIMEOUT_MINUTES,
+    eval: false,
+    // prevent recursion
+    trigger: "manual"
+  });
+}
+var ROLE_COOLDOWNS = {
+  scanner: 60 * 60 * 1e3,
+  // 1h — fast, cheap
+  lead: 4 * 60 * 60 * 1e3,
+  // 4h — orchestration
+  worker: 30 * 60 * 1e3,
+  // 30m — if work exists
+  verifier: 30 * 60 * 1e3,
+  // 30m — follows workers
+  "issue-solver": 30 * 60 * 1e3
+  // 30m — default worker
+};
+function classifyAgentRole(name) {
+  return classifyAgent(name) ?? "worker";
+}
+async function runAutopilot(squadsDir, options) {
+  const interval = parseInt(String(options.interval || "30"), 10);
+  const maxParallel = parseInt(String(options.maxParallel || "2"), 10);
+  const budget = parseFloat(String(options.budget || "0"));
+  const once = !!options.once;
+  const cognitionState = loadCognitionState();
+  seedBeliefsIfEmpty(cognitionState);
+  saveCognitionState(cognitionState);
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}autopilot${RESET}`);
+  writeLine(`  ${colors.dim}Interval: ${interval}m | Parallel: ${maxParallel} | Budget: ${budget > 0 ? "$" + budget + "/day" : "unlimited"}${RESET}`);
+  writeLine(`  ${colors.dim}Cognition: ${cognitionState.beliefs.length} beliefs, ${cognitionState.signals.length} signals${RESET}`);
+  writeLine();
+  let running = true;
+  const handleSignal = () => {
+    running = false;
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  while (running) {
+    const cycleStart = Date.now();
+    const state = loadLoopState();
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (state.dailyCostDate !== today) {
+      state.dailyCost = 0;
+      state.dailyCostDate = today;
+    }
+    if (budget > 0 && state.dailyCost >= budget) {
+      writeLine(`  ${icons.warning} ${colors.yellow}Daily budget reached ($${state.dailyCost.toFixed(2)}/$${budget})${RESET}`);
+      saveLoopState(state);
+      if (once) break;
+      await sleep(interval * 60 * 1e3);
+      continue;
+    }
+    writeLine(`  ${colors.dim}\u2500\u2500 Cycle ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \u2500\u2500${RESET}`);
+    let ghEnv = {};
+    try {
+      ghEnv = await getBotGhEnv();
+    } catch {
+    }
+    const squadRepos = getSquadRepos();
+    let dispatchedSquadNames;
+    const failed = [];
+    const completed = [];
+    if (options.phased) {
+      const phases = computePhases();
+      const phaseCount = phases.size;
+      writeLine(`  ${colors.dim}Phased mode: ${phaseCount} phase(s)${RESET}`);
+      dispatchedSquadNames = [];
+      for (const [phaseNum, phaseSquads] of phases) {
+        writeLine(`  ${colors.dim}\u2500\u2500 Phase ${phaseNum} (${phaseSquads.join(", ")}) \u2500\u2500${RESET}`);
+        const phaseSignals = scoreSquadsForPhase(phaseSquads, state, squadRepos, ghEnv);
+        const phaseDispatch = phaseSignals.filter((s) => s.score > 0).slice(0, maxParallel);
+        if (phaseDispatch.length === 0) {
+          writeLine(`    ${colors.dim}No squads need attention in this phase${RESET}`);
+          continue;
+        }
+        for (const sig of phaseDispatch) {
+          writeLine(`    ${colors.cyan}${sig.squad}${RESET} (score: ${sig.score}) \u2014 ${sig.reason}`);
+        }
+        if (options.dryRun) {
+          continue;
+        }
+        const phaseResults = await Promise.allSettled(
+          phaseDispatch.map((sig) => {
+            const squad = loadSquad(sig.squad);
+            if (!squad) return Promise.resolve();
+            return runSquadLoop(squad, squadsDir, state, ghEnv, options);
+          })
+        );
+        for (let i = 0; i < phaseResults.length; i++) {
+          const name = phaseDispatch[i].squad;
+          dispatchedSquadNames.push(name);
+          if (phaseResults[i].status === "rejected") {
+            failed.push(name);
+            state.failCounts[name] = (state.failCounts[name] || 0) + 1;
+          } else {
+            completed.push(name);
+            delete state.failCounts[name];
+          }
+        }
+      }
+      if (options.dryRun) {
+        writeLine(`  ${colors.yellow}[DRY RUN] Would dispatch above squads in phase order${RESET}`);
+        saveLoopState(state);
+        if (once) break;
+        await sleep(interval * 60 * 1e3);
+        continue;
+      }
+    } else {
+      const signals = scoreSquads(state, squadRepos, ghEnv);
+      if (signals.length === 0 || signals.every((s) => s.score <= 0)) {
+        writeLine(`  ${colors.dim}No squads need attention${RESET}`);
+        saveLoopState(state);
+        if (once) break;
+        await sleep(interval * 60 * 1e3);
+        continue;
+      }
+      const toDispatch = signals.filter((s) => s.score > 0).slice(0, maxParallel);
+      writeLine(`  ${colors.dim}Dispatching ${toDispatch.length} squad(s):${RESET}`);
+      for (const sig of toDispatch) {
+        writeLine(`    ${colors.cyan}${sig.squad}${RESET} (score: ${sig.score}) \u2014 ${sig.reason}`);
+      }
+      if (options.dryRun) {
+        writeLine(`  ${colors.yellow}[DRY RUN] Would dispatch above squads${RESET}`);
+        saveLoopState(state);
+        if (once) break;
+        await sleep(interval * 60 * 1e3);
+        continue;
+      }
+      const results = await Promise.allSettled(
+        toDispatch.map((sig) => {
+          const squad = loadSquad(sig.squad);
+          if (!squad) return Promise.resolve();
+          return runSquadLoop(squad, squadsDir, state, ghEnv, options);
+        })
+      );
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const name = toDispatch[i].squad;
+        if (r.status === "rejected") {
+          failed.push(name);
+          state.failCounts[name] = (state.failCounts[name] || 0) + 1;
+        } else {
+          completed.push(name);
+          delete state.failCounts[name];
+        }
+      }
+      dispatchedSquadNames = toDispatch.map((s) => s.squad);
+    }
+    const cycleCost = dispatchedSquadNames.length * 1;
+    state.dailyCost += cycleCost;
+    await pushMemorySignals(dispatchedSquadNames, state, !!options.verbose);
+    state.recentRuns = state.recentRuns.slice(-100);
+    state.lastCycle = (/* @__PURE__ */ new Date()).toISOString();
+    saveLoopState(state);
+    if (failed.length > 0) {
+      slackNotify([
+        `*Autopilot cycle \u2014 failures*`,
+        `Failed: ${failed.join(", ")}`,
+        `Completed: ${completed.join(", ")}`,
+        `Daily: $${state.dailyCost.toFixed(2)}${budget > 0 ? "/$" + budget : ""}`
+      ].join("\n"));
+    }
+    for (const [key, count] of Object.entries(state.failCounts)) {
+      if (count >= 3) {
+        slackNotify(`\u{1F6A8} *Escalation*: ${key} has failed ${count} times consecutively.`);
+      }
+    }
+    if (dispatchedSquadNames.length > 0) {
+      await runPostEvaluation(dispatchedSquadNames, options);
+    }
+    writeLine(`  ${colors.dim}Cognition cycle...${RESET}`);
+    const cognitionResult = await runCognitionCycle(dispatchedSquadNames, !!options.verbose);
+    if (cognitionResult.signalsIngested > 0 || cognitionResult.beliefsUpdated > 0 || cognitionResult.reflected) {
+      writeLine(`  ${colors.dim}\u{1F9E0} ${cognitionResult.signalsIngested} signals \u2192 ${cognitionResult.beliefsUpdated} beliefs updated${cognitionResult.reflected ? " \u2192 reflected" : ""}${RESET}`);
+    }
+    const elapsed = ((Date.now() - cycleStart) / 1e3).toFixed(0);
+    writeLine(`  ${colors.dim}Cycle done in ${elapsed}s | Daily: $${state.dailyCost.toFixed(2)}${RESET}`);
+    writeLine();
+    if (once) break;
+    await sleep(interval * 60 * 1e3);
+  }
+  process.off("SIGINT", handleSignal);
+  process.off("SIGTERM", handleSignal);
+}
+async function runSquadLoop(squad, squadsDir, state, ghEnv, options) {
+  writeLine(`  ${gradient("\u25B8")} ${colors.cyan}${squad.name}${RESET} \u2014 full loop`);
+  const agentsByRole = {
+    scanner: [],
+    lead: [],
+    worker: [],
+    verifier: []
+  };
+  for (const agent of squad.agents) {
+    const role = classifyAgentRole(agent.name);
+    const agentPath = join5(squadsDir, squad.dir, `${agent.name}.md`);
+    if (existsSync5(agentPath)) {
+      agentsByRole[role].push({ name: agent.name, path: agentPath });
+    }
+  }
+  const loopSteps = [
+    { role: "scanner", agents: agentsByRole.scanner },
+    { role: "lead", agents: agentsByRole.lead },
+    { role: "worker", agents: agentsByRole.worker },
+    { role: "verifier", agents: agentsByRole.verifier }
+  ];
+  for (const step of loopSteps) {
+    if (step.agents.length === 0) continue;
+    for (const agent of step.agents) {
+      const cooldownMs = ROLE_COOLDOWNS[step.role] || ROLE_COOLDOWNS.worker;
+      if (!checkCooldown(state, squad.name, agent.name, cooldownMs)) {
+        if (options.verbose) {
+          writeLine(`    ${colors.dim}\u21B3 ${agent.name} (${step.role}) \u2014 in cooldown, skip${RESET}`);
+        }
+        continue;
+      }
+      writeLine(`    ${colors.dim}\u21B3 ${agent.name} (${step.role})${RESET}`);
+      const startMs = Date.now();
+      try {
+        if (step.role === "worker" && step.agents.length > 1) {
+          const convOptions = {
+            task: options.task,
+            maxTurns: options.maxTurns || 20,
+            costCeiling: options.costCeiling || 25,
+            verbose: options.verbose,
+            model: options.model
+          };
+          await runConversation(squad, convOptions);
+        } else {
+          await runAgent(agent.name, agent.path, squad.dir, {
+            ...options,
+            background: false,
+            watch: false,
+            execute: true
+          });
+        }
+        const durationMs = Date.now() - startMs;
+        const outcome = classifyRunOutcome(0, durationMs);
+        state.cooldowns[`${squad.name}:${agent.name}`] = Date.now();
+        state.recentRuns.push({
+          squad: squad.name,
+          agent: agent.name,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          result: outcome === "skipped" ? "completed" : outcome,
+          durationMs
+        });
+        pushCognitionSignal({
+          source: "execution",
+          signal_type: `${step.role}_${outcome}`,
+          value: durationMs / 1e3,
+          unit: "seconds",
+          data: {
+            squad: squad.name,
+            agent: agent.name,
+            role: step.role,
+            duration_ms: durationMs
+          },
+          entity_type: "agent",
+          entity_id: `${squad.name}/${agent.name}`,
+          confidence: 0.9
+        });
+        if (outcome === "skipped") {
+          writeLine(`    ${colors.dim}\u21B3 ${agent.name} \u2014 phantom (${(durationMs / 1e3).toFixed(0)}s), skipped${RESET}`);
+        }
+        if (step.role === "worker" && step.agents.length > 1) break;
+      } catch (err) {
+        const durationMs = Date.now() - startMs;
+        state.cooldowns[`${squad.name}:${agent.name}`] = Date.now();
+        state.recentRuns.push({
+          squad: squad.name,
+          agent: agent.name,
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          result: "failed",
+          durationMs
+        });
+        writeLine(`    ${colors.red}\u21B3 ${agent.name} failed: ${err instanceof Error ? err.message : "unknown"}${RESET}`);
+      }
+    }
+  }
+  writeLine(`  ${colors.dim}\u21B3 ${squad.name} loop complete${RESET}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runLeadMode(squad, squadsDir, options) {
+  if (!squad) return;
+  const agentFiles = squad.agents.map((a) => ({
+    name: a.name,
+    path: join5(squadsDir, squad.dir, `${a.name}.md`),
+    role: a.role || ""
+  })).filter((a) => existsSync5(a.path));
+  if (agentFiles.length === 0) {
+    writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
+    return;
+  }
+  writeLine(`  ${bold}Lead mode${RESET} ${colors.dim}orchestrating ${agentFiles.length} agents${RESET}`);
+  writeLine();
+  for (const agent of agentFiles) {
+    writeLine(`  ${icons.empty} ${colors.cyan}${agent.name}${RESET} ${colors.dim}${agent.role}${RESET}`);
+  }
+  writeLine();
+  if (!options.execute) {
+    writeLine(`  ${colors.dim}Launch lead session:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --lead`);
+    writeLine();
+    return;
+  }
+  const timeoutMins = options.timeout || DEFAULT_TIMEOUT_MINUTES;
+  const agentList = agentFiles.map((a) => `- ${a.name}: ${a.role}`).join("\n");
+  const agentPaths = agentFiles.map((a) => `- ${a.name}: ${a.path}`).join("\n");
+  const prompt = `You are the Lead of the ${squad.name} squad.
+
+## Mission
+${squad.mission || "Execute squad operations efficiently."}
+
+## Available Agents
+${agentList}
+
+## Agent Definition Files
+${agentPaths}
+
+## Your Role as Lead
+
+1. **Assess the situation**: Check for pending work:
+   - Run \`gh issue list --repo agents-squads/hq --label squad:${squad.name}\` for assigned issues
+   - Check .agents/memory/${squad.dir}/ for squad state and pending tasks
+   - Review recent activity with \`git log --oneline -10\`
+
+2. **Delegate work using Task tool**: For each piece of work:
+   - Use the Task tool with subagent_type="general-purpose"
+   - Include the agent definition file path in the prompt
+   - Spawn multiple Task agents IN PARALLEL when work is independent
+   - Example: "Read ${agentFiles[0]?.path || "agent.md"} and execute its instructions for [specific task]"
+
+3. **Coordinate parallel execution**:
+   - Independent tasks \u2192 spawn Task agents in parallel (single message, multiple tool calls)
+   - Dependent tasks \u2192 run sequentially
+   - Monitor progress and handle failures
+
+4. **Report and update memory**:
+   - Update .agents/memory/${squad.dir}/state.md with completed work
+   - Log learnings to learnings.md
+   - Create issues for follow-up work if needed
+
+## Time Budget
+You have ${timeoutMins} minutes. Prioritize high-impact work.
+
+## Critical Instructions
+- Use Task tool for delegation, NOT direct execution of agent work
+- Spawn parallel Task agents when work is independent
+- When done, type /exit to end the session
+- Do NOT wait for user input - work autonomously
+
+## Async Mode (CRITICAL)
+This is ASYNC execution - Task agents must be fully autonomous:
+- **Findings** \u2192 Create GitHub issues (gh issue create)
+- **Code changes** \u2192 Create PRs (gh pr create)
+- **Analysis results** \u2192 Write to .agents/outputs/ or memory files
+- **NEVER wait for human review** - complete the work and move on
+- **NEVER ask clarifying questions** - make reasonable decisions
+
+Instruct each Task agent: "Work autonomously. Output findings to GitHub issues. Output code changes as PRs. Do not wait for review."
+
+Begin by assessing pending work, then delegate to agents via Task tool.`;
+  const provider = options.provider || squad?.providers?.default || "anthropic";
+  const isAnthropic = provider === "anthropic";
+  if (isAnthropic) {
+    const claudeAvailable = await checkClaudeCliAvailable();
+    if (!claudeAvailable) {
+      writeLine(`  ${colors.yellow}Claude CLI not found${RESET}`);
+      writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
+      return;
+    }
+  } else {
+    if (!isProviderCLIAvailable(provider)) {
+      const cliConfig = getCLIConfig(provider);
+      writeLine(`  ${colors.yellow}${cliConfig?.displayName || provider} CLI not found${RESET}`);
+      if (cliConfig?.install) {
+        writeLine(`  ${colors.dim}Install: ${cliConfig.install}${RESET}`);
+      }
+      return;
+    }
+  }
+  const isBackground = options.background === true && !options.watch;
+  const isWatch = options.watch === true;
+  const isForeground = !isBackground && !isWatch;
+  const modeText = isBackground ? " (background)" : isWatch ? " (watch)" : "";
+  const providerDisplay = isAnthropic ? "Claude" : getCLIConfig(provider)?.displayName || provider;
+  writeLine(`  ${gradient("Launching")} lead session${modeText} with ${providerDisplay}...`);
+  writeLine();
+  try {
+    const leadAgentName = agentFiles.find((a) => a.name.includes("lead"))?.name || `${squad.dir}-lead`;
+    let result;
+    if (isAnthropic) {
+      result = await executeWithClaude(prompt, {
+        verbose: options.verbose,
+        timeoutMinutes: timeoutMins,
+        foreground: options.foreground,
+        background: options.background,
+        watch: options.watch,
+        useApi: options.useApi,
+        effort: options.effort,
+        skills: options.skills,
+        trigger: options.trigger || "manual",
+        squadName: squad.dir,
+        agentName: leadAgentName,
+        model: options.model
+      });
+    } else {
+      result = await executeWithProvider(provider, prompt, {
+        verbose: options.verbose,
+        foreground: isForeground || isWatch,
+        squadName: squad.dir,
+        agentName: leadAgentName
+      });
+    }
+    if (isForeground || isWatch) {
+      writeLine();
+      writeLine(`  ${icons.success} Lead session completed`);
+    } else {
+      writeLine(`  ${icons.success} Lead session launched in background`);
+      writeLine(`  ${colors.dim}${result}${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}The lead will:${RESET}`);
+      writeLine(`  ${colors.dim}  1. Assess pending work (issues, memory)${RESET}`);
+      writeLine(`  ${colors.dim}  2. Spawn Task agents for parallel execution${RESET}`);
+      writeLine(`  ${colors.dim}  3. Coordinate and report results${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}Monitor: squads workers${RESET}`);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeLine(`  ${icons.error} ${colors.red}Failed to launch agent${RESET}`);
+    writeLine(`  ${colors.dim}${msg}${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads doctor\` to check your setup.${RESET}`);
+  }
+}
+async function runAgent(agentName, agentPath, squadName, options) {
+  const spinner = ora(`Running agent: ${agentName}`).start();
+  const startMs = Date.now();
+  const startTime = new Date(startMs).toISOString();
+  const executionId = generateExecutionId();
+  const taskType = detectTaskType(agentName);
+  const definition = loadAgentDefinition(agentPath);
+  const learnings = await fetchLearnings(squadName);
+  const learningContext = learnings.length > 0 ? `
+## Learnings from Previous Runs
+${learnings.map((l) => `- ${l.content}`).join("\n")}
+` : "";
+  if (options.dryRun) {
+    spinner.info(`[DRY RUN] Would run ${agentName}`);
+    const dryRunAgentRole = classifyAgent(agentName);
+    const dryRunContextRole = agentName.includes("company-lead") ? "coo" : dryRunAgentRole ?? "worker";
+    const dryRunContext = gatherSquadContext(squadName, agentName, {
+      verbose: options.verbose,
+      agentPath,
+      role: dryRunContextRole
+    });
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Agent definition:${RESET}`);
+      writeLine(`  ${colors.dim}${definition.slice(0, DRYRUN_DEF_MAX_CHARS)}...${RESET}`);
+      if (learnings.length > 0) {
+        writeLine(`  ${colors.dim}Learnings: ${learnings.length} from bridge${RESET}`);
+      }
+      if (dryRunContext || learningContext) {
+        const fullContext = `${dryRunContext}${learningContext}`;
+        writeLine();
+        writeLine(`  ${colors.cyan}Context to inject (${Math.ceil(fullContext.length / 4)} tokens):${RESET}`);
+        writeLine(`  ${colors.dim}${fullContext.slice(0, DRYRUN_CONTEXT_MAX_CHARS)}...${RESET}`);
+      }
+    }
+    return;
+  }
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    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 = {
+        mcpServers
+      };
+      const permResult = validateExecution(permContext, execRequest);
+      if (permResult.violations.length > 0) {
+        spinner.stop();
+        const violationLines = formatViolations(permResult);
+        for (const line of violationLines) {
+          writeLine(`  ${line}`);
+        }
+        writeLine();
+        if (!permResult.allowed) {
+          writeLine(`  ${colors.red}Execution blocked due to permission violations.${RESET}`);
+          writeLine(`  ${colors.dim}Configure permissions in ${squadFilePath}${RESET}`);
+          return;
+        }
+      }
+    }
+  }
+  const preflight = await checkPreflightGates(squadName, agentName);
+  if (!preflight.allowed) {
+    spinner.stop();
+    writeLine();
+    writeLine(`  ${colors.red}${icons.error} Execution blocked by preflight gates${RESET}`);
+    if (preflight.gates.quota && !preflight.gates.quota.ok) {
+      writeLine(`  ${colors.dim}Quota: $${preflight.gates.quota.used.toFixed(2)}/$${preflight.gates.quota.limit}/mo limit exceeded${RESET}`);
+    }
+    if (preflight.gates.cooldown && !preflight.gates.cooldown.ok) {
+      const elapsed = preflight.gates.cooldown.elapsed_sec;
+      const minGap = preflight.gates.cooldown.min_gap_sec;
+      writeLine(`  ${colors.dim}Cooldown: ${elapsed}s since last run (min: ${minGap}s)${RESET}`);
+    }
+    writeLine();
+    return;
+  }
+  if (options.verbose && Object.keys(preflight.gates).length > 0) {
+    writeLine(`  ${colors.dim}Preflight: quota ${preflight.gates.quota?.ok ? "\u2713" : "\u2717"} cooldown ${preflight.gates.cooldown?.ok ? "\u2713" : "\u2717"}${RESET}`);
+  }
+  const isScheduledRun = options.trigger === "scheduled" || options.trigger === "smart";
+  const bridgeHasNoHistory = preflight.gates.cooldown?.elapsed_sec === null;
+  if (isScheduledRun && (!preflight.gates.cooldown || bridgeHasNoHistory)) {
+    const frontmatterForCooldown = parseAgentFrontmatter(agentPath);
+    const cooldownMs = frontmatterForCooldown.cooldown ? parseCooldown(frontmatterForCooldown.cooldown) || DEFAULT_SCHEDULED_COOLDOWN_MS : DEFAULT_SCHEDULED_COOLDOWN_MS;
+    const localCooldown = checkLocalCooldown(squadName, agentName, cooldownMs);
+    if (!localCooldown.ok) {
+      spinner.stop();
+      writeLine();
+      writeLine(`  ${colors.yellow}${icons.warning} Skipping: cooldown not elapsed${RESET}`);
+      writeLine(`  ${colors.dim}Last run: ${formatDuration(localCooldown.elapsedMs)} ago (cooldown: ${formatDuration(localCooldown.cooldownMs)})${RESET}`);
+      writeLine();
+      return;
+    }
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Local cooldown: \u2713 (${formatDuration(localCooldown.elapsedMs || 0)} since last run)${RESET}`);
+    }
+  }
+  logExecution({
+    squadName,
+    agentName,
+    executionId,
+    startTime,
+    status: "running",
+    trigger: options.trigger || "manual",
+    taskType
+  });
+  if (options.verbose && learnings.length > 0) {
+    writeLine(`  ${colors.dim}Injecting ${learnings.length} learnings${RESET}`);
+  }
+  const systemProtocol = loadSystemProtocol();
+  const systemContext = systemProtocol ? `
+${systemProtocol}
+` : "";
+  const agentRole = classifyAgent(agentName);
+  const contextRole = agentName.includes("company-lead") ? "coo" : agentRole ?? "worker";
+  const squadContext = gatherSquadContext(squadName, agentName, {
+    verbose: options.verbose,
+    agentPath,
+    role: contextRole
+  });
+  let cognitionContext = "";
+  try {
+    const { loadSession: loadSession2 } = await import("./auth-YW3UPFSB.js");
+    const { getApiUrl: getApiUrl2 } = await import("./env-config-SQEI3Y7Y.js");
+    const session = loadSession2();
+    if (session?.accessToken && session.status === "active") {
+      const safeSquadName = encodeURIComponent(squadName);
+      const res = await fetch(`${getApiUrl2()}/cognition/context/squad:${safeSquadName}`, {
+        headers: { Authorization: `Bearer ${session.accessToken}` },
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.markdown && !data.markdown.includes("No cognition data")) {
+          cognitionContext = `
+${data.markdown}
+`;
+          if (options.verbose) {
+            writeLine(`  ${colors.dim}Injecting cognition beliefs${RESET}`);
+          }
+        }
+      }
+    }
+  } catch (e) {
+    if (options.verbose) writeLine(`  ${colors.dim}warn: cognition fetch failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+  }
+  const timeoutMins = options.timeout || DEFAULT_TIMEOUT_MINUTES;
+  const taskDirective = options.task ? `
+## TASK DIRECTIVE (overrides default behavior)
+${options.task}
+` : "";
+  const prompt = `Execute the ${agentName} agent from squad ${squadName}.
+
+Read the agent definition at ${agentPath} and follow its instructions exactly.
+${taskDirective}
+The agent definition contains:
+- Purpose/role
+- Tools it can use (MCP servers, skills)
+- Step-by-step instructions
+- Expected output format
+
+TOOL PREFERENCE: Always prefer CLI tools over MCP servers when both can accomplish the task:
+- Use \`squads\` CLI for squad operations (run, memory, status, feedback)
+- Use \`gh\` CLI for GitHub (issues, PRs, repos)
+- Use \`git\` CLI for version control
+- Use Bash for file operations, builds, tests
+- Only use MCP tools when CLI cannot do it or MCP is significantly better
+${systemContext}${squadContext}${cognitionContext}${learningContext}
+TIME LIMIT: You have ${timeoutMins} minutes. Work efficiently:
+- Focus on the most important tasks first
+- If a task is taking too long, move on and note it for next run
+- Aim to complete within ${Math.floor(timeoutMins * SOFT_DEADLINE_RATIO)} minutes`;
+  const agentProvider = parseAgentProvider(agentPath);
+  const squad = loadSquad(squadName);
+  const squadDefaultProvider = squad?.providers?.default;
+  const provider = agentProvider || options.provider || squadDefaultProvider || "anthropic";
+  const isAnthropic = provider === "anthropic";
+  if (options.verbose && (agentProvider || squadDefaultProvider)) {
+    writeLine(`  ${colors.dim}Provider resolution:${RESET}`);
+    if (agentProvider) writeLine(`    ${colors.dim}Agent: ${agentProvider}${RESET}`);
+    if (options.provider) writeLine(`    ${colors.dim}CLI: ${options.provider}${RESET}`);
+    if (squadDefaultProvider) writeLine(`    ${colors.dim}Squad: ${squadDefaultProvider}${RESET}`);
+    writeLine(`    ${colors.dim}\u2192 Using: ${provider}${RESET}`);
+  }
+  const cliAvailable = isAnthropic ? await checkClaudeCliAvailable() : isProviderCLIAvailable(provider);
+  if (options.execute && cliAvailable) {
+    const cliConfig = getCLIConfig(provider);
+    const cliName = cliConfig?.displayName || provider;
+    const isBackground = options.background === true && !options.watch;
+    const isWatch = options.watch === true;
+    const isForeground = !isBackground && !isWatch;
+    spinner.text = isBackground ? `Launching ${agentName} with ${cliName} in background...` : isWatch ? `Starting ${agentName} with ${cliName} (watch mode)...` : `Running ${agentName} with ${cliName}...`;
+    const frontmatter = parseAgentFrontmatter(agentPath);
+    const hasCriteria = !!frontmatter.acceptance_criteria && options.verify !== false;
+    const maxRetries = frontmatter.max_retries ?? 2;
+    let currentPrompt = prompt;
+    for (let attempt = 0; attempt <= (hasCriteria ? maxRetries : 0); attempt++) {
+      try {
+        let result;
+        if (isAnthropic) {
+          result = await executeWithClaude(currentPrompt, {
+            verbose: options.verbose,
+            timeoutMinutes: options.timeout || 30,
+            foreground: options.foreground,
+            background: options.background,
+            watch: options.watch,
+            useApi: options.useApi,
+            effort: options.effort,
+            skills: options.skills,
+            trigger: options.trigger || "manual",
+            squadName,
+            agentName,
+            model: options.model
+          });
+        } else {
+          result = await executeWithProvider(provider, currentPrompt, {
+            verbose: options.verbose,
+            foreground: !isBackground,
+            squadName,
+            agentName
+          });
+        }
+        if (hasCriteria && (isForeground || isWatch)) {
+          const verification = await verifyExecution(
+            squadName,
+            agentName,
+            frontmatter.acceptance_criteria,
+            { verbose: options.verbose }
+          );
+          if (!verification.passed && attempt < maxRetries) {
+            writeLine(`  ${colors.yellow}Verification: FAIL - ${verification.reason}${RESET}`);
+            writeLine(`  ${colors.dim}Retrying (${attempt + 1}/${maxRetries})...${RESET}`);
+            currentPrompt = `${prompt}
+
+## PREVIOUS ATTEMPT FAILED
+Verification found: ${verification.reason}
+Please address this issue and try again.`;
+            continue;
+          }
+          if (verification.passed) {
+            writeLine(`  ${colors.green}Verification: PASS - ${verification.reason}${RESET}`);
+          }
+        }
+        emitExecutionEvent("agent.completed", {
+          squad: squadName,
+          agent: agentName,
+          executionId
+        }).catch(() => {
+        });
+        if (isForeground || isWatch) {
+          spinner.succeed(`Agent ${agentName} completed (${cliName})`);
+        } else {
+          spinner.succeed(`Agent ${agentName} launched in background (${cliName})`);
+          writeLine(`  ${colors.dim}${result}${RESET}`);
+          writeLine();
+          writeLine(`  ${colors.dim}Monitor:${RESET} squads workers`);
+          writeLine(`  ${colors.dim}Memory:${RESET}  squads memory show ${squadName}`);
+        }
+        break;
+      } catch (error) {
+        emitExecutionEvent("agent.failed", {
+          squad: squadName,
+          agent: agentName,
+          executionId,
+          error: String(error)
+        }).catch(() => {
+        });
+        spinner.fail(`Agent ${agentName} failed to launch`);
+        updateExecutionStatus(squadName, agentName, executionId, "failed", {
+          error: String(error),
+          durationMs: Date.now() - startMs
+        });
+        const msg = error instanceof Error ? error.message : String(error);
+        const isLikelyBug = error instanceof ReferenceError || error instanceof TypeError || error instanceof SyntaxError;
+        writeLine(`  ${colors.red}${msg}${RESET}`);
+        writeLine();
+        if (isLikelyBug) {
+          writeLine(`  ${colors.yellow}This looks like a bug. Please try:${RESET}`);
+          writeLine(`  ${colors.dim}$${RESET} squads doctor          ${colors.dim}\u2014 check your setup${RESET}`);
+          writeLine(`  ${colors.dim}$${RESET} squads update           ${colors.dim}\u2014 get the latest fixes${RESET}`);
+          writeLine();
+          writeLine(`  ${colors.dim}If the problem persists, file an issue:${RESET}`);
+          writeLine(`  ${colors.dim}https://github.com/agents-squads/squads-cli/issues${RESET}`);
+        } else {
+          writeLine(`  ${colors.dim}Run \`squads doctor\` to check your setup, or \`squads run ${agentName} --verbose\` for details.${RESET}`);
+        }
+        break;
+      }
+    }
+  } else {
+    spinner.succeed(`Agent ${agentName} ready`);
+    writeLine(`  ${colors.dim}Execution logged: ${startTime}${RESET}`);
+    if (!cliAvailable) {
+      const cliConfig = getCLIConfig(provider);
+      writeLine();
+      writeLine(`  ${colors.yellow}${cliConfig?.command || provider} CLI not found${RESET}`);
+      writeLine(`  ${colors.dim}Install: ${cliConfig?.install || "squads providers"}${RESET}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}To launch as background task:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} -a ${colors.cyan}${agentName}${RESET}`);
+    if (provider !== "anthropic") {
+      writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} -a ${colors.cyan}${agentName}${RESET} --provider=${provider}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}Or run interactively:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} Run the ${colors.cyan}${agentName}${RESET} agent from ${agentPath}`);
+  }
+}
+async function checkClaudeCliAvailable() {
+  return new Promise((resolve) => {
+    const check = spawn("which", ["claude"], { stdio: "pipe" });
+    check.on("close", (code) => resolve(code === 0));
+    check.on("error", () => resolve(false));
+  });
+}
+async function preflightExecutorCheck(provider) {
+  if (process.env.SQUADS_SKIP_CHECKS === "1") {
+    return true;
+  }
+  const isAnthropic = provider === "anthropic";
+  let cliFound;
+  if (isAnthropic) {
+    cliFound = await checkClaudeCliAvailable();
+  } else {
+    cliFound = isProviderCLIAvailable(provider);
+  }
+  if (!cliFound) {
+    const cliConfig = getCLIConfig(provider);
+    const cliName = cliConfig?.command || provider;
+    const installCmd = cliConfig?.install || `See ${provider} documentation`;
+    writeLine();
+    writeLine(`  ${icons.error} ${colors.red}${cliName} CLI not found${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}The ${cliName} command is required to run agents but was not found on your PATH.${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.cyan}Install:${RESET} ${installCmd}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Skip this check: SQUADS_SKIP_CHECKS=1 squads run ...${RESET}`);
+    writeLine();
+    return false;
+  }
+  return true;
+}
+function buildAgentEnv(baseEnv, execContext, options) {
+  const { CLAUDECODE: _, ...cleanEnv } = baseEnv;
+  const env = {
+    ...cleanEnv,
+    SQUADS_SQUAD: execContext.squad,
+    SQUADS_AGENT: execContext.agent,
+    SQUADS_TASK_TYPE: execContext.taskType,
+    SQUADS_TRIGGER: execContext.trigger,
+    SQUADS_EXECUTION_ID: execContext.executionId,
+    BRIDGE_API: getBridgeUrl()
+  };
+  if (options?.ghToken) env.GH_TOKEN = options.ghToken;
+  if (options?.includeOtel) {
+    env.OTEL_RESOURCE_ATTRIBUTES = `squads.squad=${execContext.squad},squads.agent=${execContext.agent},squads.task_type=${execContext.taskType},squads.trigger=${execContext.trigger},squads.execution_id=${execContext.executionId}`;
+  }
+  if (options?.effort) env.CLAUDE_EFFORT = options.effort;
+  if (options?.skills && options.skills.length > 0) env.CLAUDE_SKILLS = options.skills.join(",");
+  return env;
+}
+function logVerboseExecution(config) {
+  writeLine(`  ${colors.dim}Project: ${config.projectRoot}${RESET}`);
+  writeLine(`  ${colors.dim}Mode: ${config.mode}${RESET}`);
+  if (config.logFile) writeLine(`  ${colors.dim}Log: ${config.logFile}${RESET}`);
+  if (config.mcpConfigPath) writeLine(`  ${colors.dim}MCP config: ${config.mcpConfigPath}${RESET}`);
+  if (config.useApi !== void 0) writeLine(`  ${colors.dim}Auth: ${config.useApi ? "API credits" : "subscription"}${RESET}`);
+  writeLine(`  ${colors.dim}Execution: ${config.execContext.executionId}${RESET}`);
+  writeLine(`  ${colors.dim}Task type: ${config.execContext.taskType}${RESET}`);
+  writeLine(`  ${colors.dim}Trigger: ${config.execContext.trigger}${RESET}`);
+  if (config.effort) writeLine(`  ${colors.dim}Effort: ${config.effort}${RESET}`);
+  if (config.skills && config.skills.length > 0) writeLine(`  ${colors.dim}Skills: ${config.skills.join(", ")}${RESET}`);
+  if (config.resolvedModel || config.claudeModelAlias) {
+    const source = config.explicitModel ? "explicit" : "auto-routed";
+    const displayModel = config.resolvedModel || config.claudeModelAlias;
+    writeLine(`  ${colors.dim}Model: ${displayModel} (${source})${RESET}`);
+  }
+}
+function resolveTargetRepoRoot(projectRoot, squad) {
+  if (!squad?.repo) return projectRoot;
+  const repoName = squad.repo.split("/").pop();
+  if (!repoName) return projectRoot;
+  const candidatePath = join5(projectRoot, "..", repoName);
+  return existsSync5(candidatePath) ? candidatePath : projectRoot;
+}
+function createAgentWorktree(projectRoot, squadName, agentName) {
+  const timestamp = Date.now();
+  const branchName = `agent/${squadName}/${agentName}-${timestamp}`;
+  const worktreePath = join5(projectRoot, "..", ".worktrees", `${squadName}-${agentName}-${timestamp}`);
+  try {
+    mkdirSync4(join5(projectRoot, "..", ".worktrees"), { recursive: true });
+    execSync3(`git worktree add '${worktreePath}' -b '${branchName}' HEAD`, { cwd: projectRoot, stdio: "pipe" });
+    return worktreePath;
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: worktree creation failed, using project root: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+    return projectRoot;
+  }
+}
+function cleanupWorktree(worktreePath, projectRoot) {
+  if (worktreePath === projectRoot) return;
+  try {
+    const branchInfo = execSync3(`git -C '${projectRoot}' worktree list --porcelain`, { encoding: "utf-8" });
+    let branchName = "";
+    const lines = branchInfo.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] === `worktree ${worktreePath}` && i + 2 < lines.length) {
+        const branchLine = lines[i + 2];
+        if (branchLine.startsWith("branch refs/heads/")) {
+          branchName = branchLine.replace("branch refs/heads/", "");
+        }
+        break;
+      }
+    }
+    execSync3(`git -C '${projectRoot}' worktree remove '${worktreePath}' --force`, { stdio: "pipe" });
+    if (branchName && branchName.startsWith("agent/")) {
+      execSync3(`git -C '${projectRoot}' branch -D '${branchName}'`, { stdio: "pipe" });
+    }
+  } catch {
+  }
+}
+function buildDetachedShellScript(config) {
+  const modelFlag = config.claudeModelAlias ? `--model ${config.claudeModelAlias}` : "";
+  const branchName = `agent/${config.squadName}/${config.agentName}-${config.timestamp}`;
+  const worktreeDir = `${config.projectRoot}/../.worktrees/${config.squadName}-${config.agentName}-${config.timestamp}`;
+  const cleanup = `if [ "\${WORK_DIR}" != '${config.projectRoot}' ]; then git -C '${config.projectRoot}' worktree remove "\${WORK_DIR}" --force 2>/dev/null; BRANCH='${branchName}'; git -C '${config.projectRoot}' branch -D "\${BRANCH}" 2>/dev/null; fi`;
+  const script = `mkdir -p '${config.projectRoot}/../.worktrees'; WORK_DIR='${config.projectRoot}'; if git -C '${config.projectRoot}' worktree add '${worktreeDir}' -b '${branchName}' HEAD 2>/dev/null; then WORK_DIR='${worktreeDir}'; fi; cd "\${WORK_DIR}"; unset CLAUDECODE; claude --print --dangerously-skip-permissions --disable-slash-commands ${modelFlag} -- '${config.escapedPrompt}' > '${config.logFile}' 2>&1; ${cleanup}`;
+  return `echo $$ > '${config.pidFile}'; ${script}`;
+}
+function prepareLogFiles(projectRoot, squadName, agentName, timestamp) {
+  const logDir = join5(projectRoot, ".agents", "logs", squadName);
+  const logFile = join5(logDir, `${agentName}-${timestamp}.log`);
+  const pidFile = join5(logDir, `${agentName}-${timestamp}.pid`);
+  if (!existsSync5(logDir)) {
+    mkdirSync4(logDir, { recursive: true });
+  }
+  return { logDir, logFile, pidFile };
+}
+function executeForeground(config) {
+  const workDir = createAgentWorktree(config.projectRoot, config.squadName, config.agentName);
+  return new Promise((resolve, reject) => {
+    const claude = spawn("claude", config.claudeArgs, {
+      stdio: "inherit",
+      cwd: workDir,
+      env: config.agentEnv
+    });
+    claude.on("close", async (code) => {
+      const durationMs = Date.now() - config.startMs;
+      if (code === 0) {
+        updateExecutionStatus(config.squadName, config.agentName, config.execContext.executionId, "completed", {
+          outcome: "Session completed successfully",
+          durationMs
+        });
+        const commitResult = await autoCommitAgentWork(config.squadName, config.agentName, config.execContext.executionId, config.provider);
+        if (commitResult.committed) {
+          writeLine();
+          writeLine(`  ${colors.green}Auto-committed agent work${RESET}`);
+        }
+        cleanupWorktree(workDir, config.projectRoot);
+        resolve("Session completed");
+      } else {
+        updateExecutionStatus(config.squadName, config.agentName, config.execContext.executionId, "failed", {
+          error: `Claude exited with code ${code}`,
+          durationMs
+        });
+        cleanupWorktree(workDir, config.projectRoot);
+        reject(new Error(`Claude exited with code ${code}`));
+      }
+    });
+    claude.on("error", (err) => {
+      const durationMs = Date.now() - config.startMs;
+      updateExecutionStatus(config.squadName, config.agentName, config.execContext.executionId, "failed", {
+        error: String(err),
+        durationMs
+      });
+      cleanupWorktree(workDir, config.projectRoot);
+      reject(err);
+    });
+  });
+}
+async function executeWatch(config) {
+  const child = spawn("sh", ["-c", config.wrapperScript], {
+    cwd: config.projectRoot,
+    detached: true,
+    stdio: "ignore",
+    env: config.agentEnv
+  });
+  child.unref();
+  await new Promise((resolve) => setTimeout(resolve, LOG_FILE_INIT_DELAY_MS));
+  writeLine(`  ${colors.dim}Tailing log (Ctrl+C to stop watching, agent continues)...${RESET}`);
+  writeLine();
+  const tail = spawn("tail", ["-f", config.logFile], { stdio: "inherit" });
+  process.on("SIGINT", () => {
+    tail.kill();
+    writeLine();
+    writeLine(`  ${colors.dim}Stopped watching. Agent continues in background.${RESET}`);
+    writeLine(`  ${colors.dim}Resume: tail -f ${config.logFile}${RESET}`);
+    process.exit(0);
+  });
+  return new Promise((resolve) => {
+    tail.on("close", () => {
+      resolve(`Agent running in background. Log: ${config.logFile}`);
+    });
+  });
+}
+async function executeWithClaude(prompt, options) {
+  const {
+    verbose,
+    timeoutMinutes: _timeoutMinutes = 30,
+    foreground,
+    background,
+    watch,
+    useApi,
+    effort,
+    skills,
+    trigger = "manual",
+    squadName,
+    agentName,
+    model
+  } = options;
+  const runInBackground = background === true && !watch;
+  const runInWatch = watch === true;
+  const runInForeground = !runInBackground && !runInWatch;
+  const startMs = Date.now();
+  const projectRoot = getProjectRoot();
+  ensureProjectTrusted(projectRoot);
+  const squad = squadName !== "unknown" ? loadSquad(squadName) : null;
+  const mcpConfigPath = selectMcpConfig(squadName, squad);
+  const taskType = detectTaskType(agentName);
+  const resolvedModel = resolveModel(model, squad, taskType);
+  const provider = resolvedModel ? detectProviderFromModel(resolvedModel) : "anthropic";
+  const targetRepoRoot = resolveTargetRepoRoot(projectRoot, squad);
+  if (provider !== "anthropic" && provider !== "unknown") {
+    if (verbose) {
+      const source = model ? "explicit" : "auto-routed";
+      writeLine(`  ${colors.dim}Model: ${resolvedModel} (${source})${RESET}`);
+      writeLine(`  ${colors.dim}Provider: ${provider}${RESET}`);
+    }
+    return executeWithProvider(provider, prompt, {
+      verbose,
+      foreground,
+      cwd: targetRepoRoot,
+      squadName,
+      agentName
+    });
+  }
+  const claudeModelAlias = resolvedModel ? getClaudeModelAlias(resolvedModel) : void 0;
+  const execContext = {
+    squad: squadName,
+    agent: agentName,
+    taskType,
+    trigger,
+    executionId: generateExecutionId()
+  };
+  const { ANTHROPIC_API_KEY: _apiKey, CLAUDECODE: _claudeCode, ...envWithoutApiKey } = process.env;
+  const spawnEnv = useApi ? (() => {
+    const { CLAUDECODE: _, ...rest } = process.env;
+    return rest;
+  })() : envWithoutApiKey;
+  const escapedPrompt = prompt.replace(/'/g, "'\\''");
+  await registerContextWithBridge(execContext);
+  let botGhToken;
+  try {
+    const ghEnv = await getBotGhEnv();
+    botGhToken = ghEnv.GH_TOKEN;
+  } catch {
+  }
+  if (runInForeground) {
+    if (verbose) {
+      logVerboseExecution({
+        projectRoot,
+        mode: "foreground",
+        useApi,
+        execContext,
+        effort,
+        skills,
+        resolvedModel,
+        claudeModelAlias,
+        explicitModel: model
+      });
+    }
+    const claudeArgs = [];
+    if (!process.stdin.isTTY) claudeArgs.push("--print");
+    claudeArgs.push("--dangerously-skip-permissions");
+    claudeArgs.push("--disable-slash-commands");
+    if (mcpConfigPath) claudeArgs.push("--mcp-config", mcpConfigPath);
+    if (claudeModelAlias) claudeArgs.push("--model", claudeModelAlias);
+    claudeArgs.push("--", prompt);
+    const agentEnv2 = buildAgentEnv(spawnEnv, execContext, {
+      effort,
+      skills,
+      includeOtel: true,
+      ghToken: botGhToken
+    });
+    return executeForeground({
+      prompt,
+      claudeArgs,
+      agentEnv: agentEnv2,
+      projectRoot: targetRepoRoot,
+      squadName,
+      agentName,
+      execContext,
+      startMs,
+      provider
+    });
+  }
+  const timestamp = Date.now();
+  const { logFile, pidFile } = prepareLogFiles(projectRoot, squadName, agentName, timestamp);
+  const agentEnv = buildAgentEnv(spawnEnv, execContext, {
+    effort,
+    skills,
+    includeOtel: !runInWatch,
+    ghToken: botGhToken
+  });
+  const wrapperScript = buildDetachedShellScript({
+    projectRoot: targetRepoRoot,
+    squadName,
+    agentName,
+    timestamp,
+    claudeModelAlias,
+    escapedPrompt,
+    logFile,
+    pidFile
+  });
+  if (runInWatch) {
+    if (verbose) {
+      logVerboseExecution({
+        projectRoot,
+        mode: "watch (background + tail)",
+        execContext,
+        logFile
+      });
+    }
+    return executeWatch({ projectRoot: targetRepoRoot, agentEnv, logFile, wrapperScript });
+  }
+  if (verbose) {
+    logVerboseExecution({
+      projectRoot,
+      mode: "background",
+      useApi,
+      execContext,
+      effort,
+      skills,
+      resolvedModel,
+      claudeModelAlias,
+      explicitModel: model,
+      logFile,
+      mcpConfigPath
+    });
+  }
+  const child = spawn("sh", ["-c", wrapperScript], {
+    cwd: targetRepoRoot,
+    detached: true,
+    stdio: "ignore",
+    env: agentEnv
+  });
+  child.unref();
+  if (verbose) {
+    writeLine(`  ${colors.dim}Monitor: tail -f ${logFile}${RESET}`);
+  }
+  return `Log: ${logFile}. Monitor: tail -f ${logFile}`;
+}
+async function executeWithProvider(provider, prompt, options) {
+  const cliConfig = getCLIConfig(provider);
+  if (!cliConfig) {
+    throw new Error(`Unknown provider: ${provider}. Run 'squads providers' to see available providers.`);
+  }
+  if (!isProviderCLIAvailable(provider)) {
+    throw new Error(`CLI '${cliConfig.command}' not found. Install: ${cliConfig.install}`);
+  }
+  const projectRoot = options.cwd || getProjectRoot();
+  const squadName = options.squadName || "unknown";
+  const agentName = options.agentName || "unknown";
+  const timestamp = Date.now();
+  const { CLAUDECODE: _claudeCode, ...cleanEnv } = process.env;
+  const providerEnv = {
+    ...cleanEnv,
+    SQUADS_SQUAD: squadName,
+    SQUADS_AGENT: agentName,
+    SQUADS_PROVIDER: provider
+  };
+  const branchName = `agent/${squadName}/${agentName}-${timestamp}`;
+  const worktreePath = join5(projectRoot, "..", ".worktrees", `${squadName}-${agentName}-${timestamp}`);
+  let workDir = projectRoot;
+  try {
+    mkdirSync4(join5(projectRoot, "..", ".worktrees"), { recursive: true });
+    execSync3(`git worktree add '${worktreePath}' -b '${branchName}' HEAD`, { cwd: projectRoot, stdio: "pipe" });
+    workDir = worktreePath;
+  } catch (e) {
+    writeLine(`  ${colors.dim}warn: worktree creation failed, using project root: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+  }
+  let effectivePrompt = prompt;
+  if (workDir !== projectRoot) {
+    const agentsDir = join5(projectRoot, ".agents");
+    const targetAgentsDir = join5(workDir, ".agents");
+    if (existsSync5(agentsDir) && !existsSync5(targetAgentsDir)) {
+      try {
+        cpSync(agentsDir, targetAgentsDir, { recursive: true });
+      } catch (e) {
+        writeLine(`  ${colors.dim}warn: .agents copy failed: ${e instanceof Error ? e.message : String(e)}${RESET}`);
+      }
+    }
+    effectivePrompt = prompt.replaceAll(projectRoot, workDir);
+  }
+  const args = cliConfig.buildArgs(effectivePrompt);
+  if (options.verbose) {
+    writeLine(`  ${colors.dim}Provider: ${cliConfig.displayName}${RESET}`);
+    writeLine(`  ${colors.dim}Command: ${cliConfig.command} ${args.join(" ").slice(0, VERBOSE_COMMAND_MAX_CHARS)}...${RESET}`);
+    writeLine(`  ${colors.dim}CWD: ${workDir}${RESET}`);
+    if (workDir !== projectRoot) {
+      writeLine(`  ${colors.dim}Worktree: ${branchName}${RESET}`);
+    }
+  }
+  if (options.foreground) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cliConfig.command, args, {
+        stdio: "inherit",
+        cwd: workDir,
+        env: providerEnv
+      });
+      proc.on("close", (code) => {
+        cleanupWorktree(workDir, projectRoot);
+        if (code === 0) {
+          resolve("Session completed");
+        } else {
+          reject(new Error(`${cliConfig.command} exited with code ${code}`));
+        }
+      });
+      proc.on("error", (err) => {
+        cleanupWorktree(workDir, projectRoot);
+        reject(err);
+      });
+    });
+  }
+  const logDir = join5(projectRoot, ".agents", "logs", squadName);
+  const logFile = join5(logDir, `${agentName}-${timestamp}.log`);
+  const pidFile = join5(logDir, `${agentName}-${timestamp}.pid`);
+  if (!existsSync5(logDir)) {
+    mkdirSync4(logDir, { recursive: true });
+  }
+  const escapedPrompt = effectivePrompt.replace(/'/g, "'\\''");
+  const providerArgs = cliConfig.buildArgs(escapedPrompt).map((a) => `'${a}'`).join(" ");
+  const cleanupCmd = workDir !== projectRoot ? `; git -C '${projectRoot}' worktree remove '${workDir}' --force 2>/dev/null; git -C '${projectRoot}' branch -D '${branchName}' 2>/dev/null` : "";
+  const shellScript = `cd '${workDir}' && ${cliConfig.command} ${providerArgs} > '${logFile}' 2>&1${cleanupCmd}`;
+  const wrapperScript = `echo $$ > '${pidFile}'; ${shellScript}`;
+  const child = spawn("sh", ["-c", wrapperScript], {
+    cwd: workDir,
+    detached: true,
+    stdio: "ignore",
+    env: providerEnv
+  });
+  child.unref();
+  if (options.verbose) {
+    writeLine(`  ${colors.dim}Log: ${logFile}${RESET}`);
+    writeLine(`  ${colors.dim}PID file: ${pidFile}${RESET}`);
+  }
+  return `Log: ${logFile}. Monitor: tail -f ${logFile}`;
+}
+async function runSquadCommand(squadName, options) {
+  return runCommand(squadName, options);
+}
+export {
+  runCommand,
+  runSquadCommand
+};
+//# sourceMappingURL=run-I6KAXU6U.js.map