squads-cli 0.6.2 → 0.7.0

package/dist/run-72OQLH5A.js

@@ -0,0 +1,2685 @@
+#!/usr/bin/env node
+import {
+  getCLIConfig,
+  isProviderCLIAvailable
+} from "./chunk-QHNUMM4V.js";
+import {
+  pushCognitionSignal,
+  reportConversationResult,
+  reportExecutionStart
+} from "./chunk-WBR5J7EX.js";
+import {
+  detectProviderFromModel
+} from "./chunk-LOA3KWYJ.js";
+import {
+  getBotGitEnv,
+  getBotPushUrl,
+  getCoAuthorTrailer
+} from "./chunk-FIWT2NMM.js";
+import {
+  parseCooldown
+} from "./chunk-RM6BWILN.js";
+import {
+  isLoggedIn,
+  loadSession
+} from "./chunk-Z2UKDBNL.js";
+import {
+  getApiUrl,
+  getBridgeUrl
+} from "./chunk-OQJHPULO.js";
+import {
+  Events,
+  flushEvents,
+  track
+} from "./chunk-L6GQCHDF.js";
+import {
+  findSquadsDir,
+  listAgents,
+  loadAgentDefinition,
+  loadSquad,
+  parseAgentProvider,
+  resolveMcpConfigPath
+} from "./chunk-LDM62TIX.js";
+import {
+  findMemoryDir
+} from "./chunk-ZTQ7ISUR.js";
+import {
+  RESET,
+  bold,
+  colors,
+  gradient,
+  icons,
+  writeLine
+} from "./chunk-N7KDWU4W.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/commands/run.ts
+import ora from "ora";
+import { spawn, execSync as execSync2 } from "child_process";
+import { join as join2, dirname } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync, 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 } from "path";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+
+// 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 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" };
+    }
+  }
+  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/workflow.ts
+var execAsync = promisify(exec);
+var DEFAULT_MAX_TURNS = 20;
+var DEFAULT_COST_CEILING = 25;
+function executeAgentTurn(config) {
+  const { agentName, agentPath, role, squadName, model, transcript, task } = config;
+  const transcriptContext = serializeTranscript(transcript);
+  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 that pass CI using \`gh pr merge --squash --delete-branch\``;
+      }
+      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}
+
+${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 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: {
+          ...process.env,
+          CLAUDECODE: "",
+          // Allow nested sessions
+          ANTHROPIC_API_KEY: void 0
+          // Use Max subscription
+        }
+      }
+    );
+    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, 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, "'\\''");
+  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: {
+          ...process.env,
+          CLAUDECODE: "",
+          ANTHROPIC_API_KEY: void 0
+        }
+      },
+      (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 = join(squadsDir, squad.dir, `${agent.name}.md`);
+    if (!existsSync(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 = join(squadsDir, "..", "..", "..");
+      const candidatePath = join(reposRoot, repoName);
+      if (existsSync(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 = join(squadsDir, "..", "conversations", transcript.squad);
+  if (!existsSync(convDir)) {
+    mkdirSync(convDir, { recursive: true });
+  }
+  const id = Date.now().toString(36);
+  const filePath = join(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/commands/run.ts
+import { homedir } from "os";
+var CLOUD_POLL_INTERVAL_MS = 3e3;
+var CLOUD_POLL_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_LEARNINGS_LIMIT = 5;
+var DEFAULT_CONTEXT_TOKENS = 8e3;
+var DEFAULT_FALLBACK_CHARS = 2e3;
+var MAX_AGENT_BRIEFS = 3;
+var MAX_SQUAD_BRIEFS = 2;
+var MAX_LEARNINGS_CHARS = 1500;
+var MAX_LEAD_STATE_CHARS = 1e3;
+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
+      })
+    });
+    if (!response.ok) {
+      return false;
+    }
+    return true;
+  } catch {
+    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 })
+    });
+    if (!response.ok) {
+      return { allowed: true, gates: {} };
+    }
+    return await response.json();
+  } catch {
+    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}`
+    );
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return data.learnings || [];
+  } catch {
+    return [];
+  }
+}
+function loadApprovalInstructions() {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return "";
+  const instructionsPath = join2(dirname(squadsDir), "config", "approval-instructions.md");
+  if (existsSync2(instructionsPath)) {
+    try {
+      return readFileSync2(instructionsPath, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function loadPostExecution(squadName, agentName) {
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    const postExecPath = join2(dirname(squadsDir), "config", "post-execution.md");
+    if (existsSync2(postExecPath)) {
+      try {
+        const template = readFileSync2(postExecPath, "utf-8");
+        return template.replace(/\{\{squadName\}\}/g, squadName).replace(/\{\{agentName\}\}/g, agentName);
+      } catch {
+      }
+    }
+  }
+  return `After completion:
+- Create a branch, commit with Conventional Commits, push, and open a PR targeting develop
+- NEVER commit to main directly
+- Type /exit when done`;
+}
+function gatherSquadContext(squadName, agentName, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return "";
+  const memoryDir = findMemoryDir();
+  const maxTokens = options.maxTokens || DEFAULT_CONTEXT_TOKENS;
+  const sections = [];
+  let estimatedTokens = 0;
+  const estimateTokens = (text) => Math.ceil(text.length / 4);
+  const squadFile = join2(squadsDir, squadName, "SQUAD.md");
+  if (existsSync2(squadFile)) {
+    try {
+      const squadContent = readFileSync2(squadFile, "utf-8");
+      const missionMatch = squadContent.match(/## Mission[\s\S]*?(?=\n## |$)/i);
+      const goalsMatch = squadContent.match(/## (?:Goals|Objectives)[\s\S]*?(?=\n## |$)/i);
+      const outputMatch = squadContent.match(/## Output[\s\S]*?(?=\n## |$)/i);
+      const contextMatch = squadContent.match(/## Context[\s\S]*?(?=\n## |$)/i);
+      let squadContext = "";
+      if (missionMatch) squadContext += missionMatch[0] + "\n";
+      if (goalsMatch) squadContext += goalsMatch[0] + "\n";
+      if (outputMatch) squadContext += outputMatch[0] + "\n";
+      if (contextMatch) squadContext += contextMatch[0] + "\n";
+      if (!squadContext && squadContent.length > 0) {
+        squadContext = squadContent.substring(0, DEFAULT_FALLBACK_CHARS);
+      }
+      if (squadContext) {
+        const tokens = estimateTokens(squadContext);
+        if (estimatedTokens + tokens < maxTokens) {
+          sections.push(`## Squad Context (${squadName})
+${squadContext.trim()}`);
+          estimatedTokens += tokens;
+        }
+      }
+    } catch {
+    }
+  }
+  if (memoryDir) {
+    const stateFile = join2(memoryDir, squadName, agentName, "state.md");
+    if (existsSync2(stateFile)) {
+      try {
+        const stateContent = readFileSync2(stateFile, "utf-8");
+        const tokens = estimateTokens(stateContent);
+        if (estimatedTokens + tokens < maxTokens && stateContent.trim()) {
+          sections.push(`## Your Previous State
+This is your memory from your last execution:
+
+${stateContent.trim()}`);
+          estimatedTokens += tokens;
+        }
+      } catch {
+      }
+    }
+  }
+  if (memoryDir) {
+    const briefsDir = join2(memoryDir, squadName, agentName, "briefs");
+    if (existsSync2(briefsDir)) {
+      try {
+        const briefFiles = readdirSync(briefsDir).filter((f) => f.endsWith(".md")).slice(0, MAX_AGENT_BRIEFS);
+        for (const briefFile of briefFiles) {
+          const briefPath = join2(briefsDir, briefFile);
+          const briefContent = readFileSync2(briefPath, "utf-8");
+          const tokens = estimateTokens(briefContent);
+          if (estimatedTokens + tokens < maxTokens) {
+            sections.push(`## Brief: ${briefFile.replace(".md", "")}
+${briefContent.trim()}`);
+            estimatedTokens += tokens;
+          } else {
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (memoryDir) {
+    const squadBriefsDir = join2(memoryDir, squadName, "_briefs");
+    if (existsSync2(squadBriefsDir)) {
+      try {
+        const squadBriefs = readdirSync(squadBriefsDir).filter((f) => f.endsWith(".md")).slice(0, MAX_SQUAD_BRIEFS);
+        for (const briefFile of squadBriefs) {
+          const briefPath = join2(squadBriefsDir, briefFile);
+          const briefContent = readFileSync2(briefPath, "utf-8");
+          const tokens = estimateTokens(briefContent);
+          if (estimatedTokens + tokens < maxTokens) {
+            sections.push(`## Squad Brief: ${briefFile.replace(".md", "")}
+${briefContent.trim()}`);
+            estimatedTokens += tokens;
+          } else {
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (memoryDir) {
+    const briefingPath = join2(memoryDir, "daily-briefing.md");
+    if (existsSync2(briefingPath)) {
+      try {
+        const briefingContent = readFileSync2(briefingPath, "utf-8");
+        if (briefingContent.trim()) {
+          const tokens = estimateTokens(briefingContent);
+          if (estimatedTokens + tokens < maxTokens) {
+            sections.push(`## Daily Briefing
+${briefingContent.trim()}`);
+            estimatedTokens += tokens;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (memoryDir && options.agentPath) {
+    const frontmatter = parseAgentFrontmatter(options.agentPath);
+    if (frontmatter.context_from && frontmatter.context_from.length > 0) {
+      for (const relatedSquad of frontmatter.context_from) {
+        const learningsPath = join2(memoryDir, relatedSquad, "shared", "learnings.md");
+        if (existsSync2(learningsPath)) {
+          try {
+            let learningsContent = readFileSync2(learningsPath, "utf-8");
+            if (learningsContent.trim()) {
+              if (learningsContent.length > MAX_LEARNINGS_CHARS) {
+                learningsContent = learningsContent.slice(0, MAX_LEARNINGS_CHARS) + "\n...(truncated)";
+              }
+              const tokens = estimateTokens(learningsContent);
+              if (estimatedTokens + tokens < maxTokens) {
+                sections.push(`## ${relatedSquad} Squad Learnings
+${learningsContent.trim()}`);
+                estimatedTokens += tokens;
+              }
+            }
+          } catch {
+          }
+        }
+        const leadStatePath = join2(memoryDir, relatedSquad, `${relatedSquad}-lead`, "state.md");
+        if (existsSync2(leadStatePath)) {
+          try {
+            let leadState = readFileSync2(leadStatePath, "utf-8");
+            if (leadState.trim()) {
+              if (leadState.length > MAX_LEAD_STATE_CHARS) {
+                leadState = leadState.slice(0, MAX_LEAD_STATE_CHARS) + "\n...(truncated)";
+              }
+              const tokens = estimateTokens(leadState);
+              if (estimatedTokens + tokens < maxTokens) {
+                sections.push(`## ${relatedSquad} Lead State
+${leadState.trim()}`);
+                estimatedTokens += tokens;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  if (options.verbose) {
+    writeLine(`  ${colors.dim}Context: ${sections.length} sections (~${estimatedTokens} tokens)${RESET}`);
+  }
+  return `
+# EXISTING CONTEXT
+Build on this existing knowledge - do NOT start from scratch:
+
+${sections.join("\n\n")}
+`;
+}
+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 = join2(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 = join2(configsDir, configFile);
+    if (existsSync2(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 = join2(process.env.HOME || "", ".claude.json");
+  if (!existsSync2(configPath)) {
+    return;
+  }
+  try {
+    const config = JSON.parse(readFileSync2(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;
+      writeFileSync2(configPath, JSON.stringify(config, null, 2));
+    }
+  } catch {
+  }
+}
+function getProjectRoot() {
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    return dirname(dirname(squadsDir));
+  }
+  return process.cwd();
+}
+function getExecutionLogPath(squadName, agentName) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return null;
+  return join2(memoryDir, squadName, agentName, "executions.md");
+}
+function logExecution(record) {
+  const logPath = getExecutionLogPath(record.squadName, record.agentName);
+  if (!logPath) return;
+  const dir = dirname(logPath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync2(logPath)) {
+    content = readFileSync2(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"}
+`;
+  writeFileSync2(logPath, content + entry);
+}
+function updateExecutionStatus(squadName, agentName, executionId, status, details) {
+  const logPath = getExecutionLogPath(squadName, agentName);
+  if (!logPath || !existsSync2(logPath)) return;
+  let content = readFileSync2(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);
+  writeFileSync2(logPath, content);
+}
+async function autoCommitAgentWork(squadName, agentName, executionId, provider2) {
+  const { execSync: execSync3 } = await import("child_process");
+  const { detectGitHubRepo } = await import("./github-UQTM5KMS.js");
+  const projectRoot = getProjectRoot();
+  try {
+    const status = execSync3("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 }
+    };
+    execSync3("git add -A", execOpts);
+    const shortExecId = executionId.slice(0, 12);
+    const coAuthor = getCoAuthorTrailer(provider2 || "claude");
+    const msgFile = join2(projectRoot, ".git", "SQUADS_COMMIT_MSG");
+    writeFileSync2(msgFile, `feat(${squadName}/${agentName}): execution ${shortExecId}
+
+${coAuthor}
+`);
+    try {
+      execSync3(`git commit --file "${msgFile}"`, execOpts);
+    } finally {
+      try {
+        unlinkSync(msgFile);
+      } catch {
+      }
+    }
+    try {
+      const { spawnSync } = await import("child_process");
+      const repo = detectGitHubRepo(projectRoot);
+      if (repo && /^[\w.-]+\/[\w.-]+$/.test(repo)) {
+        const pushUrl = await getBotPushUrl(repo);
+        if (pushUrl) {
+          spawnSync("git", ["push", pushUrl, "HEAD"], { ...execOpts, stdio: "pipe" });
+        } else {
+          spawnSync("git", ["push", "origin", "HEAD"], { ...execOpts, stdio: "pipe" });
+        }
+      } else {
+        spawnSync("git", ["push", "origin", "HEAD"], { ...execOpts, stdio: "pipe" });
+      }
+    } catch {
+    }
+    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 || !existsSync2(logPath)) return null;
+  const content = readFileSync2(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`;
+}
+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 parseAgentFrontmatter(agentPath) {
+  if (!existsSync2(agentPath)) return {};
+  const content = readFileSync2(agentPath, "utf-8");
+  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;
+}
+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 = join2(memDir, data.squad, data.agent);
+    if (!existsSync2(eventsDir)) {
+      mkdirSync2(eventsDir, { recursive: true });
+    }
+    const eventsPath = join2(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 (existsSync2(eventsPath)) {
+      existing = readFileSync2(eventsPath, "utf-8");
+    }
+    writeFileSync2(eventsPath, existing + entry);
+  } catch {
+  }
+}
+async function verifyExecution(squadName, agentName, criteria, options = {}) {
+  const { execSync: execSync3 } = await import("child_process");
+  const projectRoot = getProjectRoot();
+  let stateContent = "";
+  const memDir = findMemoryDir();
+  if (memDir) {
+    const statePath = join2(memDir, squadName, agentName, "state.md");
+    if (existsSync2(statePath)) {
+      stateContent = readFileSync2(statePath, "utf-8").slice(0, VERIFICATION_STATE_MAX_CHARS);
+    }
+  }
+  let recentCommits = "";
+  try {
+    recentCommits = execSync3("git log --oneline -5 --no-color", {
+      encoding: "utf-8",
+      cwd: projectRoot
+    }).trim();
+  } catch {
+    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 = execSync3(
+      `claude --print --model haiku -- '${escapedPrompt}'`,
+      { encoding: "utf-8", cwd: projectRoot, timeout: VERIFICATION_EXEC_TIMEOUT_MS }
+    ).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 {
+      }
+      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;
+  }
+  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 provider2 = options.provider || squad?.providers?.default || "anthropic";
+    const checksOk = await preflightExecutorCheck(provider2);
+    if (!checksOk) {
+      process.exit(1);
+    }
+  }
+  if (squad) {
+    await track(Events.CLI_RUN, { type: "squad", target: squad.name });
+    await flushEvents();
+    await runSquad(squad, squadsDir, 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 squadName2 = squadIdx >= 0 ? pathParts[squadIdx + 1] : "unknown";
+      await runAgent(agent.name, agent.filePath, squadName2, options);
+    } else {
+      writeLine(`  ${colors.red}Squad or agent "${target}" not found${RESET}`);
+      writeLine(`  ${colors.dim}Run \`squads list\` 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: join2(squadsDir, squad.dir, `${a.name}.md`)
+    })).filter((a) => existsSync2(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 = join2(squadsDir, squad.dir, `${agentName}.md`);
+      if (existsSync2(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 = join2(squadsDir, squad.dir, `${options.agent}.md`);
+      if (existsSync2(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();
+}
+async function runLeadMode(squad, squadsDir, options) {
+  if (!squad) return;
+  const agentFiles = squad.agents.map((a) => ({
+    name: a.name,
+    path: join2(squadsDir, squad.dir, `${a.name}.md`),
+    role: a.role || ""
+  })).filter((a) => existsSync2(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 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;
+  }
+  const isBackground = options.background === true && !options.watch;
+  const isWatch = options.watch === true;
+  const isForeground = !isBackground && !isWatch;
+  const modeText = isBackground ? " (background)" : isWatch ? " (watch)" : "";
+  writeLine(`  ${gradient("Launching")} lead session${modeText}...`);
+  writeLine();
+  try {
+    const leadAgentName = agentFiles.find((a) => a.name.includes("lead"))?.name || `${squad.dir}-lead`;
+    const 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
+    });
+    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) {
+    writeLine(`  ${icons.error} ${colors.red}Failed to launch: ${error}${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 dryRunContext = gatherSquadContext(squadName, agentName, { verbose: options.verbose, agentPath });
+    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 = join2(squadsDir, squadName, "SQUAD.md");
+    if (existsSync2(squadFilePath)) {
+      const squadContent = readFileSync2(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 approvalInstructions = loadApprovalInstructions();
+  const approvalContext = approvalInstructions ? `
+${approvalInstructions}
+` : "";
+  const squadContext = gatherSquadContext(squadName, agentName, { verbose: options.verbose, agentPath });
+  let cognitionContext = "";
+  try {
+    const { loadSession: loadSession2 } = await import("./auth-YW3UPFSB.js");
+    const { getApiUrl: getApiUrl2 } = await import("./env-config-KCLDBKYX.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 {
+  }
+  const timeoutMins = options.timeout || DEFAULT_TIMEOUT_MINUTES;
+  const prompt = `Execute the ${agentName} agent from squad ${squadName}.
+
+Read the agent definition at ${agentPath} and follow its instructions exactly.
+
+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
+${squadContext}${cognitionContext}${learningContext}${approvalContext}
+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
+
+${loadPostExecution(squadName, agentName)}`;
+  const agentProvider = parseAgentProvider(agentPath);
+  const squad = loadSquad(squadName);
+  const squadDefaultProvider = squad?.providers?.default;
+  const provider2 = agentProvider || options.provider || squadDefaultProvider || "anthropic";
+  const isAnthropic = provider2 === "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: ${provider2}${RESET}`);
+  }
+  const cliAvailable = isAnthropic ? await checkClaudeCliAvailable() : isProviderCLIAvailable(provider2);
+  if (options.execute && cliAvailable) {
+    const cliConfig = getCLIConfig(provider2);
+    const cliName = cliConfig?.displayName || provider2;
+    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(provider2, 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
+        });
+        writeLine(`  ${colors.red}${String(error)}${RESET}`);
+        break;
+      }
+    }
+  } else {
+    spinner.succeed(`Agent ${agentName} ready`);
+    writeLine(`  ${colors.dim}Execution logged: ${startTime}${RESET}`);
+    if (!cliAvailable) {
+      const cliConfig = getCLIConfig(provider2);
+      writeLine();
+      writeLine(`  ${colors.yellow}${cliConfig?.command || provider2} 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 (provider2 !== "anthropic") {
+      writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} -a ${colors.cyan}${agentName}${RESET} --provider=${provider2}`);
+    }
+    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(provider2) {
+  if (process.env.SQUADS_SKIP_CHECKS === "1") {
+    return true;
+  }
+  const isAnthropic = provider2 === "anthropic";
+  let cliFound;
+  if (isAnthropic) {
+    cliFound = await checkClaudeCliAvailable();
+  } else {
+    cliFound = isProviderCLIAvailable(provider2);
+  }
+  if (!cliFound) {
+    const cliConfig = getCLIConfig(provider2);
+    const cliName = cliConfig?.command || provider2;
+    const installCmd = cliConfig?.install || `See ${provider2} 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;
+  }
+  if (isAnthropic) {
+    const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+    const home = homedir();
+    const credentialsPath = join2(home, ".claude", ".credentials.json");
+    const hasOAuthCreds = existsSync2(credentialsPath);
+    if (!hasApiKey && !hasOAuthCreds) {
+      writeLine(`  ${colors.dim}${icons.progress} No API key or credentials file found \u2014 assuming OAuth${RESET}`);
+    }
+  }
+  return true;
+}
+function buildAgentEnv(baseEnv, execContext, options) {
+  const env = {
+    ...baseEnv,
+    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?.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 createAgentWorktree(projectRoot, squadName, agentName) {
+  const timestamp = Date.now();
+  const branchName = `agent/${squadName}/${agentName}-${timestamp}`;
+  const worktreePath = join2(projectRoot, "..", ".worktrees", `${squadName}-${agentName}-${timestamp}`);
+  try {
+    mkdirSync2(join2(projectRoot, "..", ".worktrees"), { recursive: true });
+    execSync2(`git worktree add '${worktreePath}' -b '${branchName}' HEAD`, { cwd: projectRoot, stdio: "pipe" });
+    return worktreePath;
+  } catch {
+    return projectRoot;
+  }
+}
+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 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}"; claude --print --dangerously-skip-permissions ${modelFlag} -- '${config.escapedPrompt}' > '${config.logFile}' 2>&1`;
+  return `echo $$ > '${config.pidFile}'; ${script}`;
+}
+function prepareLogFiles(projectRoot, squadName, agentName, timestamp) {
+  const logDir = join2(projectRoot, ".agents", "logs", squadName);
+  const logFile = join2(logDir, `${agentName}-${timestamp}.log`);
+  const pidFile = join2(logDir, `${agentName}-${timestamp}.pid`);
+  if (!existsSync2(logDir)) {
+    mkdirSync2(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}`);
+        }
+        resolve("Session completed");
+      } else {
+        updateExecutionStatus(config.squadName, config.agentName, config.execContext.executionId, "failed", {
+          error: `Claude exited with code ${code}`,
+          durationMs
+        });
+        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
+      });
+      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 detectedProvider = resolvedModel ? detectProviderFromModel(resolvedModel) : "anthropic";
+  if (detectedProvider !== "anthropic" && detectedProvider !== "unknown") {
+    if (verbose) {
+      const source = model ? "explicit" : "auto-routed";
+      writeLine(`  ${colors.dim}Model: ${resolvedModel} (${source})${RESET}`);
+      writeLine(`  ${colors.dim}Provider: ${detectedProvider}${RESET}`);
+    }
+    return executeWithProvider(detectedProvider, prompt, {
+      verbose,
+      foreground,
+      cwd: projectRoot,
+      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);
+  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");
+    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
+    });
+    return executeForeground({
+      prompt,
+      claudeArgs,
+      agentEnv: agentEnv2,
+      projectRoot,
+      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
+  });
+  const wrapperScript = buildDetachedShellScript({
+    projectRoot,
+    squadName,
+    agentName,
+    timestamp,
+    claudeModelAlias,
+    escapedPrompt,
+    logFile,
+    pidFile
+  });
+  if (runInWatch) {
+    if (verbose) {
+      logVerboseExecution({
+        projectRoot,
+        mode: "watch (background + tail)",
+        execContext,
+        logFile
+      });
+    }
+    return executeWatch({ projectRoot, 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: projectRoot,
+    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(provider2, prompt, options) {
+  const cliConfig = getCLIConfig(provider2);
+  if (!cliConfig) {
+    throw new Error(`Unknown provider: ${provider2}. Run 'squads providers' to see available providers.`);
+  }
+  if (!isProviderCLIAvailable(provider2)) {
+    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: provider2
+  };
+  const branchName = `agent/${squadName}/${agentName}-${timestamp}`;
+  const worktreePath = join2(projectRoot, "..", ".worktrees", `${squadName}-${agentName}-${timestamp}`);
+  let workDir = projectRoot;
+  try {
+    mkdirSync2(join2(projectRoot, "..", ".worktrees"), { recursive: true });
+    execSync2(`git worktree add '${worktreePath}' -b '${branchName}' HEAD`, { cwd: projectRoot, stdio: "pipe" });
+    workDir = worktreePath;
+  } catch {
+  }
+  let effectivePrompt = prompt;
+  if (workDir !== projectRoot) {
+    const agentsDir = join2(projectRoot, ".agents");
+    const targetAgentsDir = join2(workDir, ".agents");
+    if (existsSync2(agentsDir) && !existsSync2(targetAgentsDir)) {
+      try {
+        cpSync(agentsDir, targetAgentsDir, { recursive: true });
+      } catch {
+      }
+    }
+    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) => {
+        if (code === 0) {
+          resolve("Session completed");
+        } else {
+          reject(new Error(`${cliConfig.command} exited with code ${code}`));
+        }
+      });
+      proc.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  const logDir = join2(projectRoot, ".agents", "logs", squadName);
+  const logFile = join2(logDir, `${agentName}-${timestamp}.log`);
+  const pidFile = join2(logDir, `${agentName}-${timestamp}.pid`);
+  if (!existsSync2(logDir)) {
+    mkdirSync2(logDir, { recursive: true });
+  }
+  const escapedPrompt = effectivePrompt.replace(/'/g, "'\\''");
+  const providerArgs = cliConfig.buildArgs(escapedPrompt).map((a) => `'${a}'`).join(" ");
+  const shellScript = `cd '${workDir}' && ${cliConfig.command} ${providerArgs} > '${logFile}' 2>&1`;
+  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-72OQLH5A.js.map