squads-cli 0.3.0 → 0.4.0

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   cleanupStaleSessions,
   colors,
   detectSquad,
-  getLiveSessionSummary,
+  getLiveSessionSummaryAsync,
   gradient,
   icons,
   padEnd,
@@ -28,30 +28,36 @@ import {
   truncate,
   updateHeartbeat,
   writeLine
-} from "./chunk-266URT5W.js";
-import "./chunk-7OCVIDC7.js";
+} from "./chunk-G63RBKDH.js";
+import {
+  __require
+} from "./chunk-7OCVIDC7.js";
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync15 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir6 } from "os";
 import { Command } from "commander";
 import chalk4 from "chalk";
 
 // src/version.ts
-var version = "0.1.0";
+var version = "0.3.0";
 
 // src/commands/init.ts
 import chalk from "chalk";
 import ora from "ora";
 import fs from "fs/promises";
 import path from "path";
+import { execSync as execSync2, spawn } from "child_process";
+import { createInterface } from "readline";
 
 // src/lib/git.ts
-import { execSync } from "child_process";
+import { execSync, exec } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
 function checkGitStatus(cwd = process.cwd()) {
   const status = {
     isGitRepo: false,
@@ -64,34 +70,34 @@ function checkGitStatus(cwd = process.cwd()) {
   }
   status.isGitRepo = true;
   try {
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    status.branch = branch;
-    const remotes = execSync("git remote -v", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (remotes) {
-      status.hasRemote = true;
-      const lines = remotes.split("\n");
-      if (lines.length > 0) {
-        const parts = lines[0].split(/\s+/);
-        status.remoteName = parts[0];
-        status.remoteUrl = parts[1];
+    const combined = execSync(
+      'echo "BRANCH:" && git rev-parse --abbrev-ref HEAD && echo "REMOTES:" && git remote -v && echo "STATUS:" && git status --porcelain',
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+    );
+    const branchMatch = combined.match(/BRANCH:\n(.+)\n/);
+    if (branchMatch) {
+      status.branch = branchMatch[1].trim();
+    }
+    const remotesMatch = combined.match(/REMOTES:\n([\s\S]*?)STATUS:/);
+    if (remotesMatch) {
+      const remotes = remotesMatch[1].trim();
+      if (remotes) {
+        status.hasRemote = true;
+        const lines = remotes.split("\n");
+        if (lines.length > 0) {
+          const parts = lines[0].split(/\s+/);
+          status.remoteName = parts[0];
+          status.remoteUrl = parts[1];
+        }
       }
     }
-    const statusOutput = execSync("git status --porcelain", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (statusOutput) {
-      status.isDirty = true;
-      status.uncommittedCount = statusOutput.split("\n").filter((l) => l.trim()).length;
+    const statusMatch = combined.match(/STATUS:\n([\s\S]*?)$/);
+    if (statusMatch) {
+      const statusOutput = statusMatch[1].trim();
+      if (statusOutput) {
+        status.isDirty = true;
+        status.uncommittedCount = statusOutput.split("\n").filter((l) => l.trim()).length;
+      }
     }
   } catch {
   }
@@ -294,7 +300,7 @@ function getMultiRepoGitStats(basePath, days = 30) {
       const authors = /* @__PURE__ */ new Set();
       let lastCommit = "";
       for (const line of commits) {
-        const [hash, author, date, message] = line.split("|");
+        const [hash, author, date] = line.split("|");
         if (!hash) continue;
         stats.totalCommits++;
         authors.add(author);
@@ -335,9 +341,6 @@ function getActivitySparkline(basePath, days = 7) {
   const activity = [];
   const now = /* @__PURE__ */ new Date();
   for (let i = days - 1; i >= 0; i--) {
-    const date = new Date(now);
-    date.setDate(date.getDate() - i);
-    const dateStr = date.toISOString().split("T")[0];
     activity.push(0);
   }
   for (const repo of SQUAD_REPOS) {
@@ -480,6 +483,7 @@ var Events = {
   CLI_STATUS: "cli.status",
   CLI_DASHBOARD: "cli.dashboard",
   CLI_WORKERS: "cli.workers",
+  CLI_TONIGHT: "cli.tonight",
   // Goals
   CLI_GOAL_SET: "cli.goal.set",
   CLI_GOAL_LIST: "cli.goal.list",
@@ -508,7 +512,7 @@ function registerExitHandler() {
       await flushEvents();
     }
   });
-  const signalHandler = async (signal) => {
+  const signalHandler = async (_signal) => {
     if (eventQueue.length > 0) {
       await flushEvents();
     }
@@ -519,32 +523,302 @@ function registerExitHandler() {
 }
 
 // src/commands/init.ts
+async function confirm(question, defaultYes = true) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve) => {
+    rl.question(`  ${question} ${chalk.dim(suffix)} `, (answer) => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      if (normalized === "") {
+        resolve(defaultYes);
+      } else {
+        resolve(normalized === "y" || normalized === "yes");
+      }
+    });
+  });
+}
+function commandExists(cmd) {
+  try {
+    execSync2(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function dockerRunning() {
+  try {
+    execSync2("docker info", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkClaudeAuth() {
+  try {
+    execSync2("which claude", { stdio: "ignore" });
+  } catch {
+    return { installed: false, loggedIn: false };
+  }
+  try {
+    const result = execSync2("claude --version", { stdio: "pipe" }).toString();
+    return { installed: true, loggedIn: result.includes("claude") };
+  } catch {
+    return { installed: true, loggedIn: false };
+  }
+}
+function checkGhAuth() {
+  try {
+    execSync2("gh auth status", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkRequirements() {
+  const checks = [];
+  const claudeStatus = checkClaudeAuth();
+  if (claudeStatus.installed && claudeStatus.loggedIn) {
+    checks.push({ name: "Claude CLI", status: "ok" });
+  } else if (claudeStatus.installed) {
+    checks.push({
+      name: "Claude CLI",
+      status: "warning",
+      message: "Installed but may need login",
+      hint: "Run: claude login"
+    });
+  } else {
+    checks.push({
+      name: "Claude CLI",
+      status: "missing",
+      message: "Required to run agents",
+      hint: "Install: npm install -g @anthropic-ai/claude-code"
+    });
+  }
+  if (checkGhAuth()) {
+    checks.push({ name: "GitHub CLI", status: "ok" });
+  } else if (commandExists("gh")) {
+    checks.push({
+      name: "GitHub CLI",
+      status: "warning",
+      message: "Installed but not logged in",
+      hint: "Run: gh auth login"
+    });
+  } else {
+    checks.push({
+      name: "GitHub CLI",
+      status: "missing",
+      message: "Required for GitHub integration (issues, PRs)",
+      hint: "Install: https://cli.github.com"
+    });
+  }
+  if (commandExists("docker")) {
+    if (dockerRunning()) {
+      checks.push({ name: "Docker", status: "ok" });
+    } else {
+      checks.push({
+        name: "Docker",
+        status: "warning",
+        message: "Installed but not running",
+        hint: "Start Docker Desktop or run: sudo systemctl start docker"
+      });
+    }
+  } else {
+    checks.push({
+      name: "Docker",
+      status: "warning",
+      message: "Optional - enables dashboard metrics",
+      hint: "Install: https://docker.com"
+    });
+  }
+  return checks;
+}
+async function setupInfrastructure(cwd) {
+  const spinner = ora("Setting up infrastructure...").start();
+  try {
+    let dockerDir = null;
+    const localDockerCompose = path.join(cwd, "docker", "docker-compose.yml");
+    const localDockerComposeRoot = path.join(cwd, "docker-compose.yml");
+    if (await fileExists(localDockerCompose)) {
+      dockerDir = path.join(cwd, "docker");
+    } else if (await fileExists(localDockerComposeRoot)) {
+      dockerDir = cwd;
+    } else {
+      const cliPath = new URL("../..", import.meta.url).pathname;
+      const bundledDockerCompose = path.join(cliPath, "docker", "docker-compose.yml");
+      if (await fileExists(bundledDockerCompose)) {
+        spinner.text = "Copying infrastructure files...";
+        const targetDockerDir = path.join(cwd, "docker");
+        await fs.mkdir(targetDockerDir, { recursive: true });
+        const filesToCopy = [
+          "docker-compose.yml",
+          ".env.example",
+          "init-db.sql",
+          "README.md"
+        ];
+        for (const file of filesToCopy) {
+          const src = path.join(cliPath, "docker", file);
+          const dest = path.join(targetDockerDir, file);
+          if (await fileExists(src)) {
+            await fs.copyFile(src, dest);
+          }
+        }
+        const bridgeSrc = path.join(cliPath, "docker", "squads-bridge");
+        const bridgeDest = path.join(targetDockerDir, "squads-bridge");
+        if (await fileExists(bridgeSrc)) {
+          await copyDir(bridgeSrc, bridgeDest);
+        }
+        const envExample = path.join(targetDockerDir, ".env.example");
+        const envFile = path.join(targetDockerDir, ".env");
+        if (await fileExists(envExample) && !await fileExists(envFile)) {
+          await fs.copyFile(envExample, envFile);
+        }
+        dockerDir = targetDockerDir;
+      }
+    }
+    if (!dockerDir) {
+      spinner.fail("Could not find docker-compose.yml");
+      console.log(chalk.dim("  Try cloning the full repo: git clone https://github.com/agents-squads/hq"));
+      return false;
+    }
+    spinner.text = "Starting containers...";
+    await new Promise((resolve, reject) => {
+      const proc = spawn("docker", ["compose", "up", "-d"], {
+        cwd: dockerDir,
+        stdio: "pipe"
+      });
+      let stderr = "";
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(stderr || `docker compose failed with code ${code}`));
+        }
+      });
+      proc.on("error", reject);
+    });
+    spinner.text = "Waiting for services to be ready...";
+    await sleep(3e3);
+    const services = ["squads-postgres", "squads-redis", "squads-bridge"];
+    let allRunning = true;
+    for (const service of services) {
+      try {
+        execSync2(`docker ps --filter "name=${service}" --filter "status=running" -q`, { stdio: "pipe" });
+      } catch {
+        allRunning = false;
+      }
+    }
+    if (allRunning) {
+      spinner.succeed("Infrastructure ready");
+      console.log();
+      console.log(chalk.dim("  Services running:"));
+      console.log(chalk.dim("  \u2022 postgres:5432  \u2022 redis:6379  \u2022 bridge:8088"));
+      return true;
+    } else {
+      spinner.warn("Some services may not be running");
+      console.log(chalk.dim("  Check with: docker ps"));
+      return true;
+    }
+  } catch (error) {
+    spinner.fail("Failed to start infrastructure");
+    console.log(chalk.dim(`  ${error}`));
+    console.log(chalk.dim("  Try manually: cd docker && docker compose up -d"));
+    return false;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function initCommand(options) {
   const cwd = process.cwd();
-  console.log(chalk.dim("Checking project setup...\n"));
+  console.log();
+  console.log(chalk.bold("  Checking requirements..."));
+  console.log();
+  const checks = checkRequirements();
+  let hasMissingRequired = false;
+  let hasDocker = false;
+  let dockerReady = false;
+  for (const check of checks) {
+    if (check.status === "ok") {
+      console.log(`  ${chalk.green("\u2713")} ${check.name}`);
+      if (check.name === "Docker") {
+        hasDocker = true;
+        dockerReady = true;
+      }
+    } else if (check.status === "missing") {
+      console.log(`  ${chalk.yellow("\u26A0")} ${chalk.yellow(check.name)}`);
+      if (check.message) {
+        console.log(chalk.dim(`    ${check.message}`));
+      }
+      if (check.hint) {
+        console.log(chalk.dim(`    \u2192 ${check.hint}`));
+      }
+      if (check.name !== "Docker") {
+        hasMissingRequired = true;
+      }
+    } else if (check.status === "warning") {
+      console.log(`  ${chalk.dim("\u25CB")} ${check.name} ${chalk.dim(`(${check.message})`)}`);
+      if (check.hint) {
+        console.log(chalk.dim(`    \u2192 ${check.hint}`));
+      }
+      if (check.name === "Docker") {
+        hasDocker = commandExists("docker");
+      }
+    }
+  }
+  console.log();
+  if (hasMissingRequired) {
+    console.log(chalk.yellow("  Install missing tools to continue, then run squads init again."));
+    console.log();
+    return;
+  }
+  console.log(chalk.dim("  Checking project setup..."));
+  console.log();
   const gitStatus = checkGitStatus(cwd);
   if (!gitStatus.isGitRepo) {
-    console.log(chalk.yellow("\u26A0 No git repository found."));
-    console.log(chalk.dim("  Squads work best with git for version control and GitHub integration."));
-    console.log(chalk.dim("  Run: git init && git remote add origin <your-repo-url>\n"));
+    console.log(`  ${chalk.yellow("\u26A0")} No git repository found`);
+    console.log(chalk.dim("    Run: git init && git remote add origin <repo-url>"));
+    console.log();
   } else {
-    console.log(chalk.green("\u2713 Git repository detected"));
+    console.log(`  ${chalk.green("\u2713")} Git repository`);
     if (gitStatus.hasRemote) {
       const repoName = getRepoName(gitStatus.remoteUrl);
-      console.log(chalk.green(`\u2713 Remote: ${chalk.cyan(repoName || gitStatus.remoteUrl)}`));
-    } else {
-      console.log(chalk.yellow("\u26A0 No remote configured."));
-      console.log(chalk.dim("  Add a remote: git remote add origin <your-repo-url>\n"));
-    }
-    if (gitStatus.isDirty) {
-      console.log(chalk.yellow(`\u26A0 ${gitStatus.uncommittedCount} uncommitted changes`));
+      console.log(`  ${chalk.green("\u2713")} Remote: ${chalk.cyan(repoName || gitStatus.remoteUrl)}`);
     }
   }
   console.log();
-  const spinner = ora("Initializing squad project...").start();
+  const spinner = ora("Creating squad structure...").start();
   try {
     const dirs = [
       ".agents/squads",
+      ".agents/squads/demo",
       ".agents/memory",
       ".agents/outputs",
       ".claude"
@@ -552,56 +826,98 @@ async function initCommand(options) {
     for (const dir of dirs) {
       await fs.mkdir(path.join(cwd, dir), { recursive: true });
     }
-    const commitTemplate = `
+    const demoSquadMd = `# Demo Squad
 
-# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-# Commit message format (delete this comment block):
-#
-# <type>(<scope>): <subject>
-#
-# <body>
-#
-# \u{1F916} Generated with [Agents Squads](https://agents-squads.com)
-#
-# Co-Authored-By: <model> <email>
-# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
-# AI Models (add those that contributed to this commit):
-#
-# Model               | Email                      | API Key
-# --------------------|----------------------------|------------------
-# Claude Opus 4.5     | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
-# Claude Sonnet 4     | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
-# Claude Haiku 3.5    | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
-# GPT-4o              | <noreply@openai.com>       | OPENAI_API_KEY
-# GPT-o1              | <noreply@openai.com>       | OPENAI_API_KEY
-# Gemini 2.0 Flash    | <noreply@google.com>       | GEMINI_API_KEY
-# Grok 3              | <noreply@x.ai>             | XAI_API_KEY
-# Perplexity          | <noreply@perplexity.ai>    | PERPLEXITY_API_KEY
-# Manus AI            | <noreply@manus.im>         | MANUS_API_KEY
-#
-# Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
-# Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>
-# Co-Authored-By: Claude Haiku 3.5 <noreply@anthropic.com>
-# Co-Authored-By: GPT-4o <noreply@openai.com>
-# Co-Authored-By: GPT-o1 <noreply@openai.com>
-# Co-Authored-By: Gemini 2.0 Flash <noreply@google.com>
-# Co-Authored-By: Grok 3 <noreply@x.ai>
-# Co-Authored-By: Perplexity <noreply@perplexity.ai>
-# Co-Authored-By: Manus AI <noreply@manus.im>
-# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+Demonstrates squads functionality with safe, educational examples.
+
+## Agents
+
+| Agent | Purpose |
+|-------|---------|
+| welcome | Creates a welcome GitHub issue |
+| analyzer | Analyzes project structure |
+
+## Triggers
+
+None (manual execution only)
+
+## Usage
+
+\`\`\`bash
+squads run demo
+\`\`\`
+
+This will:
+1. Create a GitHub issue explaining what happened
+2. Analyze your project structure
+3. Show results in the dashboard
+
+All demo data is clearly labeled [demo] so you can distinguish it from real data.
 `;
     await fs.writeFile(
-      path.join(cwd, ".agents/commit-template.txt"),
-      commitTemplate
+      path.join(cwd, ".agents/squads/demo/SQUAD.md"),
+      demoSquadMd
+    );
+    const welcomeAgent = `# Welcome Agent
+
+## Purpose
+Create a welcome GitHub issue to demonstrate squads functionality.
+
+## Model
+claude-haiku-3-5
+
+## Tools
+- Bash (gh cli)
+
+## Instructions
+1. Check if a welcome issue already exists
+2. If not, create a new issue titled "[Demo] Welcome to Squads!"
+3. The issue body should explain:
+   - What just happened (squads run demo executed this agent)
+   - What squads are and how they work
+   - Next steps to create their own agents
+
+## Output
+Confirmation message with issue URL.
+
+## Labels
+- demo
+- automated
+`;
+    await fs.writeFile(
+      path.join(cwd, ".agents/squads/demo/welcome.md"),
+      welcomeAgent
     );
-    const mailmap = `# Git author name consolidation
-# Format: Proper Name <proper@email> Commit Name <commit@email>
-# Add entries to consolidate multiple git identities
+    const analyzerAgent = `# Project Analyzer Agent
 
-# AI Contributors
-Agents Squads <agents@agents-squads.com> Agents Squads <agents@agents-squads.com>
+## Purpose
+Analyze project structure and provide insights.
+
+## Model
+claude-haiku-3-5
+
+## Tools
+- Read
+- Glob
+- Bash (ls, find)
+
+## Instructions
+1. Scan the project directory structure
+2. Identify key files (package.json, Cargo.toml, pyproject.toml, etc.)
+3. Summarize the tech stack
+4. Create a brief report
+
+## Output
+Markdown report saved to .agents/outputs/demo/project-analysis.md
+
+## Labels
+- demo
+- analysis
 `;
-    await fs.writeFile(path.join(cwd, ".mailmap"), mailmap);
+    await fs.writeFile(
+      path.join(cwd, ".agents/squads/demo/analyzer.md"),
+      analyzerAgent
+    );
     const claudeSettings = {
       hooks: {
         SessionStart: [
@@ -632,135 +948,115 @@ Agents Squads <agents@agents-squads.com> Agents Squads <agents@agents-squads.com
       path.join(cwd, ".claude/settings.json"),
       JSON.stringify(claudeSettings, null, 2)
     );
-    const exampleAgent = `# Example Agent
-
-## Purpose
-Demonstrate basic agent structure.
-
-## Model
-claude-sonnet-4
-
-## Tools
-- Read
-- Write
-- WebSearch
-
-## Instructions
-1. Greet the user
-2. Ask how you can help
-3. Execute the task
-
-## Output
-Markdown summary of actions taken.
+    const commitTemplate = `
+# Commit message format:
+# <type>(<scope>): <subject>
+#
+# \u{1F916} Generated with [Agents Squads](https://agents-squads.com)
+# Co-Authored-By: Claude <model> <noreply@anthropic.com>
 `;
     await fs.writeFile(
-      path.join(cwd, ".agents/squads/example-agent.md"),
-      exampleAgent
+      path.join(cwd, ".agents/commit-template.txt"),
+      commitTemplate
     );
     const claudeMdPath = path.join(cwd, "CLAUDE.md");
-    try {
-      await fs.access(claudeMdPath);
-    } catch {
+    if (!await fileExists(claudeMdPath)) {
       await fs.writeFile(
         claudeMdPath,
         `# Project Instructions
 
 ## Squads CLI
 
-This project uses AI agent squads. The \`squads\` CLI provides persistent memory across sessions.
+This project uses AI agent squads for automation.
 
-### Key Commands
+### Quick Start
 
-| Command | Purpose |
-|---------|---------|
-| \`squads status\` | Overview of all squads (runs on session start) |
-| \`squads dash\` | Full operational dashboard |
-| \`squads dash --ceo\` | Executive summary with P0/P1 priorities |
-| \`squads goal list\` | View all active goals |
-| \`squads memory query "<topic>"\` | Search squad memory before researching |
-| \`squads run <squad>\` | Execute a squad |
+\`\`\`bash
+squads status          # Overview
+squads dash            # Full dashboard
+squads run demo        # Try the demo squad
+squads run <squad>     # Execute a squad
+\`\`\`
+
+### Memory
 
-### Workflow
+Squads have persistent memory across sessions:
 
-1. **Session Start**: \`squads status\` runs automatically via hook
-2. **Before Research**: Query memory to avoid re-doing work
-3. **Session End**: Memory syncs automatically from git commits
+\`\`\`bash
+squads memory query "<topic>"   # Search memory
+squads memory show <squad>      # View squad memory
+\`\`\`
 
-### Git Commit Format
+### Creating Agents
 
-All commits should use the Agents Squads format:
+Agents are markdown files in \`.agents/squads/<squad>/\`:
 
-\`\`\`
-<type>(<scope>): <subject>
+\`\`\`markdown
+# My Agent
 
-<body>
+## Purpose
+What this agent does.
 
-\u{1F916} Generated with [Agents Squads](https://agents-squads.com)
+## Instructions
+1. Step one
+2. Step two
 
-Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+## Output
+What it produces.
 \`\`\`
-
-**AI Models** (include those that contributed):
-
-| Model | Co-Author Email | API Key Required |
-|-------|-----------------|------------------|
-| Claude Opus 4.5 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
-| Claude Sonnet 4 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
-| Claude Haiku 3.5 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
-| GPT-4o | \`<noreply@openai.com>\` | \`OPENAI_API_KEY\` |
-| GPT-o1 | \`<noreply@openai.com>\` | \`OPENAI_API_KEY\` |
-| Gemini 2.0 Flash | \`<noreply@google.com>\` | \`GEMINI_API_KEY\` |
-| Grok 3 | \`<noreply@x.ai>\` | \`XAI_API_KEY\` |
-| Perplexity | \`<noreply@perplexity.ai>\` | \`PERPLEXITY_API_KEY\` |
-| Manus AI | \`<noreply@manus.im>\` | \`MANUS_API_KEY\` |
-
-### For Reports
-
-Always use CLI commands for status reports:
-- Executive summary: \`squads dash --ceo\`
-- Operational view: \`squads dash\`
-- Goals: \`squads goal list\`
 `
       );
     }
-    spinner.succeed("Squad project initialized!");
+    spinner.succeed("Squad structure created");
     await track(Events.CLI_INIT, {
       hasGit: gitStatus.isGitRepo,
       hasRemote: gitStatus.hasRemote,
-      template: options.template
+      template: options.template,
+      hasDocker
     });
-    console.log(`
-${chalk.green("Success!")} Created squad project structure:
-
-  ${chalk.cyan(".agents/")}
-  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("squads/")}           Squad & agent definitions
-  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("memory/")}           Persistent squad memory
-  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("outputs/")}          Squad outputs
-  ${chalk.dim("\u2514\u2500\u2500")} ${chalk.cyan("commit-template.txt")} Git commit format
-
-  ${chalk.cyan(".mailmap")}              Author name consolidation
-
-${chalk.dim("Commit format:")}
-  \u{1F916} Generated with [Agents Squads](https://agents-squads.com)
-  Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
-
-${chalk.dim("Next steps:")}
-  ${chalk.cyan("1.")} Create a squad: ${chalk.yellow("mkdir .agents/squads/my-squad && touch .agents/squads/my-squad/SQUAD.md")}
-  ${chalk.cyan("2.")} Set a goal: ${chalk.yellow('squads goal set my-squad "Solve a problem"')}
-  ${chalk.cyan("3.")} Run it: ${chalk.yellow("squads run my-squad")}
-
-${chalk.dim("Put your first squad to work solving a problem in minutes.")}
-`);
   } catch (error) {
-    spinner.fail("Failed to initialize project");
-    console.error(chalk.red(error));
+    spinner.fail("Failed to create structure");
+    console.error(chalk.red(`  ${error}`));
     process.exit(1);
   }
+  if (!options.skipInfra && hasDocker) {
+    console.log();
+    if (!dockerReady) {
+      console.log(chalk.dim("  Docker is installed but not running."));
+      console.log(chalk.dim("  Start Docker to enable infrastructure setup."));
+    } else {
+      const setupInfra = await confirm("Set up local infrastructure (postgres, redis)?", true);
+      if (setupInfra) {
+        console.log();
+        const success = await setupInfrastructure(cwd);
+        if (!success) {
+          console.log();
+          console.log(chalk.dim("  You can set up infrastructure later with:"));
+          console.log(chalk.dim("  cd docker && docker compose up -d"));
+        }
+      }
+    }
+  }
+  console.log();
+  console.log(chalk.green("  \u2713 Ready!"));
+  console.log();
+  console.log(`  ${chalk.cyan(".agents/")}
+  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("squads/demo/")}     Demo squad (try it!)
+  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("memory/")}         Persistent context
+  ${chalk.dim("\u2514\u2500\u2500")} ${chalk.cyan("outputs/")}        Agent outputs`);
+  console.log();
+  console.log(chalk.dim("  Next steps:"));
+  console.log(`  ${chalk.cyan("1.")} Try the demo: ${chalk.yellow("squads run demo")}`);
+  console.log(`  ${chalk.cyan("2.")} Check status: ${chalk.yellow("squads dash")}`);
+  console.log(`  ${chalk.cyan("3.")} Create your own squad in ${chalk.cyan(".agents/squads/")}`);
+  console.log();
+  console.log(chalk.dim("  Need help? jorge@agents-squads.com"));
+  console.log();
 }
 
 // src/commands/run.ts
 import ora2 from "ora";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { join as join4, dirname } from "path";
 import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 
@@ -1010,6 +1306,33 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
 }
 
 // src/commands/run.ts
+function ensureProjectTrusted(projectPath) {
+  const configPath = join4(process.env.HOME || "", ".claude.json");
+  if (!existsSync4(configPath)) {
+    return;
+  }
+  try {
+    const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
+    if (!config2.projects) {
+      config2.projects = {};
+    }
+    if (!config2.projects[projectPath]) {
+      config2.projects[projectPath] = {};
+    }
+    if (!config2.projects[projectPath].hasTrustDialogAccepted) {
+      config2.projects[projectPath].hasTrustDialogAccepted = true;
+      writeFileSync3(configPath, JSON.stringify(config2, 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;
@@ -1091,6 +1414,44 @@ async function runSquad(squad, squadsDir, options) {
   }
   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: join4(squadsDir, squad.name, `${a.name}.md`)
+    })).filter((a) => existsSync4(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 --execute`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${gradient("Launching")} ${agentFiles.length} agents in parallel...`);
+    writeLine();
+    const launches = agentFiles.map(
+      (agent) => runAgent(agent.name, agent.path, squad.name, 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}`);
@@ -1132,6 +1493,9 @@ async function runSquad(squad, squadsDir, options) {
         writeLine();
         writeLine(`  ${colors.dim}Run a specific agent:${RESET}`);
         writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --agent ${colors.cyan}<name>${RESET}`);
+        writeLine();
+        writeLine(`  ${colors.dim}Run all agents in parallel:${RESET}`);
+        writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --parallel --execute`);
       }
     }
   }
@@ -1140,15 +1504,123 @@ async function runSquad(squad, squadsDir, options) {
   writeLine(`  ${colors.dim}$${RESET} squads feedback add ${colors.cyan}${squad.name}${RESET} ${colors.cyan}<1-5>${RESET} ${colors.cyan}"<feedback>"${RESET}`);
   writeLine();
 }
-async function runAgent(agentName, agentPath, squadName, options) {
-  const spinner = ora2(`Running agent: ${agentName}`).start();
-  const startTime = (/* @__PURE__ */ new Date()).toISOString();
-  const definition = loadAgentDefinition(agentPath);
-  if (options.dryRun) {
-    spinner.info(`[DRY RUN] Would run ${agentName}`);
-    if (options.verbose) {
-      writeLine(`  ${colors.dim}Agent definition:${RESET}`);
-      writeLine(`  ${colors.dim}${definition.slice(0, 500)}...${RESET}`);
+async function runLeadMode(squad, squadsDir, options) {
+  if (!squad) return;
+  const agentFiles = squad.agents.map((a) => ({
+    name: a.name,
+    path: join4(squadsDir, squad.name, `${a.name}.md`),
+    role: a.role || ""
+  })).filter((a) => existsSync4(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 --execute`);
+    writeLine();
+    return;
+  }
+  const timeoutMins = options.timeout || 30;
+  const agentList = agentFiles.map((a) => `- ${a.name}: ${a.role}`).join("\n");
+  const agentPaths = agentFiles.map((a) => `- ${a.name}: ${a.path}`).join("\n");
+  const prompt2 = `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.name}/ 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.name}/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;
+  }
+  writeLine(`  ${gradient("Launching")} lead session${options.foreground ? " (foreground)" : ""}...`);
+  writeLine();
+  try {
+    const result = await executeWithClaude(prompt2, options.verbose, timeoutMins, options.foreground, options.useApi);
+    if (options.foreground) {
+      writeLine();
+      writeLine(`  ${icons.success} Lead session completed`);
+    } else {
+      writeLine(`  ${icons.success} Lead session launched`);
+      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 = ora2(`Running agent: ${agentName}`).start();
+  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  const definition = loadAgentDefinition(agentPath);
+  if (options.dryRun) {
+    spinner.info(`[DRY RUN] Would run ${agentName}`);
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Agent definition:${RESET}`);
+      writeLine(`  ${colors.dim}${definition.slice(0, 500)}...${RESET}`);
     }
     return;
   }
@@ -1158,6 +1630,7 @@ async function runAgent(agentName, agentPath, squadName, options) {
     startTime,
     status: "running"
   });
+  const timeoutMins = options.timeout || 30;
   const prompt2 = `Execute the ${agentName} agent from squad ${squadName}.
 
 Read the agent definition at ${agentPath} and follow its instructions exactly.
@@ -1168,20 +1641,35 @@ The agent definition contains:
 - Step-by-step instructions
 - Expected output format
 
+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 * 0.7)} minutes
+
 After completion:
 1. Update the agent's memory in .agents/memory/${squadName}/${agentName}/state.md
 2. Log any learnings to learnings.md
-3. Report what was accomplished`;
+3. Summarize what was accomplished
+
+CRITICAL: When you have completed your tasks OR reached the time limit:
+- Type /exit immediately to end this session
+- Do NOT wait for user input
+- Do NOT ask follow-up questions
+- Just /exit when done`;
   const claudeAvailable = await checkClaudeCliAvailable();
   if (options.execute && claudeAvailable) {
-    spinner.text = `Launching ${agentName} as background task...`;
+    spinner.text = options.foreground ? `Running ${agentName} in foreground...` : `Launching ${agentName} as background task...`;
     try {
-      const result = await executeWithClaude(prompt2, options.verbose, options.timeout || 30);
-      spinner.succeed(`Agent ${agentName} launched`);
-      writeLine(`  ${colors.dim}${result}${RESET}`);
-      writeLine();
-      writeLine(`  ${colors.dim}Monitor:${RESET} squads workers`);
-      writeLine(`  ${colors.dim}Memory:${RESET}  squads memory show ${squadName}`);
+      const result = await executeWithClaude(prompt2, options.verbose, options.timeout || 30, options.foreground, options.useApi);
+      if (options.foreground) {
+        spinner.succeed(`Agent ${agentName} completed`);
+      } else {
+        spinner.succeed(`Agent ${agentName} launched`);
+        writeLine(`  ${colors.dim}${result}${RESET}`);
+        writeLine();
+        writeLine(`  ${colors.dim}Monitor:${RESET} squads workers`);
+        writeLine(`  ${colors.dim}Memory:${RESET}  squads memory show ${squadName}`);
+      }
     } catch (error) {
       spinner.fail(`Agent ${agentName} failed to launch`);
       updateExecutionStatus(squadName, agentName, "failed", String(error));
@@ -1205,25 +1693,64 @@ After completion:
 }
 async function checkClaudeCliAvailable() {
   return new Promise((resolve) => {
-    const check = spawn("which", ["claude"], { stdio: "pipe" });
+    const check = spawn2("which", ["claude"], { stdio: "pipe" });
     check.on("close", (code) => resolve(code === 0));
     check.on("error", () => resolve(false));
   });
 }
-async function executeWithClaude(prompt2, verbose, timeoutMinutes = 30) {
+async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foreground, useApi) {
   const userConfigPath = join4(process.env.HOME || "", ".claude.json");
+  const projectRoot = getProjectRoot();
+  ensureProjectTrusted(projectRoot);
   const squadMatch = prompt2.match(/squad (\w+)/);
   const agentMatch = prompt2.match(/(\w+) agent/);
-  const squadName = squadMatch?.[1] || "unknown";
-  const agentName = agentMatch?.[1] || "unknown";
-  const timestamp = Date.now();
-  const sessionName = `squads-${squadName}-${agentName}-${timestamp}`;
+  const squadName = process.env.SQUADS_SQUAD || squadMatch?.[1] || "unknown";
+  const agentName = process.env.SQUADS_AGENT || agentMatch?.[1] || "unknown";
+  const { ANTHROPIC_API_KEY: _apiKey, ...envWithoutApiKey } = process.env;
+  const spawnEnv = useApi ? process.env : envWithoutApiKey;
+  const escapedPrompt = prompt2.replace(/'/g, "'\\''");
+  if (foreground) {
+    if (verbose) {
+      writeLine(`  ${colors.dim}Project: ${projectRoot}${RESET}`);
+      writeLine(`  ${colors.dim}Mode: foreground${RESET}`);
+      writeLine(`  ${colors.dim}Auth: ${useApi ? "API credits" : "subscription"}${RESET}`);
+    }
+    return new Promise((resolve, reject) => {
+      const claude = spawn2("claude", [
+        "--dangerously-skip-permissions",
+        "--mcp-config",
+        userConfigPath,
+        "--",
+        prompt2
+      ], {
+        stdio: "inherit",
+        cwd: projectRoot,
+        env: {
+          ...spawnEnv,
+          SQUADS_SQUAD: squadName,
+          SQUADS_AGENT: agentName
+        }
+      });
+      claude.on("close", (code) => {
+        if (code === 0) {
+          resolve("Session completed");
+        } else {
+          reject(new Error(`Claude exited with code ${code}`));
+        }
+      });
+      claude.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  const sessionName = process.env.SQUADS_TMUX_SESSION || `squads-${squadName}-${agentName}-${Date.now()}`;
   if (verbose) {
-    writeLine(`  ${colors.dim}Spawning tmux session: ${sessionName}${RESET}`);
+    writeLine(`  ${colors.dim}Project: ${projectRoot}${RESET}`);
+    writeLine(`  ${colors.dim}Session: ${sessionName}${RESET}`);
+    writeLine(`  ${colors.dim}Auth: ${useApi ? "API credits" : "subscription"}${RESET}`);
   }
-  const escapedPrompt = prompt2.replace(/'/g, "'\\''");
-  const claudeCmd = `claude --dangerously-skip-permissions --mcp-config '${userConfigPath}' -- '${escapedPrompt}'`;
-  const tmux = spawn("tmux", [
+  const claudeCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions --mcp-config '${userConfigPath}' -- '${escapedPrompt}'`;
+  const tmux = spawn2("tmux", [
     "new-session",
     "-d",
     // Detached
@@ -1241,16 +1768,12 @@ async function executeWithClaude(prompt2, verbose, timeoutMinutes = 30) {
     stdio: "ignore",
     detached: true,
     env: {
-      ...process.env,
+      ...spawnEnv,
       SQUADS_SQUAD: squadName,
       SQUADS_AGENT: agentName
     }
   });
   tmux.unref();
-  spawn("/bin/sh", ["-c", `sleep 2 && tmux send-keys -t '${sessionName}' Down Enter`], {
-    stdio: "ignore",
-    detached: true
-  }).unref();
   if (verbose) {
     writeLine(`  ${colors.dim}Attach: tmux attach -t ${sessionName}${RESET}`);
   }
@@ -1259,6 +1782,7 @@ async function executeWithClaude(prompt2, verbose, timeoutMinutes = 30) {
 
 // src/commands/list.ts
 async function listCommand(options) {
+  await track("cli.list", { squads: options.squads, agents: options.agents });
   const squadsDir = findSquadsDir();
   if (!squadsDir) {
     writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
@@ -1314,7 +1838,7 @@ import { join as join6 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, unlinkSync } from "fs";
 import { join as join5, dirname as dirname2 } from "path";
 import { homedir as homedir2 } from "os";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import { fileURLToPath } from "url";
 function getPackageVersion() {
   try {
@@ -1377,7 +1901,7 @@ function writeCache(latestVersion) {
 }
 function fetchLatestVersion() {
   try {
-    const result = execSync2("npm view squads-cli version 2>/dev/null", {
+    const result = execSync3("npm view squads-cli version 2>/dev/null", {
       encoding: "utf-8",
       timeout: 5e3
     }).trim();
@@ -1394,25 +1918,42 @@ function checkForUpdate() {
   };
   const cache = readCache();
   const now = Date.now();
-  if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
+  if (cache) {
     result.latestVersion = cache.latestVersion;
     result.updateAvailable = isNewerVersion(CURRENT_VERSION, cache.latestVersion);
+    if (now - cache.checkedAt >= CACHE_TTL_MS) {
+      triggerBackgroundRefresh();
+    }
     return result;
   }
-  const latestVersion = fetchLatestVersion();
-  if (latestVersion) {
-    writeCache(latestVersion);
-    result.latestVersion = latestVersion;
-    result.updateAvailable = isNewerVersion(CURRENT_VERSION, latestVersion);
-  } else if (cache) {
-    result.latestVersion = cache.latestVersion;
-    result.updateAvailable = isNewerVersion(CURRENT_VERSION, cache.latestVersion);
-  }
+  triggerBackgroundRefresh();
   return result;
 }
+function triggerBackgroundRefresh() {
+  try {
+    const { spawn: spawn8 } = __require("child_process");
+    const child = spawn8("npm", ["view", "squads-cli", "version"], {
+      detached: true,
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: true
+    });
+    let output = "";
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("close", () => {
+      const version2 = output.trim();
+      if (version2 && /^\d+\.\d+\.\d+/.test(version2)) {
+        writeCache(version2);
+      }
+    });
+    child.unref();
+  } catch {
+  }
+}
 function performUpdate() {
   try {
-    execSync2("npm update -g squads-cli", {
+    execSync3("npm update -g squads-cli", {
       encoding: "utf-8",
       stdio: "inherit",
       timeout: 12e4
@@ -1445,6 +1986,7 @@ function refreshVersionCache() {
 
 // src/commands/status.ts
 async function statusCommand(squadName, options = {}) {
+  await track(Events.CLI_STATUS, { squad: squadName || "all", verbose: options.verbose });
   const squadsDir = findSquadsDir();
   if (!squadsDir) {
     writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
@@ -1461,7 +2003,7 @@ async function showOverallStatus(squadsDir, _options) {
   const squads = listSquads(squadsDir);
   const memoryDir = findMemoryDir();
   cleanupStaleSessions();
-  const sessionSummary = getLiveSessionSummary();
+  const sessionSummary = await getLiveSessionSummaryAsync();
   writeLine();
   writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET}`);
   const updateInfo = checkForUpdate();
@@ -1601,8 +2143,8 @@ async function showSquadStatus(squadName, squadsDir, options) {
 import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, copyFileSync } from "fs";
 import { join as join7, dirname as dirname3 } from "path";
 import { homedir as homedir3 } from "os";
-import { execSync as execSync3, spawn as spawn2 } from "child_process";
-import { createInterface } from "readline";
+import { execSync as execSync4, spawn as spawn3 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname3(__filename2);
@@ -1728,7 +2270,7 @@ function showServiceSetupGuide(serviceName, issue) {
   writeLine();
 }
 async function prompt(question, defaultValue) {
-  const rl = createInterface({
+  const rl = createInterface2({
     input: process.stdin,
     output: process.stdout
   });
@@ -1740,7 +2282,7 @@ async function prompt(question, defaultValue) {
     });
   });
 }
-async function confirm(question, defaultYes = true) {
+async function confirm2(question, defaultYes = true) {
   const suffix = defaultYes ? "[Y/n]" : "[y/N]";
   const answer = await prompt(`${question} ${suffix}`);
   if (!answer) return defaultYes;
@@ -1821,7 +2363,7 @@ function applyStackConfig() {
 }
 function isDockerRunning() {
   try {
-    execSync3("docker info", { stdio: "ignore" });
+    execSync4("docker info", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -1829,7 +2371,7 @@ function isDockerRunning() {
 }
 function getContainerStatus(name) {
   try {
-    const runningOutput = execSync3(
+    const runningOutput = execSync4(
       `docker inspect ${name} --format '{{.State.Running}}'`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     ).trim();
@@ -1839,7 +2381,7 @@ function getContainerStatus(name) {
     }
     let port;
     try {
-      const portOutput = execSync3(
+      const portOutput = execSync4(
         `docker inspect ${name} --format '{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}'`,
         { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
       ).trim();
@@ -1848,7 +2390,7 @@ function getContainerStatus(name) {
     }
     let healthy = true;
     try {
-      const healthOutput = execSync3(
+      const healthOutput = execSync4(
         `docker inspect ${name} --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}'`,
         { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
       ).trim();
@@ -1959,7 +2501,7 @@ async function stackInitCommand() {
       }
       composeDir = targetDir;
       writeLine(`  ${colors.green}${icons.success}${RESET} Files copied`);
-    } catch (err) {
+    } catch {
       writeLine(`  ${colors.yellow}${icons.warning}${RESET} Could not copy files, using source location`);
     }
   } else if (existsSync7(targetDir)) {
@@ -2044,19 +2586,19 @@ BRIDGE_PORT=8088
   }
   writeLine();
   if (requiredNotRunning.length > 0) {
-    const shouldStart = await confirm("Start required services now?");
+    const shouldStart = await confirm2("Start required services now?");
     if (shouldStart) {
       writeLine();
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Starting containers...`);
       try {
-        execSync3("docker compose up -d", {
+        execSync4("docker compose up -d", {
           cwd: composeDir,
           stdio: "inherit"
         });
         writeLine(`  ${colors.cyan}${icons.progress}${RESET} Waiting for services to be ready...`);
         await new Promise((resolve) => setTimeout(resolve, 5e3));
         writeLine(`  ${colors.green}${icons.success}${RESET} Services started`);
-      } catch (err) {
+      } catch {
         writeLine(`  ${colors.red}${icons.error}${RESET} Failed to start services`);
         writeLine(`  ${colors.dim}Try manually: cd ${composeDir} && docker compose up -d${RESET}`);
       }
@@ -2182,7 +2724,7 @@ async function stackUpCommand() {
   writeLine(`  ${colors.cyan}${icons.progress}${RESET} Starting containers from ${colors.dim}${composeDir}${RESET}`);
   writeLine();
   try {
-    const child = spawn2("docker-compose", ["up", "-d"], {
+    const child = spawn3("docker-compose", ["up", "-d"], {
       cwd: composeDir,
       stdio: "inherit"
     });
@@ -2249,7 +2791,7 @@ async function stackHealthCommand(verbose = false) {
     let logs;
     if (!ok && verbose) {
       try {
-        logs = execSync3(`docker logs ${container.name} --tail 10 2>&1`, {
+        logs = execSync4(`docker logs ${container.name} --tail 10 2>&1`, {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
@@ -2300,7 +2842,7 @@ function stackLogsCommand(service, tail = 50) {
   };
   const container = containerMap[service] || `squads-${service}`;
   try {
-    execSync3(`docker logs ${container} --tail ${tail}`, { stdio: "inherit" });
+    execSync4(`docker logs ${container} --tail ${tail}`, { stdio: "inherit" });
   } catch {
     writeLine(`  ${colors.red}${icons.error}${RESET} Container ${container} not found`);
   }
@@ -2318,7 +2860,7 @@ async function stackDownCommand() {
   writeLine(`  ${colors.cyan}${icons.progress}${RESET} Stopping containers...`);
   writeLine();
   try {
-    const child = spawn2("docker-compose", ["down"], {
+    const child = spawn3("docker-compose", ["down"], {
       cwd: composeDir,
       stdio: "inherit"
     });
@@ -2343,6 +2885,7 @@ async function stackDownCommand() {
 var SQUADS_BRIDGE_URL = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 var MEM0_API_URL = process.env.MEM0_API_URL || "http://localhost:8000";
 async function memoryQueryCommand(query, options) {
+  await track(Events.CLI_MEMORY_QUERY, { squad: options.squad, agent: options.agent });
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
@@ -2403,6 +2946,7 @@ async function memoryQueryCommand(query, options) {
   writeLine();
 }
 async function memoryShowCommand(squadName, _options) {
+  await track(Events.CLI_MEMORY_SHOW, { squad: squadName });
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
@@ -2434,6 +2978,7 @@ async function memoryShowCommand(squadName, _options) {
   writeLine();
 }
 async function memoryUpdateCommand(squadName, content, options) {
+  await track(Events.CLI_MEMORY_UPDATE, { squad: squadName, agent: options.agent, type: options.type });
   const agentName = options.agent || `${squadName}-lead`;
   const type = options.type || "learnings";
   writeLine();
@@ -2447,6 +2992,7 @@ async function memoryUpdateCommand(squadName, content, options) {
   writeLine();
 }
 async function memoryListCommand() {
+  await track(Events.CLI_MEMORY_LIST);
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
@@ -2683,7 +3229,7 @@ async function memoryExtractCommand(options = {}) {
 }
 
 // src/commands/sync.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join8 } from "path";
 var PATH_TO_SQUAD = {
@@ -2727,7 +3273,7 @@ function getRecentCommits(since) {
   const commits = [];
   try {
     const sinceArg = since ? `--since="${since}"` : "-n 20";
-    const logOutput = execSync4(
+    const logOutput = execSync5(
       `git log ${sinceArg} --format="%H|%aI|%s" --name-only`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -2748,7 +3294,7 @@ function getRecentCommits(since) {
         });
       }
     }
-  } catch (error) {
+  } catch {
   }
   return commits;
 }
@@ -2825,8 +3371,8 @@ Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
 }
 function gitPullMemory() {
   try {
-    execSync4("git fetch origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-    const status = execSync4("git status -sb", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    execSync5("git fetch origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const status = execSync5("git status -sb", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const behindMatch = status.match(/behind (\d+)/);
     const aheadMatch = status.match(/ahead (\d+)/);
     const behind = behindMatch ? parseInt(behindMatch[1]) : 0;
@@ -2834,7 +3380,7 @@ function gitPullMemory() {
     if (behind === 0) {
       return { success: true, output: "Already up to date", behind: 0, ahead };
     }
-    const output = execSync4("git pull --rebase origin main", {
+    const output = execSync5("git pull --rebase origin main", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -2846,18 +3392,18 @@ function gitPullMemory() {
 }
 function gitPushMemory() {
   try {
-    const status = execSync4("git status --porcelain .agents/memory/", {
+    const status = execSync5("git status --porcelain .agents/memory/", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (status) {
-      execSync4("git add .agents/memory/", { stdio: ["pipe", "pipe", "pipe"] });
-      execSync4('git commit -m "chore: sync squad memory"', {
+      execSync5("git add .agents/memory/", { stdio: ["pipe", "pipe", "pipe"] });
+      execSync5('git commit -m "chore: sync squad memory"', {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     }
-    const output = execSync4("git push origin main", {
+    const output = execSync5("git push origin main", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -2868,8 +3414,9 @@ function gitPushMemory() {
   }
 }
 async function syncCommand(options = {}) {
+  await track(Events.CLI_MEMORY_SYNC, { push: options.push, pull: options.pull });
   const memoryDir = findMemoryDir();
-  const squadsDir = findSquadsDir();
+  const _squadsDir = findSquadsDir();
   if (!memoryDir) {
     writeLine(`  ${colors.yellow}No .agents/memory directory found${RESET}`);
     writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
@@ -2958,6 +3505,7 @@ async function syncCommand(options = {}) {
 
 // src/commands/goal.ts
 async function goalSetCommand(squadName, description, options) {
+  await track(Events.CLI_GOAL_SET, { squad: squadName });
   const squad = loadSquad(squadName);
   if (!squad) {
     writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
@@ -2981,6 +3529,7 @@ async function goalSetCommand(squadName, description, options) {
   writeLine();
 }
 async function goalListCommand(squadName, options = {}) {
+  await track(Events.CLI_GOAL_LIST, { squad: squadName || "all" });
   const squadsDir = findSquadsDir();
   if (!squadsDir) {
     writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
@@ -3037,15 +3586,21 @@ async function goalListCommand(squadName, options = {}) {
   writeLine();
 }
 async function goalCompleteCommand(squadName, goalIndex) {
+  await track(Events.CLI_GOAL_COMPLETE, { squad: squadName });
   const squad = loadSquad(squadName);
   if (!squad) {
     writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
     return;
   }
   const idx = parseInt(goalIndex) - 1;
-  if (idx < 0 || idx >= squad.goals.length) {
+  if (isNaN(idx) || idx < 0 || idx >= squad.goals.length) {
     writeLine(`  ${colors.red}Invalid goal index: ${goalIndex}${RESET}`);
-    writeLine(`  ${colors.dim}Squad has ${squad.goals.length} goal(s)${RESET}`);
+    if (squad.goals.length === 0) {
+      writeLine(`  ${colors.dim}Squad has no goals${RESET}`);
+    } else {
+      writeLine(`  ${colors.dim}Valid indexes: 1-${squad.goals.length}${RESET}`);
+      writeLine(`  ${colors.dim}Tip: Run 'squads goal list ${squadName}' to see goals with indexes${RESET}`);
+    }
     return;
   }
   const success = updateGoalInSquad(squadName, idx, { completed: true });
@@ -3058,14 +3613,21 @@ async function goalCompleteCommand(squadName, goalIndex) {
   writeLine();
 }
 async function goalProgressCommand(squadName, goalIndex, progress2) {
+  await track(Events.CLI_GOAL_PROGRESS, { squad: squadName });
   const squad = loadSquad(squadName);
   if (!squad) {
     writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
     return;
   }
   const idx = parseInt(goalIndex) - 1;
-  if (idx < 0 || idx >= squad.goals.length) {
+  if (isNaN(idx) || idx < 0 || idx >= squad.goals.length) {
     writeLine(`  ${colors.red}Invalid goal index: ${goalIndex}${RESET}`);
+    if (squad.goals.length === 0) {
+      writeLine(`  ${colors.dim}Squad has no goals${RESET}`);
+    } else {
+      writeLine(`  ${colors.dim}Valid indexes: 1-${squad.goals.length}${RESET}`);
+      writeLine(`  ${colors.dim}Tip: Run 'squads goal list ${squadName}' to see goals with indexes${RESET}`);
+    }
     return;
   }
   const success = updateGoalInSquad(squadName, idx, { progress: progress2 });
@@ -3081,7 +3643,7 @@ async function goalProgressCommand(squadName, goalIndex, progress2) {
 
 // src/commands/feedback.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
-import { join as join9, dirname as dirname5 } from "path";
+import { join as join9, dirname as dirname4 } from "path";
 function getFeedbackPath(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
@@ -3141,6 +3703,7 @@ function parseFeedbackHistory(content) {
   return entries;
 }
 async function feedbackAddCommand(squadName, rating, feedback2, options) {
+  await track(Events.CLI_FEEDBACK_ADD, { squad: squadName, rating: parseInt(rating) });
   const feedbackPath = getFeedbackPath(squadName);
   if (!feedbackPath) {
     writeLine(`  ${colors.red}Could not find memory directory${RESET}`);
@@ -3152,7 +3715,7 @@ async function feedbackAddCommand(squadName, rating, feedback2, options) {
     return;
   }
   const lastExec = getLastExecution(squadName);
-  const dir = dirname5(feedbackPath);
+  const dir = dirname4(feedbackPath);
   if (!existsSync9(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
@@ -3202,6 +3765,7 @@ _Date: ${date}_
   writeLine();
 }
 async function feedbackShowCommand(squadName, options) {
+  await track(Events.CLI_FEEDBACK_SHOW, { squad: squadName });
   const feedbackPath = getFeedbackPath(squadName);
   if (!feedbackPath || !existsSync9(feedbackPath)) {
     writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
@@ -3234,6 +3798,7 @@ async function feedbackShowCommand(squadName, options) {
   }
 }
 async function feedbackStatsCommand() {
+  await track(Events.CLI_FEEDBACK_STATS);
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     writeLine(`  ${colors.red}Could not find memory directory${RESET}`);
@@ -3281,19 +3846,323 @@ import { readdirSync as readdirSync4, existsSync as existsSync10, statSync as st
 import { join as join10 } from "path";
 import { homedir as homedir4 } from "os";
 
-// src/lib/costs.ts
-var MODEL_PRICING = {
-  "claude-opus-4-5-20251101": { input: 15, output: 75 },
-  "claude-sonnet-4-20250514": { input: 3, output: 15 },
-  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
-  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
-  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
-  default: { input: 3, output: 15 }
+// src/lib/providers.ts
+var PROVIDERS = {
+  anthropic: {
+    name: "anthropic",
+    displayName: "Anthropic",
+    envVars: ["ANTHROPIC_API_KEY"],
+    modelPatterns: [/^claude/i],
+    defaultPricing: { input: 3, output: 15 },
+    models: {
+      "claude-opus-4-5": { input: 15, output: 75 },
+      "claude-opus-4-5-20251101": { input: 15, output: 75 },
+      "claude-sonnet-4": { input: 3, output: 15 },
+      "claude-sonnet-4-20250514": { input: 3, output: 15 },
+      "claude-3-5-sonnet": { input: 3, output: 15 },
+      "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+      "claude-3-5-sonnet-20240620": { input: 3, output: 15 },
+      "claude-haiku-3-5": { input: 0.8, output: 4 },
+      "claude-3-5-haiku": { input: 0.8, output: 4 },
+      "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+      "claude-3-opus": { input: 15, output: 75 },
+      "claude-3-sonnet": { input: 3, output: 15 },
+      "claude-3-haiku": { input: 0.25, output: 1.25 }
+    }
+  },
+  openai: {
+    name: "openai",
+    displayName: "OpenAI",
+    envVars: ["OPENAI_API_KEY"],
+    modelPatterns: [/^gpt-/i, /^o1/i, /^o3/i],
+    defaultPricing: { input: 2.5, output: 10 },
+    models: {
+      "gpt-4o": { input: 2.5, output: 10 },
+      "gpt-4o-2024-11-20": { input: 2.5, output: 10 },
+      "gpt-4o-2024-08-06": { input: 2.5, output: 10 },
+      "gpt-4o-mini": { input: 0.15, output: 0.6 },
+      "gpt-4o-mini-2024-07-18": { input: 0.15, output: 0.6 },
+      "gpt-4-turbo": { input: 10, output: 30 },
+      "gpt-4-turbo-2024-04-09": { input: 10, output: 30 },
+      "gpt-4": { input: 30, output: 60 },
+      "gpt-4-32k": { input: 60, output: 120 },
+      "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+      "gpt-3.5-turbo-0125": { input: 0.5, output: 1.5 },
+      o1: { input: 15, output: 60 },
+      "o1-2024-12-17": { input: 15, output: 60 },
+      "o1-preview": { input: 15, output: 60 },
+      "o1-mini": { input: 3, output: 12 },
+      "o1-mini-2024-09-12": { input: 3, output: 12 },
+      "o3-mini": { input: 1.1, output: 4.4 }
+    }
+  },
+  google: {
+    name: "google",
+    displayName: "Google",
+    envVars: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    modelPatterns: [/^gemini/i],
+    defaultPricing: { input: 0.1, output: 0.4 },
+    models: {
+      "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+      "gemini-2.0-flash-exp": { input: 0.1, output: 0.4 },
+      "gemini-1.5-pro": { input: 1.25, output: 5 },
+      "gemini-1.5-pro-002": { input: 1.25, output: 5 },
+      "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+      "gemini-1.5-flash-002": { input: 0.075, output: 0.3 },
+      "gemini-1.0-pro": { input: 0.5, output: 1.5 }
+    }
+  },
+  mistral: {
+    name: "mistral",
+    displayName: "Mistral",
+    envVars: ["MISTRAL_API_KEY"],
+    modelPatterns: [/^mistral/i, /^mixtral/i, /^codestral/i],
+    defaultPricing: { input: 2, output: 6 },
+    models: {
+      "mistral-large": { input: 2, output: 6 },
+      "mistral-large-2411": { input: 2, output: 6 },
+      "mistral-medium": { input: 2.7, output: 8.1 },
+      "mistral-small": { input: 0.2, output: 0.6 },
+      "mistral-small-2409": { input: 0.2, output: 0.6 },
+      "mixtral-8x7b": { input: 0.7, output: 0.7 },
+      "mixtral-8x22b": { input: 2, output: 6 },
+      codestral: { input: 0.2, output: 0.6 },
+      "codestral-2405": { input: 0.2, output: 0.6 }
+    }
+  },
+  groq: {
+    name: "groq",
+    displayName: "Groq",
+    envVars: ["GROQ_API_KEY"],
+    modelPatterns: [/^llama/i],
+    // llama models on Groq
+    defaultPricing: { input: 0.59, output: 0.79 },
+    models: {
+      "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+      "llama-3.3-70b-specdec": { input: 0.59, output: 0.99 },
+      "llama-3.1-70b-versatile": { input: 0.59, output: 0.79 },
+      "llama-3.1-8b-instant": { input: 0.05, output: 0.08 },
+      "llama-3-70b-8192": { input: 0.59, output: 0.79 },
+      "llama-3-8b-8192": { input: 0.05, output: 0.08 },
+      "mixtral-8x7b-32768": { input: 0.24, output: 0.24 },
+      "gemma2-9b-it": { input: 0.2, output: 0.2 }
+    }
+  },
+  aws_bedrock: {
+    name: "aws_bedrock",
+    displayName: "AWS Bedrock",
+    envVars: ["AWS_ACCESS_KEY_ID"],
+    modelPatterns: [/^anthropic\./i, /^amazon\./i, /^meta\./i, /^mistral\./i],
+    defaultPricing: { input: 3, output: 15 },
+    models: {
+      "anthropic.claude-3-5-sonnet-20241022-v2:0": { input: 3, output: 15 },
+      "anthropic.claude-3-5-sonnet-20240620-v1:0": { input: 3, output: 15 },
+      "anthropic.claude-3-5-haiku-20241022-v1:0": { input: 0.8, output: 4 },
+      "anthropic.claude-3-opus-20240229-v1:0": { input: 15, output: 75 },
+      "anthropic.claude-3-sonnet-20240229-v1:0": { input: 3, output: 15 },
+      "anthropic.claude-3-haiku-20240307-v1:0": { input: 0.25, output: 1.25 },
+      "amazon.titan-text-premier-v1:0": { input: 0.5, output: 1.5 },
+      "amazon.titan-text-express-v1": { input: 0.2, output: 0.6 },
+      "amazon.titan-text-lite-v1": { input: 0.15, output: 0.2 },
+      "meta.llama3-70b-instruct-v1:0": { input: 2.65, output: 3.5 },
+      "meta.llama3-8b-instruct-v1:0": { input: 0.3, output: 0.6 },
+      "meta.llama3-1-405b-instruct-v1:0": { input: 5.32, output: 16 },
+      "mistral.mistral-large-2407-v1:0": { input: 4, output: 12 }
+    }
+  },
+  azure: {
+    name: "azure",
+    displayName: "Azure OpenAI",
+    envVars: ["AZURE_OPENAI_API_KEY"],
+    modelPatterns: [],
+    // Detected via endpoint, not model name
+    defaultPricing: { input: 2.5, output: 10 },
+    models: {
+      // Same pricing as OpenAI (regional variations possible)
+      "gpt-4o": { input: 2.5, output: 10 },
+      "gpt-4o-mini": { input: 0.15, output: 0.6 },
+      "gpt-4-turbo": { input: 10, output: 30 },
+      "gpt-4": { input: 30, output: 60 },
+      "gpt-35-turbo": { input: 0.5, output: 1.5 }
+      // Azure uses different name
+    }
+  }
 };
+function detectProviderFromModel(model) {
+  const modelLower = model.toLowerCase();
+  if (modelLower.includes("anthropic.") || modelLower.includes("amazon.") || modelLower.includes("meta.") || modelLower.includes("mistral.")) {
+    return "aws_bedrock";
+  }
+  if (modelLower.startsWith("claude")) {
+    return "anthropic";
+  }
+  if (modelLower.startsWith("gpt-") || modelLower.startsWith("o1") || modelLower.startsWith("o3")) {
+    if (process.env.AZURE_OPENAI_ENDPOINT || process.env.AZURE_OPENAI_API_KEY) {
+      return "azure";
+    }
+    return "openai";
+  }
+  if (modelLower.startsWith("gemini")) {
+    return "google";
+  }
+  if (modelLower.startsWith("mistral") || modelLower.startsWith("mixtral") || modelLower.startsWith("codestral")) {
+    if (process.env.GROQ_API_KEY && !process.env.MISTRAL_API_KEY) {
+      return "groq";
+    }
+    return "mistral";
+  }
+  if (modelLower.startsWith("llama") || modelLower.startsWith("gemma")) {
+    return "groq";
+  }
+  return "unknown";
+}
+function detectProvidersFromEnv() {
+  const detected = [];
+  if (process.env.ANTHROPIC_API_KEY) {
+    const tier = parseInt(process.env.ANTHROPIC_TIER || "0", 10);
+    const budgetSet = process.env.ANTHROPIC_BUDGET_DAILY || process.env.SQUADS_DAILY_BUDGET;
+    const explicitPlan = process.env.SQUADS_PLAN_TYPE?.toLowerCase();
+    let plan = "Max";
+    let confidence = "inferred";
+    let reason = "API key detected";
+    if (explicitPlan === "usage") {
+      plan = "Usage";
+      confidence = "explicit";
+      reason = "SQUADS_PLAN_TYPE=usage";
+    } else if (explicitPlan === "max") {
+      plan = "Max";
+      confidence = "explicit";
+      reason = "SQUADS_PLAN_TYPE=max";
+    } else if (budgetSet) {
+      plan = "Usage";
+      reason = `Budget set ($${budgetSet}/day)`;
+    } else if (tier >= 4) {
+      plan = "Max";
+      reason = `Tier ${tier} (high usage)`;
+    } else if (tier >= 1 && tier <= 2) {
+      plan = "Usage";
+      reason = `Tier ${tier} (new user)`;
+    }
+    detected.push({ provider: "anthropic", plan, confidence, reason });
+  }
+  if (process.env.OPENAI_API_KEY) {
+    const orgId = process.env.OPENAI_ORG_ID;
+    detected.push({
+      provider: "openai",
+      plan: orgId ? "Team/Enterprise" : "Personal",
+      confidence: "inferred",
+      reason: orgId ? "Org ID set" : "API key only"
+    });
+  }
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+    detected.push({
+      provider: "google",
+      plan: "Pay-as-you-go",
+      confidence: "inferred",
+      reason: "API key detected"
+    });
+  }
+  if (process.env.AWS_ACCESS_KEY_ID) {
+    detected.push({
+      provider: "aws_bedrock",
+      plan: "On-demand",
+      confidence: "inferred",
+      reason: "AWS credentials detected"
+    });
+  }
+  if (process.env.AZURE_OPENAI_API_KEY) {
+    detected.push({
+      provider: "azure",
+      plan: process.env.AZURE_OPENAI_DEPLOYMENT ? "PTU" : "Pay-as-you-go",
+      confidence: "inferred",
+      reason: process.env.AZURE_OPENAI_DEPLOYMENT ? "Deployment detected" : "API key only"
+    });
+  }
+  if (process.env.MISTRAL_API_KEY) {
+    detected.push({
+      provider: "mistral",
+      plan: "Pay-per-token",
+      confidence: "inferred",
+      reason: "API key detected"
+    });
+  }
+  if (process.env.GROQ_API_KEY) {
+    detected.push({
+      provider: "groq",
+      plan: "Developer",
+      confidence: "inferred",
+      reason: "API key detected"
+    });
+  }
+  return detected;
+}
+function getModelPricing(provider, model) {
+  if (provider === "unknown") {
+    return { input: 3, output: 15 };
+  }
+  const config2 = PROVIDERS[provider];
+  const modelLower = model.toLowerCase();
+  if (config2.models[model]) {
+    return config2.models[model];
+  }
+  const matchedModel = Object.keys(config2.models).find(
+    (m) => m.toLowerCase() === modelLower
+  );
+  if (matchedModel) {
+    return config2.models[matchedModel];
+  }
+  const partialMatch = Object.keys(config2.models).find(
+    (m) => modelLower.includes(m.toLowerCase()) || m.toLowerCase().includes(modelLower)
+  );
+  if (partialMatch) {
+    return config2.models[partialMatch];
+  }
+  return config2.defaultPricing;
+}
+function calcCost(provider, model, inputTokens, outputTokens, cachedTokens = 0) {
+  const pricing = getModelPricing(provider, model);
+  const inputCost = inputTokens / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  const cachedCost = pricing.cached ? cachedTokens / 1e6 * pricing.cached : 0;
+  return inputCost + outputCost + cachedCost;
+}
+function getProviderDisplayName(provider) {
+  if (provider === "unknown") return "Unknown";
+  return PROVIDERS[provider].displayName;
+}
+
+// src/lib/costs.ts
 var DEFAULT_DAILY_BUDGET = 200;
 var DEFAULT_DAILY_CALL_LIMIT = 1e3;
 var BRIDGE_URL = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 var FETCH_TIMEOUT_MS = 2e3;
+function detectPlan() {
+  const explicitPlan = process.env.SQUADS_PLAN_TYPE?.toLowerCase();
+  if (explicitPlan === "usage") {
+    return { plan: "usage", confidence: "explicit", reason: "SQUADS_PLAN_TYPE=usage" };
+  }
+  if (explicitPlan === "max") {
+    return { plan: "max", confidence: "explicit", reason: "SQUADS_PLAN_TYPE=max" };
+  }
+  const budgetSet = process.env.ANTHROPIC_BUDGET_DAILY || process.env.SQUADS_DAILY_BUDGET;
+  if (budgetSet) {
+    return { plan: "usage", confidence: "inferred", reason: `Budget set ($${budgetSet}/day)` };
+  }
+  const tier = parseInt(process.env.ANTHROPIC_TIER || "0", 10);
+  if (tier >= 4) {
+    return { plan: "max", confidence: "inferred", reason: `Tier ${tier} (high usage)` };
+  }
+  if (tier >= 1 && tier <= 2) {
+    return { plan: "usage", confidence: "inferred", reason: `Tier ${tier} (new user)` };
+  }
+  return { plan: "max", confidence: "inferred", reason: "Default (no config)" };
+}
+function getPlanType() {
+  return detectPlan().plan;
+}
+function isMaxPlan() {
+  return getPlanType() === "max";
+}
 async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
@@ -3306,9 +4175,9 @@ async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS)
     throw error;
   }
 }
-function calcCost(model, inputTokens, outputTokens) {
-  const pricing = MODEL_PRICING[model] || MODEL_PRICING.default;
-  return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+function calcCost2(model, inputTokens, outputTokens) {
+  const provider = detectProviderFromModel(model);
+  return calcCost(provider, model, inputTokens, outputTokens);
 }
 async function fetchFromBridge(period = "day") {
   try {
@@ -3336,6 +4205,20 @@ async function fetchFromBridge(period = "day") {
     const totalInputTokens = bySquad.reduce((sum, s) => sum + s.inputTokens, 0);
     const totalAllInput = totalInputTokens + totalCachedTokens;
     const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    const detectedProviders = detectProvidersFromEnv();
+    const byProvider = detectedProviders.map((p) => ({
+      provider: p.provider,
+      displayName: getProviderDisplayName(p.provider),
+      calls: 0,
+      // Bridge doesn't track by provider yet
+      inputTokens: 0,
+      outputTokens: 0,
+      cost: p.provider === "anthropic" ? totalCost : 0,
+      // Assume all cost is Anthropic for now
+      plan: p.plan,
+      confidence: p.confidence,
+      reason: p.reason
+    }));
     return {
       totalCost,
       dailyBudget,
@@ -3348,6 +4231,7 @@ async function fetchFromBridge(period = "day") {
       totalInputTokens,
       cacheHitRate,
       bySquad,
+      byProvider,
       source: "postgres"
     };
   } catch {
@@ -3384,7 +4268,7 @@ async function fetchFromLangfuse(limit = 100) {
       const usage = obs.usage || {};
       const inputTokens = usage.input || 0;
       const outputTokens = usage.output || 0;
-      const cost = calcCost(model, inputTokens, outputTokens);
+      const cost = calcCost2(model, inputTokens, outputTokens);
       if (!bySquad[squad]) {
         bySquad[squad] = {
           squad,
@@ -3411,6 +4295,35 @@ async function fetchFromLangfuse(limit = 100) {
     const totalInputTokens = squadList.reduce((sum, s) => sum + s.inputTokens, 0);
     const totalAllInput = totalInputTokens + totalCachedTokens;
     const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    const providerMap = {};
+    for (const obs of observations) {
+      if (obs.type !== "GENERATION") continue;
+      const model = obs.model || "unknown";
+      const provider = detectProviderFromModel(model);
+      const usage = obs.usage || {};
+      const inputTokens = usage.input || 0;
+      const outputTokens = usage.output || 0;
+      const cost = calcCost2(model, inputTokens, outputTokens);
+      if (!providerMap[provider]) {
+        const detection = detectProvidersFromEnv().find((p) => p.provider === provider);
+        providerMap[provider] = {
+          provider,
+          displayName: getProviderDisplayName(provider),
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cost: 0,
+          plan: detection?.plan,
+          confidence: detection?.confidence,
+          reason: detection?.reason
+        };
+      }
+      providerMap[provider].calls += 1;
+      providerMap[provider].inputTokens += inputTokens;
+      providerMap[provider].outputTokens += outputTokens;
+      providerMap[provider].cost += cost;
+    }
+    const byProvider = Object.values(providerMap).sort((a, b) => b.cost - a.cost);
     return {
       totalCost,
       dailyBudget,
@@ -3423,6 +4336,7 @@ async function fetchFromLangfuse(limit = 100) {
       totalInputTokens,
       cacheHitRate,
       bySquad: squadList,
+      byProvider,
       source: "langfuse"
     };
   } catch {
@@ -3439,6 +4353,18 @@ async function fetchCostSummary(limit = 100, period = "day") {
     return langfuseResult;
   }
   const defaultBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+  const detectedProviders = detectProvidersFromEnv();
+  const byProvider = detectedProviders.map((p) => ({
+    provider: p.provider,
+    displayName: getProviderDisplayName(p.provider),
+    calls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cost: 0,
+    plan: p.plan,
+    confidence: p.confidence,
+    reason: p.reason
+  }));
   return {
     totalCost: 0,
     dailyBudget: defaultBudget,
@@ -3451,28 +4377,19 @@ async function fetchCostSummary(limit = 100, period = "day") {
     totalInputTokens: 0,
     cacheHitRate: 0,
     bySquad: [],
+    byProvider,
     source: "none"
   };
 }
-function formatCostBar(usedPercent, width = 20) {
-  const filled = Math.min(Math.round(usedPercent / 100 * width), width);
-  const empty = width - filled;
-  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
-}
 async function fetchBridgeStats() {
   try {
-    const statsResponse = await fetchWithTimeout(`${BRIDGE_URL}/stats`, {
-      headers: { "Content-Type": "application/json" }
-    });
-    if (!statsResponse.ok) {
-      return null;
-    }
-    const stats = await statsResponse.json();
-    const healthResponse = await fetchWithTimeout(`${BRIDGE_URL}/health`, {
-      headers: { "Content-Type": "application/json" }
-    });
-    const health = healthResponse.ok ? await healthResponse.json() : {};
-    const [costResponse, weekResponse] = await Promise.all([
+    const [statsResponse, healthResponse, costResponse, weekResponse] = await Promise.all([
+      fetchWithTimeout(`${BRIDGE_URL}/stats`, {
+        headers: { "Content-Type": "application/json" }
+      }),
+      fetchWithTimeout(`${BRIDGE_URL}/health`, {
+        headers: { "Content-Type": "application/json" }
+      }),
       fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=day`, {
         headers: { "Content-Type": "application/json" }
       }),
@@ -3480,8 +4397,15 @@ async function fetchBridgeStats() {
         headers: { "Content-Type": "application/json" }
       })
     ]);
-    const costData = costResponse.ok ? await costResponse.json() : {};
-    const weekData = weekResponse.ok ? await weekResponse.json() : {};
+    if (!statsResponse.ok) {
+      return null;
+    }
+    const [stats, health, costData, weekData] = await Promise.all([
+      statsResponse.json(),
+      healthResponse.ok ? healthResponse.json() : Promise.resolve({}),
+      costResponse.ok ? costResponse.json() : Promise.resolve({}),
+      weekResponse.ok ? weekResponse.json() : Promise.resolve({})
+    ]);
     return {
       status: stats.status || "unknown",
       source: stats.source || "none",
@@ -3528,6 +4452,38 @@ async function fetchBridgeStats() {
     return null;
   }
 }
+async function fetchRateLimits() {
+  try {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/rate-limits`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return { limits: {}, source: "none" };
+    }
+    const data = await response.json();
+    const rateLimits = data.rate_limits || {};
+    const limits = {};
+    for (const [key, value] of Object.entries(rateLimits)) {
+      limits[key] = {
+        model: value.model || key,
+        requestsLimit: value.requests_limit || 0,
+        requestsRemaining: value.requests_remaining || 0,
+        requestsReset: value.requests_reset,
+        tokensLimit: value.tokens_limit || 0,
+        tokensRemaining: value.tokens_remaining || 0,
+        tokensReset: value.tokens_reset,
+        inputTokensLimit: value.input_tokens_limit,
+        inputTokensRemaining: value.input_tokens_remaining,
+        outputTokensLimit: value.output_tokens_limit,
+        outputTokensRemaining: value.output_tokens_remaining,
+        capturedAt: value.captured_at || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return { limits, source: "proxy" };
+  } catch {
+    return { limits: {}, source: "none" };
+  }
+}
 async function fetchInsights(period = "week") {
   try {
     const response = await fetchWithTimeout(`${BRIDGE_URL}/api/insights?period=${period}`, {
@@ -3591,6 +4547,34 @@ async function fetchInsights(period = "week") {
     };
   }
 }
+async function fetchNpmStats(packageName = "squads-cli") {
+  try {
+    const [dayRes, weekRes, monthRes] = await Promise.all([
+      fetch(`https://api.npmjs.org/downloads/point/last-day/${packageName}`),
+      fetch(`https://api.npmjs.org/downloads/point/last-week/${packageName}`),
+      fetch(`https://api.npmjs.org/downloads/point/last-month/${packageName}`)
+    ]);
+    if (!dayRes.ok || !weekRes.ok || !monthRes.ok) return null;
+    const [dayData, weekData, monthData] = await Promise.all([
+      dayRes.json(),
+      weekRes.json(),
+      monthRes.json()
+    ]);
+    const avgWeeklyFromMonth = monthData.downloads / 4;
+    const weekOverWeek = avgWeeklyFromMonth > 0 ? Math.round((weekData.downloads - avgWeeklyFromMonth) / avgWeeklyFromMonth * 100) : 0;
+    return {
+      package: packageName,
+      downloads: {
+        lastDay: dayData.downloads,
+        lastWeek: weekData.downloads,
+        lastMonth: monthData.downloads
+      },
+      weekOverWeek
+    };
+  } catch {
+    return null;
+  }
+}
 
 // src/lib/db.ts
 import { createRequire } from "module";
@@ -3747,6 +4731,7 @@ function getLastActivityDate(squadName) {
   return `${Math.floor(ageDays / 7)}w`;
 }
 async function dashboardCommand(options = {}) {
+  await track(Events.CLI_DASHBOARD, { verbose: options.verbose, ceo: options.ceo, fast: options.fast });
   const squadsDir = findSquadsDir();
   if (!squadsDir) {
     writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
@@ -3760,7 +4745,8 @@ async function dashboardCommand(options = {}) {
   const squadNames = listSquads(squadsDir);
   const skipGitHub = options.fast !== false;
   const timeout = (promise, ms, fallback) => Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(fallback), ms))]);
-  const [gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights] = await Promise.all([
+  cleanupStaleSessions();
+  const [gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights, sessionSummary, npmStats] = await Promise.all([
     // Git stats (local, ~1s)
     Promise.resolve(baseDir ? getMultiRepoGitStats(baseDir, 30) : null),
     // GitHub stats (network, ~20-30s) - skip by default for fast mode
@@ -3776,9 +4762,13 @@ async function dashboardCommand(options = {}) {
     // Dashboard history (1.5s timeout)
     timeout(getDashboardHistory(14).catch(() => []), 1500, []),
     // Insights (2s timeout)
-    timeout(fetchInsights("week").catch(() => null), 2e3, null)
+    timeout(fetchInsights("week").catch(() => null), 2e3, null),
+    // Session summary (parallel lsof, ~1s)
+    getLiveSessionSummaryAsync(),
+    // NPM download stats (network, 2s timeout)
+    timeout(fetchNpmStats("squads-cli"), 2e3, null)
   ]);
-  const cache = { gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights };
+  const cache = { gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights, sessionSummary, npmStats };
   const squadData = [];
   for (const name of squadNames) {
     const squad = loadSquad(name);
@@ -3840,8 +4830,6 @@ async function dashboardCommand(options = {}) {
   const totalPRs = ghStats ? ghStats.prsMerged : 0;
   const totalIssuesClosed = ghStats ? ghStats.issuesClosed : 0;
   const totalIssuesOpen = ghStats ? ghStats.issuesOpen : 0;
-  cleanupStaleSessions();
-  const sessionSummary = getLiveSessionSummary();
   writeLine();
   writeLine(`  ${gradient("squads")} ${colors.dim}dashboard${RESET}`);
   const updateInfo = checkForUpdate();
@@ -3873,8 +4861,8 @@ async function dashboardCommand(options = {}) {
   const overallProgress = squadData.length > 0 ? Math.round(squadData.reduce((sum, s) => sum + s.goalProgress, 0) / squadData.length) : 0;
   writeLine(`  ${progressBar(overallProgress, 32)} ${colors.dim}${overallProgress}% goal progress${RESET}`);
   writeLine();
-  const w = { name: 13, commits: 7, prs: 4, issues: 6, goals: 6, bar: 10 };
-  const tableWidth = w.name + w.commits + w.prs + w.issues + w.goals + w.bar + 12;
+  const w = { name: 13, commits: 9, prs: 5, issues: 8, goals: 7, bar: 10 };
+  const tableWidth = w.name + w.commits + w.prs + w.issues + w.goals + w.bar + 6;
   writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
   writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("COMMITS", w.commits)}${RESET}${bold}${padEnd("PRs", w.prs)}${RESET}${bold}${padEnd("ISSUES", w.issues)}${RESET}${bold}${padEnd("GOALS", w.goals)}${RESET}${bold}PROGRESS${RESET} ${colors.purple}${box.vertical}${RESET}`);
   writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
@@ -3898,9 +4886,14 @@ async function dashboardCommand(options = {}) {
   }
   writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
   writeLine();
+  const goalCount = {
+    active: squadData.reduce((sum, s) => sum + s.goals.filter((g) => !g.completed).length, 0),
+    completed: squadData.reduce((sum, s) => sum + s.goals.filter((g) => g.completed).length, 0)
+  };
   renderGitPerformanceCached(cache);
-  renderTokenEconomicsCached(cache);
+  renderTokenEconomicsCached(cache, goalCount);
   renderInfrastructureCached(cache);
+  renderAcquisitionCached(cache);
   renderHistoricalTrendsCached(cache);
   renderInsightsCached(cache);
   const allActiveGoals = squadData.flatMap(
@@ -3987,37 +4980,62 @@ function renderGitPerformanceCached(cache) {
     writeLine();
   }
 }
-function renderTokenEconomicsCached(cache) {
+function renderTokenEconomicsCached(cache, goalCount) {
   const costs = cache.costs;
-  if (!costs) {
+  const stats = cache.bridgeStats;
+  if (!costs && !stats) {
     writeLine(`  ${bold}Token Economics${RESET} ${colors.dim}(no data)${RESET}`);
-    writeLine(`  ${colors.dim}Set LANGFUSE_PUBLIC_KEY & LANGFUSE_SECRET_KEY for cost tracking${RESET}`);
+    writeLine(`  ${colors.dim}Set LANGFUSE_PUBLIC_KEY & LANGFUSE_SECRET_KEY for tracking${RESET}`);
     writeLine();
     return;
   }
-  writeLine(`  ${bold}Token Economics${RESET} ${colors.dim}(last 100 calls)${RESET}`);
-  writeLine();
-  const barWidth = 32;
-  const costBar = formatCostBar(costs.usedPercent, barWidth);
-  writeLine(`  ${colors.dim}Budget $${costs.dailyBudget}${RESET} [${costBar}] ${costs.usedPercent.toFixed(1)}%`);
-  writeLine(`  ${colors.green}$${costs.totalCost.toFixed(2)}${RESET} used  ${colors.dim}\u2502${RESET}  ${colors.cyan}$${costs.idleBudget.toFixed(2)}${RESET} idle`);
+  writeLine(`  ${bold}Token Economics${RESET}`);
   writeLine();
+  const maxPlan = isMaxPlan();
   const tier = parseInt(process.env.ANTHROPIC_TIER || "4", 10);
-  writeLine(`  ${colors.dim}Rate Limits (Tier ${tier})${RESET}`);
-  writeLine();
-  const now = /* @__PURE__ */ new Date();
-  const hoursElapsed = Math.max(now.getHours() + now.getMinutes() / 60, 1);
-  const hourlyRate = costs.totalCost / hoursElapsed;
-  const dailyProjection = hourlyRate * 24;
-  const monthlyProjection = dailyProjection * 30;
-  writeLine(`  ${colors.dim}Projections${RESET}`);
-  const projColor = dailyProjection > costs.dailyBudget ? colors.red : colors.green;
-  writeLine(`  ${colors.dim}Daily:${RESET}  ${projColor}~$${dailyProjection.toFixed(2)}${RESET}${colors.dim}/${costs.dailyBudget}${RESET}  ${colors.dim}Monthly:${RESET} ${colors.cyan}~$${monthlyProjection.toFixed(0)}${RESET}`);
-  if (dailyProjection > costs.dailyBudget * 0.8) {
-    writeLine(`  ${colors.yellow}\u26A0${RESET} ${colors.yellow}Projected to exceed daily budget${RESET}`);
+  const planIcon = maxPlan ? `${colors.purple}\u25C6${RESET}` : `${colors.dim}\u25CB${RESET}`;
+  writeLine(`  ${planIcon} ${bold}Claude Max${RESET} ${colors.dim}$200/mo flat${RESET}  ${colors.dim}Tier ${tier}${RESET}`);
+  writeLine();
+  const todayTokens = stats ? stats.today.inputTokens + stats.today.outputTokens : 0;
+  const todayCalls = stats?.today.generations || costs?.totalCalls || 0;
+  const todayCost = stats?.today.costUsd || costs?.totalCost || 0;
+  writeLine(`  ${colors.dim}Today${RESET}`);
+  writeLine(`  ${colors.cyan}${formatK(todayTokens)}${RESET} tokens  ${colors.dim}\u2502${RESET}  ${colors.cyan}${todayCalls}${RESET} calls  ${colors.dim}\u2502${RESET}  ${colors.green}$${todayCost.toFixed(2)}${RESET}`);
+  if (stats?.week && stats.week.generations > 0) {
+    const weekTokens = (stats.week.inputTokens || 0) + (stats.week.outputTokens || 0);
+    writeLine(`  ${colors.dim}Week${RESET}   ${colors.purple}${formatK(weekTokens)}${RESET} tokens  ${colors.dim}\u2502${RESET}  ${colors.purple}${stats.week.generations}${RESET} calls  ${colors.dim}\u2502${RESET}  ${colors.purple}$${stats.week.costUsd.toFixed(2)}${RESET}`);
+  }
+  writeLine();
+  if (goalCount && goalCount.completed > 0 && todayTokens > 0) {
+    const tokensPerGoal = Math.round(todayTokens / goalCount.completed);
+    writeLine(`  ${colors.dim}Efficiency${RESET}`);
+    writeLine(`  ${colors.cyan}${formatK(tokensPerGoal)}${RESET} tokens/goal  ${colors.dim}\u2502${RESET}  ${colors.green}${goalCount.completed}${RESET} goals done`);
+    writeLine();
   }
-  if (costs.usedPercent > 80) {
-    writeLine(`  ${colors.red}\u26A0${RESET} ${colors.red}${costs.usedPercent.toFixed(0)}% of daily budget used${RESET}`);
+  writeLine(`  ${colors.dim}Rate Limits${RESET} ${colors.dim}(Tier ${tier})${RESET}`);
+  const tier4Limits = {
+    rpm: 4e3,
+    inputTpm: 4e5,
+    outputTpm: 8e4
+  };
+  const now = /* @__PURE__ */ new Date();
+  const minutesElapsed = Math.max(now.getHours() * 60 + now.getMinutes(), 1);
+  const callsPerMinute = todayCalls / minutesElapsed;
+  const tokensPerMinute = todayTokens / minutesElapsed;
+  const rpmPct = callsPerMinute / tier4Limits.rpm * 100;
+  const tpmPct = tokensPerMinute / (tier4Limits.inputTpm + tier4Limits.outputTpm) * 100;
+  const rpmBar = progressBar(Math.min(rpmPct, 100), 10);
+  const tpmBar = progressBar(Math.min(tpmPct, 100), 10);
+  const rpmColor = rpmPct > 75 ? colors.red : rpmPct > 50 ? colors.yellow : colors.green;
+  const tpmColor = tpmPct > 75 ? colors.red : tpmPct > 50 ? colors.yellow : colors.green;
+  writeLine(`  RPM  ${rpmBar} ${rpmColor}${callsPerMinute.toFixed(1)}${RESET}${colors.dim}/${tier4Limits.rpm}${RESET}`);
+  writeLine(`  TPM  ${tpmBar} ${tpmColor}${formatK(Math.round(tokensPerMinute))}${RESET}${colors.dim}/${formatK(tier4Limits.inputTpm + tier4Limits.outputTpm)}${RESET}`);
+  const rpmAvailable = Math.max(0, tier4Limits.rpm - callsPerMinute);
+  const tpmAvailable = Math.max(0, tier4Limits.inputTpm + tier4Limits.outputTpm - tokensPerMinute);
+  if (rpmAvailable > 100 && tpmAvailable > 1e4) {
+    writeLine(`  ${colors.green}\u25CF${RESET} ${colors.dim}Capacity for autonomous triggers${RESET}`);
+  } else if (rpmPct > 75 || tpmPct > 75) {
+    writeLine(`  ${colors.yellow}\u26A0${RESET} ${colors.yellow}Rate limits constrained${RESET}`);
   }
   writeLine();
 }
@@ -4025,7 +5043,10 @@ function renderInfrastructureCached(cache) {
   const stats = cache.bridgeStats;
   if (!stats) {
     writeLine(`  ${bold}Infrastructure${RESET} ${colors.dim}(bridge offline)${RESET}`);
-    writeLine(`  ${colors.dim}Start with: cd docker && docker-compose up -d${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Start with:${RESET} cd docker && docker-compose up -d`);
+    writeLine(`  ${colors.dim}Docs:${RESET} https://agents-squads.com/docs/setup`);
+    writeLine(`  ${colors.yellow}Need help?${RESET} ${colors.dim}jorge@agents-squads.com${RESET}`);
     writeLine();
     return;
   }
@@ -4038,8 +5059,10 @@ function renderInfrastructureCached(cache) {
   writeLine(`  ${pgStatus} postgres  ${redisStatus} redis  ${otelStatus} otel`);
   writeLine();
   if (stats.today.generations > 0 || stats.today.costUsd > 0) {
-    const costColor = stats.budget.usedPct > 80 ? colors.red : stats.budget.usedPct > 50 ? colors.yellow : colors.green;
-    writeLine(`  ${colors.dim}Today:${RESET} ${colors.cyan}${stats.today.generations}${RESET}${colors.dim} calls${RESET}  ${costColor}$${stats.today.costUsd.toFixed(2)}${RESET}${colors.dim}/$${stats.budget.daily}${RESET}  ${colors.dim}${formatK(stats.today.inputTokens)}+${formatK(stats.today.outputTokens)} tokens${RESET}`);
+    const maxPlan = isMaxPlan();
+    const costColor = maxPlan ? colors.green : stats.budget.usedPct > 80 ? colors.red : stats.budget.usedPct > 50 ? colors.yellow : colors.green;
+    const costDisplay = maxPlan ? `${costColor}$${stats.today.costUsd.toFixed(2)}${RESET}` : `${costColor}$${stats.today.costUsd.toFixed(2)}${RESET}${colors.dim}/$${stats.budget.daily}${RESET}`;
+    writeLine(`  ${colors.dim}Today:${RESET} ${colors.cyan}${stats.today.generations}${RESET}${colors.dim} calls${RESET}  ${costDisplay}  ${colors.dim}${formatK(stats.today.inputTokens)}+${formatK(stats.today.outputTokens)} tokens${RESET}`);
     if (stats.byModel && stats.byModel.length > 0) {
       const modelLine = stats.byModel.map((m) => {
         const shortName = m.model.includes("opus") ? "opus" : m.model.includes("sonnet") ? "sonnet" : m.model.includes("haiku") ? "haiku" : m.model.slice(0, 10);
@@ -4057,7 +5080,22 @@ function renderInfrastructureCached(cache) {
   }
   writeLine();
 }
-async function saveSnapshotCached(squadData, cache, baseDir) {
+function renderAcquisitionCached(cache) {
+  const npm = cache.npmStats;
+  if (!npm) {
+    return;
+  }
+  writeLine(`  ${bold}Acquisition${RESET} ${colors.dim}(npm)${RESET}`);
+  writeLine();
+  const trendIcon = npm.weekOverWeek >= 0 ? `${colors.green}\u2191${RESET}` : `${colors.red}\u2193${RESET}`;
+  const trendColor = npm.weekOverWeek >= 0 ? colors.green : colors.red;
+  writeLine(`  ${colors.cyan}${npm.downloads.lastWeek}${RESET} installs/week  ${trendIcon} ${trendColor}${Math.abs(npm.weekOverWeek)}%${RESET} ${colors.dim}wow${RESET}`);
+  writeLine(`  ${colors.dim}Today${RESET} ${npm.downloads.lastDay}  ${colors.dim}\u2502${RESET}  ${colors.dim}Month${RESET} ${npm.downloads.lastMonth}`);
+  writeLine();
+  writeLine(`  ${colors.dim}GitHub \u2192 npm install \u2192 squads dash \u2192 ?${RESET}`);
+  writeLine();
+}
+async function saveSnapshotCached(squadData, cache, _baseDir) {
   if (!cache.dbAvailable) return;
   const { gitStats, ghStats, costs } = cache;
   const squadsData = squadData.map((s) => ({
@@ -4261,7 +5299,10 @@ function renderInsightsCached(cache) {
 }
 
 // src/commands/issues.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
+function getLabelName(label) {
+  return typeof label === "string" ? label : label.name;
+}
 var DEFAULT_ORG = "agents-squads";
 var DEFAULT_REPOS = ["hq", "agents-squads-web", "squads-cli"];
 async function issuesCommand(options = {}) {
@@ -4271,7 +5312,7 @@ async function issuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}issues${RESET}`);
   writeLine();
   try {
-    execSync5("gh --version", { stdio: "pipe" });
+    execSync6("gh --version", { stdio: "pipe" });
   } catch {
     writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
     writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
@@ -4282,14 +5323,14 @@ async function issuesCommand(options = {}) {
   let totalOpen = 0;
   for (const repo of repos) {
     try {
-      const result = execSync5(
+      const result = execSync6(
         `gh issue list -R ${org}/${repo} --state open --json number,title,state,labels,createdAt --limit 50`,
         { stdio: "pipe", encoding: "utf-8" }
       );
       const issues = JSON.parse(result);
       repoData.push({ repo, issues });
       totalOpen += issues.length;
-    } catch (e) {
+    } catch {
       repoData.push({ repo, issues: [], error: "not found or no access" });
     }
   }
@@ -4321,7 +5362,7 @@ async function issuesCommand(options = {}) {
     writeLine(`  ${bold}Recent${RESET}`);
     writeLine();
     for (const issue of allIssues) {
-      const labelStr = issue.labels.length > 0 ? `${colors.dim}[${issue.labels.map((l) => l.name || l).join(", ")}]${RESET}` : "";
+      const labelStr = issue.labels.length > 0 ? `${colors.dim}[${issue.labels.map(getLabelName).join(", ")}]${RESET}` : "";
       writeLine(`  ${icons.empty} ${colors.dim}#${issue.number}${RESET} ${truncate(issue.title, 50)} ${labelStr}`);
       writeLine(`    ${colors.dim}\u2514 ${issue.repo}${RESET}`);
     }
@@ -4333,7 +5374,7 @@ async function issuesCommand(options = {}) {
 }
 
 // src/commands/solve-issues.ts
-import { execSync as execSync6, spawn as spawn3 } from "child_process";
+import { execSync as execSync7, spawn as spawn4 } from "child_process";
 import ora3 from "ora";
 var DEFAULT_ORG2 = "agents-squads";
 var DEFAULT_REPOS2 = ["hq", "agents-squads-web", "squads-cli", "agents-squads"];
@@ -4343,7 +5384,7 @@ async function solveIssuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}solve-issues${RESET}`);
   writeLine();
   try {
-    execSync6("gh --version", { stdio: "pipe" });
+    execSync7("gh --version", { stdio: "pipe" });
   } catch {
     writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
     writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
@@ -4353,7 +5394,7 @@ async function solveIssuesCommand(options = {}) {
   if (options.issue) {
     const repo = options.repo || "hq";
     try {
-      const result = execSync6(
+      const result = execSync7(
         `gh issue view ${options.issue} -R ${DEFAULT_ORG2}/${repo} --json number,title,labels,body`,
         { stdio: "pipe", encoding: "utf-8" }
       );
@@ -4366,7 +5407,7 @@ async function solveIssuesCommand(options = {}) {
   } else {
     for (const repo of repos) {
       try {
-        const result = execSync6(
+        const result = execSync7(
           `gh issue list -R ${DEFAULT_ORG2}/${repo} --label "ready-to-fix" --state open --json number,title,labels --limit 20`,
           { stdio: "pipe", encoding: "utf-8" }
         );
@@ -4420,7 +5461,7 @@ function showSolveInstructions(issues) {
 async function solveWithClaude(issues) {
   const spinner = ora3("Starting issue solver...").start();
   try {
-    execSync6("which claude", { stdio: "pipe" });
+    execSync7("which claude", { stdio: "pipe" });
   } catch {
     spinner.fail("Claude CLI not found");
     writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
@@ -4479,7 +5520,7 @@ Return the PR URL when done.`;
 }
 function executeClaudePrompt(prompt2) {
   return new Promise((resolve, reject) => {
-    const claude = spawn3("claude", ["--print", prompt2], {
+    const claude = spawn4("claude", ["--print", prompt2], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let output = "";
@@ -4506,7 +5547,7 @@ function executeClaudePrompt(prompt2) {
 }
 
 // src/commands/open-issues.ts
-import { execSync as execSync7, spawn as spawn4 } from "child_process";
+import { execSync as execSync8, spawn as spawn5 } from "child_process";
 import { readdirSync as readdirSync5 } from "fs";
 import { join as join11 } from "path";
 import ora4 from "ora";
@@ -4602,7 +5643,7 @@ function showRunInstructions(agents) {
 async function runEvaluators(agents) {
   const spinner = ora4("Starting evaluators...").start();
   try {
-    execSync7("which claude", { stdio: "pipe" });
+    execSync8("which claude", { stdio: "pipe" });
   } catch {
     spinner.fail("Claude CLI not found");
     writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
@@ -4653,7 +5694,7 @@ Do NOT get stuck re-reading files. Evaluate, report findings, create issues, don
 }
 function executeClaudePrompt2(prompt2) {
   return new Promise((resolve, reject) => {
-    const claude = spawn4("claude", ["--print", prompt2], {
+    const claude = spawn5("claude", ["--print", prompt2], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let output = "";
@@ -4686,9 +5727,10 @@ import open from "open";
 
 // src/lib/auth.ts
 import { createClient } from "@supabase/supabase-js";
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
 import { join as join12 } from "path";
 import { homedir as homedir5 } from "os";
+import "open";
 import http from "http";
 var PERSONAL_DOMAINS = [
   "gmail.com",
@@ -4726,21 +5768,21 @@ function getEmailDomain(email) {
   return email.split("@")[1]?.toLowerCase() || "";
 }
 function saveSession(session2) {
-  if (!existsSync12(AUTH_DIR)) {
+  if (!existsSync11(AUTH_DIR)) {
     mkdirSync7(AUTH_DIR, { recursive: true });
   }
   writeFileSync8(AUTH_PATH, JSON.stringify(session2, null, 2));
 }
 function loadSession() {
-  if (!existsSync12(AUTH_PATH)) return null;
+  if (!existsSync11(AUTH_PATH)) return null;
   try {
-    return JSON.parse(readFileSync9(AUTH_PATH, "utf-8"));
+    return JSON.parse(readFileSync8(AUTH_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearSession() {
-  if (existsSync12(AUTH_PATH)) {
+  if (existsSync11(AUTH_PATH)) {
     writeFileSync8(AUTH_PATH, "");
   }
 }
@@ -4897,9 +5939,9 @@ Since:   ${new Date(session2.createdAt).toLocaleDateString()}
 }
 
 // src/commands/update.ts
-import { createInterface as createInterface2 } from "readline";
-async function confirm2(message) {
-  const rl = createInterface2({
+import { createInterface as createInterface3 } from "readline";
+async function confirm3(message) {
+  const rl = createInterface3({
     input: process.stdin,
     output: process.stdout
   });
@@ -4939,7 +5981,7 @@ async function updateCommand(options = {}) {
   writeLine();
   writeLine(`  ${colors.cyan}\u2B06${RESET} Update available: ${colors.dim}${info.currentVersion}${RESET} \u2192 ${colors.green}${info.latestVersion}${RESET}`);
   writeLine();
-  const shouldUpdate = options.yes || await confirm2("Update now?");
+  const shouldUpdate = options.yes || await confirm3("Update now?");
   if (!shouldUpdate) {
     writeLine();
     writeLine(`  ${colors.dim}Update skipped${RESET}`);
@@ -4963,15 +6005,15 @@ async function updateCommand(options = {}) {
 }
 
 // src/commands/progress.ts
-import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
+import { execSync as execSync9 } from "child_process";
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
 import { join as join13 } from "path";
 function getTasksFilePath() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     const cwd = process.cwd();
     const agentsDir = join13(cwd, ".agents");
-    if (!existsSync13(agentsDir)) {
+    if (!existsSync12(agentsDir)) {
       mkdirSync8(agentsDir, { recursive: true });
     }
     return join13(agentsDir, "tasks.json");
@@ -4980,9 +6022,9 @@ function getTasksFilePath() {
 }
 function loadTasks() {
   const tasksPath = getTasksFilePath();
-  if (existsSync13(tasksPath)) {
+  if (existsSync12(tasksPath)) {
     try {
-      return JSON.parse(readFileSync10(tasksPath, "utf-8"));
+      return JSON.parse(readFileSync9(tasksPath, "utf-8"));
     } catch {
       return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
     }
@@ -5008,7 +6050,7 @@ function getRecentActivity() {
     marketing: ["marketing", "content", "social"]
   };
   try {
-    const logOutput = execSync8(
+    const logOutput = execSync9(
       'git log --since="24 hours ago" --format="%h|%aI|%s" 2>/dev/null',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5142,7 +6184,7 @@ function getElapsedTime(startTime) {
 }
 
 // src/commands/results.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 function getGitStats(days = 7) {
   const stats = /* @__PURE__ */ new Map();
   const squadKeywords = {
@@ -5157,7 +6199,7 @@ function getGitStats(days = 7) {
     marketing: ["marketing"]
   };
   try {
-    const logOutput = execSync9(
+    const logOutput = execSync10(
       `git log --since="${days} days ago" --format="%s" --name-only 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5191,12 +6233,12 @@ function getGitStats(days = 7) {
   }
   return stats;
 }
-function getGitHubStats2(days = 7) {
+function getGitHubStats(days = 7) {
   const prsOpened = /* @__PURE__ */ new Map();
   const prsMerged = /* @__PURE__ */ new Map();
   const issuesClosed = /* @__PURE__ */ new Map();
   try {
-    const prsOutput = execSync9(
+    const prsOutput = execSync10(
       `gh pr list --state all --json title,createdAt,mergedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -5211,7 +6253,7 @@ function getGitHubStats2(days = 7) {
         prsMerged.set(squad, (prsMerged.get(squad) || 0) + 1);
       }
     }
-    const issuesOutput = execSync9(
+    const issuesOutput = execSync10(
       `gh issue list --state closed --json title,closedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -5272,7 +6314,7 @@ async function resultsCommand(options = {}) {
   writeLine();
   const squadNames = options.squad ? [options.squad] : listSquads(squadsDir);
   const gitStats = getGitStats(days);
-  const ghStats = getGitHubStats2(days);
+  const ghStats = getGitHubStats(days);
   const results = [];
   for (const name of squadNames) {
     const squad = loadSquad(name);
@@ -5342,29 +6384,425 @@ async function resultsCommand(options = {}) {
   writeLine();
 }
 
-// src/commands/workers.ts
-import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+// src/commands/history.ts
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { join as join14 } from "path";
-function getTasksFilePath2() {
-  const memoryDir = findMemoryDir();
-  if (!memoryDir) return null;
-  return join14(memoryDir, "..", "tasks.json");
-}
-function loadActiveTasks() {
-  const tasksPath = getTasksFilePath2();
-  if (!tasksPath || !existsSync14(tasksPath)) return [];
+var BRIDGE_URL2 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+var FETCH_TIMEOUT_MS2 = 3e3;
+async function fetchWithTimeout2(url, timeoutMs = FETCH_TIMEOUT_MS2) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const data = JSON.parse(readFileSync11(tasksPath, "utf-8"));
-    return data.tasks?.filter((t) => t.status === "active") || [];
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
   } catch {
-    return [];
+    clearTimeout(timeoutId);
+    throw new Error("Request timed out");
   }
 }
-function getRunningProcesses() {
-  const processes = [];
+async function fetchFromBridge2(days, squad) {
   try {
-    const psOutput = execSync10(
+    const params = new URLSearchParams({
+      days: String(days),
+      ...squad && { squad }
+    });
+    const response = await fetchWithTimeout2(`${BRIDGE_URL2}/api/executions?${params}`);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return (data.executions || []).map((e) => ({
+      id: e.id || "",
+      squad: e.squad || "unknown",
+      agent: e.agent || "unknown",
+      startedAt: new Date(e.started_at || Date.now()),
+      endedAt: e.ended_at ? new Date(e.ended_at) : void 0,
+      durationMs: e.duration_ms,
+      status: e.status || "success",
+      cost: e.cost_usd,
+      tokens: e.total_tokens,
+      error: e.error
+    }));
+  } catch {
+    return [];
+  }
+}
+function fetchFromLocal(days, squad) {
+  const executions = [];
+  const historyPaths = [
+    join14(process.cwd(), ".agents/sessions/history.jsonl"),
+    join14(process.env.HOME || "", "agents-squads/hq/.agents/sessions/history.jsonl")
+  ];
+  let historyPath;
+  for (const path3 of historyPaths) {
+    if (existsSync13(path3)) {
+      historyPath = path3;
+      break;
+    }
+  }
+  if (!historyPath) {
+    return [];
+  }
+  try {
+    const content = readFileSync10(historyPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        const timestamp = new Date(event.timestamp || 0);
+        if (timestamp.getTime() < cutoff) continue;
+        if (squad && event.squad !== squad) continue;
+        if (event.type === "session_end" || event.type === "agent_complete") {
+          executions.push({
+            id: event.sessionId || `local-${Date.now()}`,
+            squad: event.squad || "unknown",
+            agent: event.agent || "unknown",
+            startedAt: timestamp,
+            durationMs: event.duration,
+            status: event.status === "error" ? "error" : "success",
+            cost: event.cost,
+            tokens: event.tokens
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return executions;
+}
+function formatDuration(ms) {
+  if (!ms) return "\u2014";
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${hours}h ${remainingMinutes}m`;
+}
+function groupByDate(executions) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const exec2 of executions) {
+    const dateKey = exec2.startedAt.toISOString().split("T")[0];
+    if (!groups.has(dateKey)) {
+      groups.set(dateKey, []);
+    }
+    groups.get(dateKey).push(exec2);
+  }
+  return groups;
+}
+function formatDateHeader(dateStr) {
+  const date = new Date(dateStr);
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (dateStr === today.toISOString().split("T")[0]) {
+    return `Today (${date.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`;
+  }
+  if (dateStr === yesterday.toISOString().split("T")[0]) {
+    return `Yesterday (${date.toLocaleDateString("en-US", { month: "short", day: "numeric" })})`;
+  }
+  return date.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric" });
+}
+async function historyCommand(options = {}) {
+  const days = options.days || 7;
+  const squad = options.squad;
+  const verbose = options.verbose || false;
+  const jsonOutput = options.json || false;
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}history${RESET}`);
+  writeLine();
+  const [bridgeExecs, localExecs] = await Promise.all([
+    fetchFromBridge2(days, squad),
+    Promise.resolve(fetchFromLocal(days, squad))
+  ]);
+  const seenIds = /* @__PURE__ */ new Set();
+  const allExecutions = [];
+  for (const exec2 of bridgeExecs) {
+    seenIds.add(exec2.id);
+    allExecutions.push(exec2);
+  }
+  for (const exec2 of localExecs) {
+    if (!seenIds.has(exec2.id)) {
+      allExecutions.push(exec2);
+    }
+  }
+  allExecutions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+  if (jsonOutput) {
+    console.log(JSON.stringify(allExecutions, null, 2));
+    return;
+  }
+  if (allExecutions.length === 0) {
+    writeLine(`  ${colors.dim}No executions found in the last ${days} day(s)${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Tip: Run agents with 'squads run <squad>' to see history${RESET}`);
+    writeLine();
+    return;
+  }
+  const grouped = groupByDate(allExecutions);
+  const source = bridgeExecs.length > 0 ? "postgres" : "local";
+  writeLine(`  ${colors.dim}${allExecutions.length} executions (last ${days}d, source: ${source})${RESET}`);
+  writeLine();
+  for (const [dateStr, execs] of grouped) {
+    writeLine(`  ${bold}${formatDateHeader(dateStr)}${RESET}`);
+    writeLine(`  ${colors.purple}\u250C${"\u2500".repeat(60)}\u2510${RESET}`);
+    writeLine(`  ${colors.purple}\u2502${RESET} ${padEnd("TIME", 7)}${padEnd("SQUAD", 13)}${padEnd("AGENT", 16)}${padEnd("DURATION", 10)}${padEnd("STATUS", 8)}${colors.purple}\u2502${RESET}`);
+    writeLine(`  ${colors.purple}\u251C${"\u2500".repeat(60)}\u2524${RESET}`);
+    for (const exec2 of execs) {
+      const time = exec2.startedAt.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+      const squadName = truncate(exec2.squad, 11);
+      const agentName = truncate(exec2.agent, 14);
+      const duration = formatDuration(exec2.durationMs);
+      let statusIcon;
+      let statusColor;
+      switch (exec2.status) {
+        case "success":
+          statusIcon = icons.success;
+          statusColor = colors.green;
+          break;
+        case "error":
+          statusIcon = icons.error;
+          statusColor = colors.red;
+          break;
+        case "running":
+          statusIcon = icons.progress;
+          statusColor = colors.cyan;
+          break;
+        default:
+          statusIcon = icons.empty;
+          statusColor = colors.dim;
+      }
+      writeLine(`  ${colors.purple}\u2502${RESET} ${colors.dim}${time}${RESET}  ${colors.cyan}${padEnd(squadName, 12)}${RESET}${padEnd(agentName, 16)}${padEnd(duration, 10)}${statusColor}${statusIcon}${RESET}       ${colors.purple}\u2502${RESET}`);
+      if (verbose && (exec2.cost || exec2.tokens)) {
+        const costStr = exec2.cost ? `$${exec2.cost.toFixed(2)}` : "";
+        const tokenStr = exec2.tokens ? `${exec2.tokens.toLocaleString()} tokens` : "";
+        const details = [costStr, tokenStr].filter(Boolean).join("  \u2502  ");
+        writeLine(`  ${colors.purple}\u2502${RESET}         ${colors.dim}\u2514 ${details}${RESET}${" ".repeat(Math.max(0, 45 - details.length))}${colors.purple}\u2502${RESET}`);
+      }
+      if (exec2.error) {
+        writeLine(`  ${colors.purple}\u2502${RESET}         ${colors.red}\u2514 ${truncate(exec2.error, 45)}${RESET}${" ".repeat(Math.max(0, 45 - exec2.error.length))}${colors.purple}\u2502${RESET}`);
+      }
+    }
+    writeLine(`  ${colors.purple}\u2514${"\u2500".repeat(60)}\u2518${RESET}`);
+    writeLine();
+  }
+  const successCount = allExecutions.filter((e) => e.status === "success").length;
+  const errorCount = allExecutions.filter((e) => e.status === "error").length;
+  const totalCost = allExecutions.reduce((sum, e) => sum + (e.cost || 0), 0);
+  writeLine(`  ${colors.dim}Summary:${RESET} ${colors.green}${successCount} success${RESET}  ${errorCount > 0 ? `${colors.red}${errorCount} errors${RESET}  ` : ""}${totalCost > 0 ? `${colors.cyan}$${totalCost.toFixed(2)} total${RESET}` : ""}`);
+  writeLine();
+}
+
+// src/commands/health.ts
+var FETCH_TIMEOUT_MS3 = 2e3;
+var SERVICES2 = [
+  {
+    name: "PostgreSQL",
+    url: `${process.env.SQUADS_BRIDGE_URL || "http://localhost:8088"}/stats`,
+    fix: "squads stack up postgres"
+  },
+  {
+    name: "Redis",
+    url: `${process.env.SQUADS_BRIDGE_URL || "http://localhost:8088"}/stats`,
+    fix: "squads stack up redis"
+  },
+  {
+    name: "Bridge API",
+    url: `${process.env.SQUADS_BRIDGE_URL || "http://localhost:8088"}/health`,
+    fix: "squads stack up bridge"
+  },
+  {
+    name: "Scheduler",
+    url: `${process.env.SQUADS_SCHEDULER_URL || "http://localhost:8090"}/health`,
+    fix: "squads stack up scheduler"
+  },
+  {
+    name: "Langfuse",
+    url: `${process.env.LANGFUSE_HOST || "http://localhost:3100"}/api/public/health`,
+    optional: true,
+    fix: "squads stack up langfuse"
+  }
+];
+async function fetchWithTimeout3(url, timeoutMs = FETCH_TIMEOUT_MS3) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
+  } catch {
+    clearTimeout(timeoutId);
+    throw new Error("timeout");
+  }
+}
+async function checkService2(service) {
+  const start = Date.now();
+  try {
+    const response = await fetchWithTimeout3(service.url);
+    const latencyMs = Date.now() - start;
+    if (response.ok) {
+      return {
+        name: service.name,
+        status: "healthy",
+        latencyMs,
+        optional: service.optional
+      };
+    }
+    return {
+      name: service.name,
+      status: "degraded",
+      latencyMs,
+      error: `HTTP ${response.status}`,
+      optional: service.optional,
+      fix: service.fix
+    };
+  } catch (error) {
+    return {
+      name: service.name,
+      status: "down",
+      error: error instanceof Error ? error.message : "unknown",
+      optional: service.optional,
+      fix: service.fix
+    };
+  }
+}
+async function getTriggerStats() {
+  try {
+    const schedulerUrl = process.env.SQUADS_SCHEDULER_URL || "http://localhost:8090";
+    const response = await fetchWithTimeout3(`${schedulerUrl}/api/triggers/stats`);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return {
+      active: data.active || 0,
+      disabled: data.disabled || 0,
+      lastFire: data.last_fire ? {
+        name: data.last_fire.name || "unknown",
+        ago: formatTimeAgo(new Date(data.last_fire.fired_at || Date.now()))
+      } : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function formatTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+function formatLatency(ms) {
+  if (!ms) return "\u2014";
+  return `${ms}ms`;
+}
+async function healthCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}health${RESET}`);
+  writeLine();
+  const results = await Promise.all(SERVICES2.map(checkService2));
+  writeLine(`  ${colors.purple}\u250C${"\u2500".repeat(48)}\u2510${RESET}`);
+  writeLine(`  ${colors.purple}\u2502${RESET} ${padEnd("SERVICE", 18)}${padEnd("STATUS", 14)}${padEnd("LATENCY", 12)}${colors.purple}\u2502${RESET}`);
+  writeLine(`  ${colors.purple}\u251C${"\u2500".repeat(48)}\u2524${RESET}`);
+  const issues = [];
+  for (const result of results) {
+    let statusIcon;
+    let statusColor;
+    let statusText;
+    switch (result.status) {
+      case "healthy":
+        statusIcon = icons.success;
+        statusColor = colors.green;
+        statusText = "healthy";
+        break;
+      case "degraded":
+        statusIcon = icons.warning;
+        statusColor = colors.yellow;
+        statusText = "degraded";
+        issues.push(result);
+        break;
+      case "down":
+        statusIcon = icons.error;
+        statusColor = colors.red;
+        statusText = "down";
+        if (!result.optional) {
+          issues.push(result);
+        }
+        break;
+    }
+    const nameDisplay = result.optional ? `${result.name} ${colors.dim}(opt)${RESET}` : result.name;
+    const latency = formatLatency(result.latencyMs);
+    writeLine(`  ${colors.purple}\u2502${RESET} ${padEnd(nameDisplay, 18)}${statusColor}${statusIcon} ${padEnd(statusText, 11)}${RESET}${padEnd(latency, 12)}${colors.purple}\u2502${RESET}`);
+  }
+  writeLine(`  ${colors.purple}\u2514${"\u2500".repeat(48)}\u2518${RESET}`);
+  writeLine();
+  const schedulerUp = results.find((r) => r.name === "Scheduler")?.status === "healthy";
+  if (schedulerUp) {
+    const stats = await getTriggerStats();
+    if (stats) {
+      const lastFireText = stats.lastFire ? `${colors.dim}Last fire:${RESET} ${stats.lastFire.ago} (${stats.lastFire.name})` : `${colors.dim}No recent fires${RESET}`;
+      writeLine(`  ${colors.cyan}Triggers:${RESET} ${stats.active} active, ${stats.disabled} disabled`);
+      writeLine(`  ${lastFireText}`);
+      writeLine();
+    }
+  }
+  if (issues.length > 0) {
+    const criticalIssues = issues.filter((i) => !i.optional);
+    const optionalIssues = issues.filter((i) => i.optional);
+    if (criticalIssues.length > 0) {
+      writeLine(`  ${colors.red}${icons.warning} ${criticalIssues.length} service(s) need attention${RESET}`);
+      for (const issue of criticalIssues) {
+        writeLine(`    ${colors.dim}\u2022${RESET} ${issue.name}: ${issue.error || "not responding"}`);
+        if (issue.fix) {
+          writeLine(`      ${colors.cyan}Fix:${RESET} ${issue.fix}`);
+        }
+      }
+      writeLine();
+    }
+    if (options.verbose && optionalIssues.length > 0) {
+      writeLine(`  ${colors.yellow}Optional services down:${RESET}`);
+      for (const issue of optionalIssues) {
+        writeLine(`    ${colors.dim}\u2022${RESET} ${issue.name}`);
+      }
+      writeLine();
+    }
+  } else {
+    writeLine(`  ${colors.green}${icons.success} All services healthy${RESET}`);
+    writeLine();
+  }
+  if (!schedulerUp) {
+    writeLine(`  ${colors.yellow}${icons.warning} Scheduler not running - triggers won't auto-fire${RESET}`);
+    writeLine(`    ${colors.dim}Start with:${RESET} squads stack up scheduler`);
+    writeLine();
+  }
+}
+
+// src/commands/workers.ts
+import { execSync as execSync11 } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
+function getTasksFilePath2() {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return null;
+  return join15(memoryDir, "..", "tasks.json");
+}
+function loadActiveTasks() {
+  const tasksPath = getTasksFilePath2();
+  if (!tasksPath || !existsSync14(tasksPath)) return [];
+  try {
+    const data = JSON.parse(readFileSync11(tasksPath, "utf-8"));
+    return data.tasks?.filter((t) => t.status === "active") || [];
+  } catch {
+    return [];
+  }
+}
+function getRunningProcesses() {
+  const processes = [];
+  try {
+    const psOutput = execSync11(
       'ps aux | grep -E "claude|squads|astro|node.*agent" | grep -v grep',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5415,7 +6853,7 @@ async function workersCommand(options = {}) {
   writeLine();
   if (options.kill) {
     try {
-      execSync10(`kill ${options.kill}`, { stdio: "pipe" });
+      execSync11(`kill ${options.kill}`, { stdio: "pipe" });
       writeLine(`  ${icons.success} Killed process ${colors.cyan}${options.kill}${RESET}`);
       writeLine();
       return;
@@ -5501,6 +6939,725 @@ function getElapsedTime2(startTime) {
   return "<1m";
 }
 
+// src/commands/context-feed.ts
+import { existsSync as existsSync15, statSync as statSync3, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
+var BRIDGE_URL3 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+async function syncBriefToBridge(brief, sourcePath) {
+  try {
+    const response = await fetch(`${BRIDGE_URL3}/api/brief`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        priority: brief.priority,
+        runway: brief.runway,
+        focus: brief.focus || [],
+        blockers: brief.blockers || [],
+        decision_framework: brief.decisionFramework || [],
+        raw_content: brief.raw || "",
+        source_path: sourcePath,
+        synced_by: "cli"
+      })
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const result = await response.json();
+    return result.status === "synced" || result.status === "unchanged";
+  } catch {
+    return false;
+  }
+}
+function readBusinessBrief(squadsDir) {
+  if (!squadsDir) return void 0;
+  const briefPath = join16(squadsDir, "..", "BUSINESS_BRIEF.md");
+  if (!existsSync15(briefPath)) return void 0;
+  try {
+    const content = readFileSync12(briefPath, "utf-8");
+    const brief = { raw: content };
+    const priorityMatch = content.match(/##\s*#1 Priority\s*\n+\*\*([^*]+)\*\*/);
+    if (priorityMatch) {
+      brief.priority = priorityMatch[1].trim();
+    }
+    const runwayMatch = content.match(/##\s*Runway\s*\n+([\s\S]*?)(?=\n##|$)/);
+    if (runwayMatch) {
+      const pressureMatch = runwayMatch[1].match(/\*\*Pressure\*\*:\s*(\w+)/i);
+      if (pressureMatch) {
+        brief.runway = pressureMatch[1];
+      }
+    }
+    const focusMatch = content.match(/##\s*Current Focus\s*\n+([\s\S]*?)(?=\n##|$)/);
+    if (focusMatch) {
+      const items = focusMatch[1].match(/^\d+\.\s*\*\*([^*]+)\*\*/gm);
+      if (items) {
+        brief.focus = items.map((item) => {
+          const match = item.match(/\*\*([^*]+)\*\*/);
+          return match ? match[1].trim() : item;
+        });
+      }
+    }
+    const blockersMatch = content.match(/##\s*Blockers\s*\n+([\s\S]*?)(?=\n##|$)/);
+    if (blockersMatch) {
+      const text = blockersMatch[1].trim();
+      if (text.toLowerCase().includes("none")) {
+        brief.blockers = [];
+      } else {
+        const items = text.match(/^-\s*(.+)$/gm);
+        if (items) {
+          brief.blockers = items.map((item) => item.replace(/^-\s*/, "").trim());
+        }
+      }
+    }
+    const decisionMatch = content.match(/##\s*Decision Framework\s*\n+([\s\S]*?)(?=\n##|$)/);
+    if (decisionMatch) {
+      const items = decisionMatch[1].match(/^\d+\.\s*(.+)$/gm);
+      if (items) {
+        brief.decisionFramework = items.map((item) => item.replace(/^\d+\.\s*/, "").trim());
+      }
+    }
+    return brief;
+  } catch {
+    return void 0;
+  }
+}
+async function collectBriefingData(options) {
+  const squadsDir = findSquadsDir();
+  const memoryDir = findMemoryDir();
+  const baseDir = squadsDir ? join16(squadsDir, "..", "..", "..") : null;
+  const allSquads = squadsDir ? listSquads(squadsDir) : [];
+  if (options.squad && !allSquads.includes(options.squad)) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: `Squad "${options.squad}" not found. Available: ${allSquads.join(", ")}`,
+      squads: [],
+      goals: { active: 0, completed: 0, bySquad: [] },
+      sessions: { active: 0, bySquad: 0 }
+    };
+  }
+  const squadNames = options.squad ? [options.squad] : allSquads;
+  const [bridgeStats, rateLimits, sessions2, gitStats] = await Promise.all([
+    fetchBridgeStats(),
+    fetchRateLimits(),
+    getLiveSessionSummaryAsync(),
+    baseDir ? Promise.resolve(getMultiRepoGitStats(baseDir, 7)) : Promise.resolve(null)
+  ]);
+  const squadBriefings = [];
+  const goalsBySquad = [];
+  let totalActive = 0;
+  let totalCompleted = 0;
+  for (const squadName of squadNames) {
+    const squad = loadSquad(squadName);
+    if (!squad) continue;
+    const agents = squadsDir ? listAgents(squadsDir, squadName) : [];
+    const activeGoals = squad.goals.filter((g) => !g.completed);
+    const completedGoals = squad.goals.filter((g) => g.completed);
+    totalActive += activeGoals.length;
+    totalCompleted += completedGoals.length;
+    const states = getSquadState(squadName);
+    const recentMemory = [];
+    for (const state of states.slice(0, 3)) {
+      const lines = state.content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+      if (lines.length > 0) {
+        recentMemory.push(lines[0].substring(0, 100));
+      }
+    }
+    let lastActivity;
+    if (memoryDir) {
+      const squadMemoryPath = join16(memoryDir, squadName);
+      if (existsSync15(squadMemoryPath)) {
+        let mostRecent = 0;
+        try {
+          const walkDir = (dir) => {
+            const entries = readdirSync6(dir, { withFileTypes: true });
+            for (const entry of entries) {
+              const fullPath = join16(dir, entry.name);
+              if (entry.isDirectory()) {
+                walkDir(fullPath);
+              } else if (entry.name.endsWith(".md")) {
+                const stat = statSync3(fullPath);
+                if (stat.mtimeMs > mostRecent) {
+                  mostRecent = stat.mtimeMs;
+                }
+              }
+            }
+          };
+          walkDir(squadMemoryPath);
+        } catch {
+        }
+        if (mostRecent > 0) {
+          const daysAgo = Math.floor((Date.now() - mostRecent) / (1e3 * 60 * 60 * 24));
+          if (daysAgo === 0) lastActivity = "today";
+          else if (daysAgo === 1) lastActivity = "yesterday";
+          else lastActivity = `${daysAgo}d ago`;
+        }
+      }
+    }
+    squadBriefings.push({
+      name: squadName,
+      mission: squad.mission,
+      agentCount: agents.length,
+      activeGoals: activeGoals.map((g) => ({
+        description: g.description,
+        progress: g.progress
+      })),
+      memoryEntries: states.length,
+      recentMemory,
+      lastActivity
+    });
+    if (activeGoals.length > 0) {
+      goalsBySquad.push({
+        squad: squadName,
+        goals: activeGoals.map((g) => g.description)
+      });
+    }
+  }
+  const costs = bridgeStats ? {
+    today: {
+      generations: bridgeStats.today.generations,
+      cost: bridgeStats.today.costUsd
+    },
+    budget: bridgeStats.budget,
+    bySquad: bridgeStats.bySquad.map((s) => ({
+      squad: s.squad,
+      cost: s.costUsd,
+      generations: s.generations
+    }))
+  } : void 0;
+  const rateLimitsData = rateLimits.source !== "none" ? {
+    models: Object.values(rateLimits.limits).map((l) => ({
+      model: l.model,
+      requestsRemaining: l.requestsRemaining,
+      tokensRemaining: l.tokensRemaining
+    }))
+  } : void 0;
+  const git = gitStats ? {
+    commits: gitStats.totalCommits,
+    activeDays: gitStats.activeDays,
+    avgPerDay: gitStats.avgCommitsPerDay,
+    byRepo: Array.from(gitStats.commitsByRepo.entries()).map(([repo, commits]) => ({
+      repo,
+      commits
+    }))
+  } : void 0;
+  let relevantMemory;
+  if (options.topic) {
+    const results = searchMemory(options.topic);
+    relevantMemory = results.slice(0, 5).map((r) => ({
+      squad: r.entry.squad,
+      agent: r.entry.agent,
+      snippet: r.matches[0]?.substring(0, 150) || ""
+    }));
+  }
+  const brief = readBusinessBrief(squadsDir);
+  if (brief && squadsDir) {
+    const briefPath = join16(squadsDir, "..", "BUSINESS_BRIEF.md");
+    syncBriefToBridge(brief, briefPath).catch(() => {
+    });
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    brief,
+    squads: squadBriefings,
+    goals: {
+      active: totalActive,
+      completed: totalCompleted,
+      bySquad: goalsBySquad
+    },
+    costs,
+    rateLimits: rateLimitsData,
+    git,
+    sessions: {
+      active: sessions2.totalSessions,
+      bySquad: sessions2.squadCount
+    },
+    relevantMemory
+  };
+}
+function renderHumanBriefing(data, options) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}context-feed${RESET}`);
+  writeLine();
+  if (data.error) {
+    writeLine(`  ${colors.yellow}${icons.warning || "\u26A0"}${RESET} ${data.error}`);
+    writeLine();
+    return;
+  }
+  if (data.brief) {
+    if (data.brief.priority) {
+      const runwayColor = data.brief.runway === "HIGH" ? colors.red : data.brief.runway === "MEDIUM" ? colors.yellow : colors.green;
+      writeLine(`  ${bold}#1 Priority${RESET} ${runwayColor}[${data.brief.runway || "\u2014"}]${RESET}`);
+      writeLine(`  ${colors.white}${data.brief.priority}${RESET}`);
+      writeLine();
+    }
+    if (data.brief.focus && data.brief.focus.length > 0) {
+      writeLine(`  ${bold}Focus${RESET}`);
+      for (const item of data.brief.focus.slice(0, 3)) {
+        writeLine(`  ${colors.cyan}\u2192${RESET} ${item}`);
+      }
+      writeLine();
+    }
+    if (data.brief.blockers && data.brief.blockers.length > 0) {
+      writeLine(`  ${colors.red}${bold}Blockers${RESET}`);
+      for (const blocker of data.brief.blockers) {
+        writeLine(`  ${colors.red}\u2717${RESET} ${blocker}`);
+      }
+      writeLine();
+    }
+  }
+  if (data.sessions.active > 0) {
+    writeLine(`  ${colors.green}${icons.active}${RESET} ${data.sessions.active} active sessions across ${data.sessions.bySquad} squads`);
+    writeLine();
+  }
+  if (data.goals.active > 0) {
+    writeLine(`  ${bold}Active Goals${RESET} ${colors.dim}(${data.goals.active})${RESET}`);
+    writeLine();
+    for (const sq of data.goals.bySquad) {
+      writeLine(`  ${colors.cyan}${sq.squad}${RESET}`);
+      for (const goal2 of sq.goals.slice(0, 2)) {
+        writeLine(`    ${icons.active} ${goal2}`);
+      }
+      if (sq.goals.length > 2) {
+        writeLine(`    ${colors.dim}+${sq.goals.length - 2} more${RESET}`);
+      }
+    }
+    writeLine();
+  }
+  if (data.costs) {
+    const { budget } = data.costs;
+    const usedBar = "\u2588".repeat(Math.min(Math.round(budget.usedPct / 5), 20));
+    const emptyBar = "\u2591".repeat(20 - usedBar.length);
+    writeLine(`  ${bold}Budget${RESET}`);
+    writeLine(`  ${colors.dim}$${budget.used.toFixed(2)}/${budget.daily} today${RESET} ${usedBar}${emptyBar} ${budget.usedPct.toFixed(0)}%`);
+    writeLine();
+  }
+  if (data.rateLimits && options.verbose) {
+    writeLine(`  ${bold}Rate Limits${RESET}`);
+    for (const model of data.rateLimits.models.slice(0, 3)) {
+      const shortName = model.model.replace("claude-", "").replace(/-\d+$/, "");
+      writeLine(`  ${colors.dim}${shortName}:${RESET} ${model.requestsRemaining} req, ${Math.round(model.tokensRemaining / 1e3)}k tok`);
+    }
+    writeLine();
+  }
+  if (data.git && data.git.commits > 0) {
+    writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(7d)${RESET}`);
+    writeLine(`  ${data.git.commits} commits, ${data.git.avgPerDay}/day avg`);
+    writeLine();
+  }
+  const activeSquads = data.squads.filter((s) => s.activeGoals.length > 0 || s.memoryEntries > 0);
+  if (activeSquads.length > 0 && options.verbose) {
+    const w = { name: 14, agents: 8, memory: 10, activity: 10 };
+    const tableWidth = w.name + w.agents + w.memory + w.activity + 4;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("AGENTS", w.agents)}${RESET}${bold}${padEnd("MEMORY", w.memory)}${RESET}${bold}ACTIVITY${RESET} ${colors.purple}${box.vertical}${RESET}`);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const sq of activeSquads.slice(0, 8)) {
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(sq.name, w.name)}${RESET}${padEnd(String(sq.agentCount), w.agents)}${padEnd(String(sq.memoryEntries), w.memory)}${padEnd(sq.lastActivity || "\u2014", w.activity - 2)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+    writeLine();
+  }
+  if (data.relevantMemory && data.relevantMemory.length > 0) {
+    writeLine(`  ${bold}Relevant Memory${RESET} ${colors.dim}("${options.topic}")${RESET}`);
+    for (const mem of data.relevantMemory) {
+      writeLine(`  ${colors.cyan}${mem.squad}/${mem.agent}${RESET}`);
+      writeLine(`    ${colors.dim}${mem.snippet}${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads feed ${colors.cyan}--topic "pricing"${RESET}    ${colors.dim}Topic-focused${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads feed ${colors.cyan}--squad website${RESET}     ${colors.dim}Single squad${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads feed ${colors.cyan}--agent${RESET}             ${colors.dim}JSON for agents${RESET}`);
+  writeLine();
+}
+function renderAgentBriefing(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+async function contextFeedCommand(options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    if (options.json || options.agent) {
+      console.log(JSON.stringify({ error: "No .agents/squads directory found" }));
+    } else {
+      writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+      writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    }
+    process.exit(1);
+  }
+  const data = await collectBriefingData(options);
+  if (options.json || options.agent) {
+    renderAgentBriefing(data);
+  } else {
+    renderHumanBriefing(data, options);
+  }
+}
+
+// src/commands/watch.ts
+import { spawn as spawn6 } from "child_process";
+async function watchCommand(command, args, options) {
+  const interval = (options.interval || 2) * 1e3;
+  const shouldClear = options.clear !== false;
+  const validCommands = [
+    "status",
+    "workers",
+    "dash",
+    "dashboard",
+    "sessions",
+    "memory",
+    "history",
+    "results",
+    "progress",
+    "goal"
+  ];
+  if (!validCommands.includes(command)) {
+    writeLine(`  ${colors.red}Unknown command: ${command}${RESET}`);
+    writeLine(`  ${colors.dim}Valid commands: ${validCommands.join(", ")}${RESET}`);
+    process.exit(1);
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}watch${RESET} ${colors.cyan}${command}${RESET}`);
+  writeLine(`  ${colors.dim}Refreshing every ${options.interval || 2}s (Ctrl+C to stop)${RESET}`);
+  writeLine();
+  await runCommand2(command, args, shouldClear);
+  const timer = setInterval(async () => {
+    await runCommand2(command, args, shouldClear);
+  }, interval);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    writeLine();
+    writeLine(`  ${colors.dim}Watch stopped${RESET}`);
+    writeLine();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+async function runCommand2(command, args, clear) {
+  return new Promise((resolve) => {
+    if (clear) {
+      process.stdout.write("\x1B[2J\x1B[H");
+    }
+    const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    process.stdout.write(`\x1B[90m${now}\x1B[0m
+
+`);
+    const child = spawn6("squads", [command, ...args], {
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("close", () => {
+      resolve();
+    });
+    child.on("error", (err) => {
+      writeLine(`  ${colors.red}Error: ${err.message}${RESET}`);
+      resolve();
+    });
+  });
+}
+
+// src/commands/live.ts
+import blessed from "blessed";
+import contrib from "blessed-contrib";
+import { execSync as execSync12 } from "child_process";
+async function liveCommand(_options) {
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: "Squads Live Dashboard",
+    fullUnicode: true
+  });
+  const grid = new contrib.grid({
+    rows: 12,
+    cols: 12,
+    screen
+  });
+  const agentsTable = grid.set(0, 0, 6, 8, contrib.table, {
+    keys: true,
+    fg: "white",
+    label: " Running Agents ",
+    columnSpacing: 2,
+    columnWidth: [20, 12, 10, 8, 8],
+    border: { type: "line", fg: "cyan" }
+  });
+  const costGauge = grid.set(0, 8, 3, 4, contrib.gauge, {
+    label: " Budget Used ",
+    stroke: "green",
+    fill: "white",
+    border: { type: "line", fg: "cyan" }
+  });
+  const costLog = grid.set(3, 8, 3, 4, contrib.log, {
+    fg: "green",
+    label: " Cost Tracker ",
+    border: { type: "line", fg: "cyan" }
+  });
+  const activityLog = grid.set(6, 0, 6, 6, contrib.log, {
+    fg: "cyan",
+    label: " Recent Activity ",
+    border: { type: "line", fg: "magenta" }
+  });
+  const memoryLog = grid.set(6, 6, 6, 6, contrib.log, {
+    fg: "yellow",
+    label: " Memory Updates ",
+    border: { type: "line", fg: "magenta" }
+  });
+  function getAgents() {
+    try {
+      const output = execSync12('ps aux | grep -E "claude|node.*squads" | grep -v grep', {
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+      const agents = [];
+      const lines = output.trim().split("\n").slice(0, 10);
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 10) {
+          const cpu = parts[2];
+          const mem = parts[3];
+          const time = parts[9];
+          const cmd = parts.slice(10).join(" ");
+          let name = "claude";
+          let squad = "unknown";
+          if (cmd.includes("squads-")) {
+            const match = cmd.match(/squads-(\w+)-(\w+)/);
+            if (match) {
+              squad = match[1];
+              name = match[2];
+            }
+          }
+          agents.push({
+            name: name.substring(0, 18),
+            squad: squad.substring(0, 10),
+            status: parseFloat(cpu) > 5 ? "active" : "idle",
+            duration: time,
+            cpu: cpu + "%",
+            mem: mem + "%"
+          });
+        }
+      }
+      return agents.slice(0, 8);
+    } catch {
+      return [];
+    }
+  }
+  function getCosts() {
+    const baseToday = 12.5;
+    const baseWeek = 89.2;
+    const variance = Math.random() * 0.5;
+    return {
+      today: baseToday + variance,
+      week: baseWeek + variance * 10,
+      budget: 200
+    };
+  }
+  function getRecentActivity2() {
+    try {
+      const output = execSync12(
+        "gh issue list --repo agents-squads/squads-cli --state open --limit 5 --json number,title,createdAt 2>/dev/null",
+        { encoding: "utf-8", timeout: 1e4 }
+      );
+      const issues = JSON.parse(output);
+      return issues.map(
+        (i) => `#${i.number} ${i.title.substring(0, 40)}`
+      );
+    } catch {
+      return ["(loading...)"];
+    }
+  }
+  function getMemoryUpdates() {
+    try {
+      const output = execSync12(
+        'find .agents/memory -name "state.md" -mmin -60 2>/dev/null | head -5',
+        { encoding: "utf-8", timeout: 5e3 }
+      );
+      return output.trim().split("\n").filter(Boolean).map((path3) => {
+        const parts = path3.split("/");
+        const squad = parts[2] || "";
+        const agent = parts[3] || "";
+        return `${squad}/${agent}`;
+      });
+    } catch {
+      return ["(no recent updates)"];
+    }
+  }
+  function updateAgents() {
+    const agents = getAgents();
+    const data = agents.length > 0 ? agents.map((a) => [a.name, a.squad, a.status === "active" ? "\u25CF active" : "\u25CB idle", a.cpu, a.mem]) : [["(no agents running)", "", "", "", ""]];
+    agentsTable.setData({
+      headers: ["Agent", "Squad", "Status", "CPU", "MEM"],
+      data
+    });
+  }
+  function updateCosts() {
+    const costs = getCosts();
+    const percent = Math.round(costs.week / costs.budget * 100);
+    costGauge.setPercent(percent);
+    costLog.log(`Today:  $${costs.today.toFixed(2)}`);
+    costLog.log(`Week:   $${costs.week.toFixed(2)} / $${costs.budget}`);
+  }
+  function updateActivity() {
+    const activities = getRecentActivity2();
+    activities.forEach((a) => activityLog.log(a));
+  }
+  function updateMemory() {
+    const updates = getMemoryUpdates();
+    updates.forEach((u) => memoryLog.log(u));
+  }
+  updateAgents();
+  updateCosts();
+  updateActivity();
+  updateMemory();
+  screen.render();
+  const agentInterval = setInterval(() => {
+    updateAgents();
+    screen.render();
+  }, 2e3);
+  const costInterval = setInterval(() => {
+    updateCosts();
+    screen.render();
+  }, 5e3);
+  const activityInterval = setInterval(() => {
+    updateActivity();
+    screen.render();
+  }, 1e4);
+  const memoryInterval = setInterval(() => {
+    updateMemory();
+    screen.render();
+  }, 15e3);
+  screen.key(["escape", "q", "C-c"], () => {
+    clearInterval(agentInterval);
+    clearInterval(costInterval);
+    clearInterval(activityInterval);
+    clearInterval(memoryInterval);
+    return process.exit(0);
+  });
+  screen.key(["r"], () => {
+    updateAgents();
+    updateCosts();
+    updateActivity();
+    updateMemory();
+    screen.render();
+  });
+  agentsTable.focus();
+}
+
+// src/commands/top.ts
+import { execSync as execSync13 } from "child_process";
+var ESC = "\x1B";
+var CLEAR_SCREEN = `${ESC}[2J`;
+var CURSOR_HOME = `${ESC}[H`;
+var CURSOR_HIDE = `${ESC}[?25l`;
+var CURSOR_SHOW = `${ESC}[?25h`;
+var BOLD = `${ESC}[1m`;
+var DIM = `${ESC}[2m`;
+var RESET2 = `${ESC}[0m`;
+var CYAN = `${ESC}[36m`;
+var GREEN = `${ESC}[32m`;
+var YELLOW = `${ESC}[33m`;
+var MAGENTA = `${ESC}[35m`;
+async function topCommand() {
+  process.stdout.write(CURSOR_HIDE + CLEAR_SCREEN + CURSOR_HOME);
+  let running = true;
+  const cleanup = () => {
+    running = false;
+    process.stdout.write(CURSOR_SHOW + "\n");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  while (running) {
+    const data = getProcessData();
+    render(data);
+    await sleep2(1e3);
+  }
+}
+function getProcessData() {
+  const processes = [];
+  let claudeCount = 0;
+  let agentCount = 0;
+  try {
+    const psOutput = execSync13(
+      'ps aux | grep -E "[c]laude" | head -15',
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const lines = psOutput.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 11) {
+        const pid = parts[1];
+        const cpu = parts[2];
+        const mem = parts[3];
+        const time = parts[9];
+        const cmd = parts.slice(10).join(" ").substring(0, 30);
+        const cpuNum = parseFloat(cpu);
+        const status = cpuNum > 5 ? "active" : "idle";
+        if (cmd.includes("squads-")) {
+          agentCount++;
+        }
+        claudeCount++;
+        processes.push({ pid, cpu, mem, time, status, cmd });
+      }
+    }
+  } catch {
+  }
+  try {
+    const tmuxOutput = execSync13("tmux ls 2>/dev/null | grep squads- | wc -l", { encoding: "utf-8" });
+    agentCount = parseInt(tmuxOutput.trim()) || 0;
+  } catch {
+  }
+  return {
+    processes: processes.slice(0, 12),
+    summary: { claude: claudeCount, tasks: 0, agents: agentCount }
+  };
+}
+function render(data) {
+  const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${MAGENTA}squads${RESET2} ${DIM}top${RESET2}  ${DIM}${now}${RESET2}  ${DIM}(q to quit)${RESET2}`);
+  lines.push("");
+  const activeCount = data.processes.filter((p) => p.status === "active").length;
+  lines.push(`  ${CYAN}${data.summary.claude}${RESET2} claude  ${DIM}\u2502${RESET2}  ${GREEN}${activeCount}${RESET2} active  ${DIM}\u2502${RESET2}  ${YELLOW}${data.summary.agents}${RESET2} agents`);
+  lines.push("");
+  lines.push(`  ${BOLD}PID      CPU%    MEM%    TIME      STATUS${RESET2}`);
+  lines.push(`  ${DIM}${"\u2500".repeat(50)}${RESET2}`);
+  if (data.processes.length === 0) {
+    lines.push(`  ${DIM}(no claude processes)${RESET2}`);
+  } else {
+    for (const p of data.processes) {
+      const statusIcon = p.status === "active" ? `${GREEN}\u25CF${RESET2}` : `${DIM}\u25CB${RESET2}`;
+      const statusText = p.status === "active" ? `${GREEN}active${RESET2}` : `${DIM}idle${RESET2}`;
+      const cpuColor = parseFloat(p.cpu) > 10 ? YELLOW : "";
+      lines.push(
+        `  ${CYAN}${p.pid.padEnd(8)}${RESET2}${cpuColor}${p.cpu.padStart(5)}${RESET2}   ${p.mem.padStart(5)}   ${p.time.padEnd(10)}${statusIcon} ${statusText}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(`  ${DIM}Press q to quit, r to refresh${RESET2}`);
+  lines.push("");
+  process.stdout.write(CURSOR_HOME);
+  for (const line of lines) {
+    process.stdout.write(line + `${ESC}[K
+`);
+  }
+  for (let i = 0; i < 5; i++) {
+    process.stdout.write(`${ESC}[K
+`);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+if (process.stdin.isTTY) {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", (key) => {
+    if (key.toString() === "q" || key[0] === 3) {
+      process.stdout.write(CURSOR_SHOW + "\n");
+      process.exit(0);
+    }
+  });
+}
+
 // src/commands/session.ts
 async function sessionStartCommand(options = {}) {
   cleanupStaleSessions();
@@ -5545,9 +7702,10 @@ async function detectSquadCommand() {
 
 // src/commands/trigger.ts
 import chalk3 from "chalk";
+import { existsSync as existsSync16 } from "fs";
 var SCHEDULER_URL = process.env.SCHEDULER_URL || "http://localhost:8090";
-async function fetchScheduler(path2, options) {
-  const res = await fetch(`${SCHEDULER_URL}${path2}`, {
+async function fetchScheduler(path3, options) {
+  const res = await fetch(`${SCHEDULER_URL}${path3}`, {
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -5590,11 +7748,13 @@ async function listTriggers(squad) {
 }
 async function syncTriggers() {
   console.log(chalk3.gray("Syncing triggers from SQUAD.md files...\n"));
-  const { execSync: execSync11 } = await import("child_process");
+  const { execSync: execSync15 } = await import("child_process");
   const hqPath = process.env.HQ_PATH || `${process.env.HOME}/agents-squads/hq`;
   try {
-    const output = execSync11(
-      `python ${hqPath}/squads-scheduler/sync_triggers.py`,
+    const venvPython = `${hqPath}/squads-scheduler/.venv/bin/python`;
+    const pythonCmd = existsSync16(venvPython) ? venvPython : "python3";
+    const output = execSync15(
+      `${pythonCmd} ${hqPath}/squads-scheduler/sync_triggers.py`,
       { encoding: "utf-8", cwd: hqPath }
     );
     console.log(output);
@@ -5674,14 +7834,336 @@ function registerTriggerCommand(program2) {
   });
 }
 
+// src/commands/tonight.ts
+import ora6 from "ora";
+import fs2 from "fs/promises";
+import path2, { dirname as dirname5 } from "path";
+import { execSync as execSync14, spawn as spawn7 } from "child_process";
+function getProjectRoot2() {
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    return dirname5(dirname5(squadsDir));
+  }
+  return process.cwd();
+}
+var TONIGHT_STATE_FILE = ".agents/tonight-state.json";
+var TONIGHT_LOG_DIR = ".agents/outputs/tonight";
+async function getCurrentCost() {
+  try {
+    const response = await fetch("http://localhost:8088/api/stats/today");
+    if (response.ok) {
+      const data = await response.json();
+      return data.cost_usd || 0;
+    }
+  } catch {
+  }
+  return 0;
+}
+function killAllSessions() {
+  try {
+    const sessions2 = execSync14('tmux ls 2>/dev/null | grep "squads-tonight-" | cut -d: -f1', { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    for (const session2 of sessions2) {
+      try {
+        execSync14(`tmux kill-session -t "${session2}"`, { stdio: "ignore" });
+      } catch {
+      }
+    }
+    return sessions2.length;
+  } catch {
+    return 0;
+  }
+}
+function getRunningSessionCount() {
+  try {
+    const output = execSync14('tmux ls 2>/dev/null | grep "squads-tonight-" | wc -l', { encoding: "utf-8" });
+    return parseInt(output.trim()) || 0;
+  } catch {
+    return 0;
+  }
+}
+function launchAgent(target, projectRoot, sessionId, logFile) {
+  const sessionName = `squads-tonight-${sessionId}`;
+  const claudeCmd = [
+    `cd '${projectRoot}'`,
+    `echo "=== Tonight Session: ${target} ===" >> '${logFile}'`,
+    `echo "Started: $(date)" >> '${logFile}'`,
+    `claude --dangerously-skip-permissions -p 'You are running as part of an overnight autonomous session. Execute your tasks efficiently. If you encounter errors, document them clearly and move on. Do not ask for user input.' -- "Run squad: ${target}" 2>&1 | tee -a '${logFile}'`,
+    `echo "Ended: $(date)" >> '${logFile}'`
+  ].join(" && ");
+  spawn7("tmux", [
+    "new-session",
+    "-d",
+    "-s",
+    sessionName,
+    "-x",
+    "200",
+    "-y",
+    "50",
+    "/bin/sh",
+    "-c",
+    claudeCmd
+  ], {
+    stdio: "ignore",
+    detached: true
+  }).unref();
+  return sessionName;
+}
+async function generateReport(state, projectRoot) {
+  const duration = Math.round((Date.now() - new Date(state.startedAt).getTime()) / 1e3 / 60);
+  const completed = state.sessions.filter((s) => s.status === "completed").length;
+  const failed = state.sessions.filter((s) => s.status === "failed").length;
+  const report = `# Tonight Report - ${(/* @__PURE__ */ new Date()).toLocaleDateString()}
+
+## Summary
+- **Duration**: ${duration} minutes
+- **Total Cost**: $${state.totalCost.toFixed(2)} / $${state.costCap} cap
+- **Sessions**: ${completed} completed, ${failed} failed, ${state.sessions.length} total
+- **Stopped**: ${state.stoppedReason || "All tasks completed"}
+
+## Sessions
+
+| Target | Status | Restarts | Duration |
+|--------|--------|----------|----------|
+${state.sessions.map((s) => {
+    const dur = s.startedAt ? Math.round((Date.now() - new Date(s.startedAt).getTime()) / 1e3 / 60) : 0;
+    return `| ${s.target} | ${s.status} | ${s.restarts} | ${dur}min |`;
+  }).join("\n")}
+
+## Logs
+See \`.agents/outputs/tonight/\` for detailed logs.
+
+---
+*Generated by squads tonight*
+`;
+  const reportPath = path2.join(projectRoot, TONIGHT_LOG_DIR, `report-${Date.now()}.md`);
+  await fs2.writeFile(reportPath, report);
+  return reportPath;
+}
+async function tonightCommand(targets, options) {
+  const costCap = options.costCap ?? 50;
+  const stopAt = options.stopAt ?? "07:00";
+  const maxRetries = options.maxRetries ?? 3;
+  const dryRun = options.dryRun ?? false;
+  const verbose = options.verbose ?? false;
+  writeLine();
+  writeLine(`  ${bold}squads tonight${RESET}`);
+  writeLine();
+  const projectRoot = getProjectRoot2();
+  if (targets.length === 0) {
+    writeLine(`  ${colors.red}\u2716${RESET} No targets specified`);
+    writeLine();
+    writeLine(`  ${colors.dim}Usage: squads tonight <squad> [squad/agent...]${RESET}`);
+    writeLine(`  ${colors.dim}Example: squads tonight intelligence customer/outreach${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.dim}Config:${RESET}`);
+  writeLine(`    Cost cap:    ${colors.cyan}$${costCap}${RESET}`);
+  writeLine(`    Stop at:     ${colors.cyan}${stopAt}${RESET}`);
+  writeLine(`    Max retries: ${colors.cyan}${maxRetries}${RESET}`);
+  writeLine(`    Targets:     ${colors.cyan}${targets.join(", ")}${RESET}`);
+  writeLine();
+  if (dryRun) {
+    writeLine(`  ${colors.yellow}DRY RUN${RESET} - would launch:`);
+    for (const target of targets) {
+      writeLine(`    \u2022 ${target}`);
+    }
+    writeLine();
+    return;
+  }
+  const logDir = path2.join(projectRoot, TONIGHT_LOG_DIR);
+  await fs2.mkdir(logDir, { recursive: true });
+  const state = {
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stopAt,
+    costCap,
+    maxRetries,
+    sessions: [],
+    totalCost: await getCurrentCost(),
+    stopped: false
+  };
+  const spinner = ora6("Launching agents...").start();
+  for (const target of targets) {
+    const sessionId = `${target.replace("/", "-")}-${Date.now()}`;
+    const logFile = path2.join(logDir, `${sessionId}.log`);
+    const tmuxSession = launchAgent(target, projectRoot, sessionId, logFile);
+    state.sessions.push({
+      id: sessionId,
+      target,
+      tmuxSession,
+      startedAt: /* @__PURE__ */ new Date(),
+      status: "running",
+      restarts: 0
+    });
+  }
+  spinner.succeed(`Launched ${targets.length} agent(s)`);
+  await fs2.writeFile(
+    path2.join(projectRoot, TONIGHT_STATE_FILE),
+    JSON.stringify(state, null, 2)
+  );
+  await track(Events.CLI_TONIGHT, {
+    targets: targets.length,
+    costCap,
+    stopAt
+  });
+  writeLine();
+  writeLine(`  ${colors.green}\u2713${RESET} Tonight mode active`);
+  writeLine();
+  writeLine(`  ${colors.dim}Monitor:${RESET}`);
+  writeLine(`    ${colors.cyan}squads tonight status${RESET}  - Check progress`);
+  writeLine(`    ${colors.cyan}squads tonight stop${RESET}    - Kill all agents`);
+  writeLine(`    ${colors.cyan}tmux ls | grep tonight${RESET} - List sessions`);
+  writeLine();
+  writeLine(`  ${colors.dim}Logs: ${logDir}${RESET}`);
+  writeLine();
+  const watcherCmd = `
+    while true; do
+      sleep 60
+      # Check cost
+      COST=$(curl -s http://localhost:8088/api/stats/today 2>/dev/null | jq -r '.cost_usd // 0')
+      if [ "$(echo "$COST >= ${costCap}" | bc)" -eq 1 ]; then
+        echo "Cost cap reached: $COST" >> '${logDir}/watcher.log'
+        tmux ls 2>/dev/null | grep squads-tonight | cut -d: -f1 | xargs -I{} tmux kill-session -t {}
+        break
+      fi
+      # Check time
+      HOUR=$(date +%H)
+      MIN=$(date +%M)
+      STOP_HOUR=${stopAt.split(":")[0]}
+      STOP_MIN=${stopAt.split(":")[1]}
+      if [ "$HOUR" -ge "$STOP_HOUR" ] && [ "$MIN" -ge "$STOP_MIN" ]; then
+        echo "Stop time reached" >> '${logDir}/watcher.log'
+        tmux ls 2>/dev/null | grep squads-tonight | cut -d: -f1 | xargs -I{} tmux kill-session -t {}
+        break
+      fi
+      # Check if any sessions still running
+      COUNT=$(tmux ls 2>/dev/null | grep squads-tonight | wc -l)
+      if [ "$COUNT" -eq 0 ]; then
+        echo "All sessions completed" >> '${logDir}/watcher.log'
+        break
+      fi
+    done
+  `;
+  spawn7("tmux", [
+    "new-session",
+    "-d",
+    "-s",
+    "squads-tonight-watcher",
+    "/bin/sh",
+    "-c",
+    watcherCmd
+  ], {
+    stdio: "ignore",
+    detached: true
+  }).unref();
+  if (verbose) {
+    writeLine(`  ${colors.dim}Watcher session started${RESET}`);
+  }
+}
+async function tonightStatusCommand() {
+  writeLine();
+  writeLine(`  ${bold}Tonight Status${RESET}`);
+  writeLine();
+  const projectRoot = getProjectRoot2();
+  const statePath = path2.join(projectRoot, TONIGHT_STATE_FILE);
+  let state = null;
+  try {
+    const content = await fs2.readFile(statePath, "utf-8");
+    state = JSON.parse(content);
+  } catch {
+  }
+  const running = getRunningSessionCount();
+  const cost = await getCurrentCost();
+  if (running === 0 && !state) {
+    writeLine(`  ${colors.dim}No tonight session active${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Start with: squads tonight <squad> [squad...]${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${running}${RESET} agents running`);
+  if (state) {
+    const duration = Math.round((Date.now() - new Date(state.startedAt).getTime()) / 1e3 / 60);
+    writeLine(`  ${colors.dim}Duration:${RESET} ${duration} minutes`);
+    writeLine(`  ${colors.dim}Cost:${RESET} $${cost.toFixed(2)} / $${state.costCap} cap`);
+    writeLine(`  ${colors.dim}Stop at:${RESET} ${state.stopAt}`);
+  }
+  writeLine();
+  try {
+    const sessions2 = execSync14("tmux ls 2>/dev/null | grep squads-tonight", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    if (sessions2.length > 0) {
+      writeLine(`  ${colors.dim}Sessions:${RESET}`);
+      for (const session2 of sessions2) {
+        const name = session2.split(":")[0];
+        writeLine(`    \u2022 ${name}`);
+      }
+      writeLine();
+      writeLine(`  ${colors.dim}Attach: tmux attach -t <session>${RESET}`);
+    }
+  } catch {
+  }
+  writeLine();
+}
+async function tonightStopCommand() {
+  writeLine();
+  writeLine(`  ${bold}Stopping Tonight Mode${RESET}`);
+  writeLine();
+  const killed = killAllSessions();
+  if (killed > 0) {
+    writeLine(`  ${colors.green}\u2713${RESET} Killed ${killed} session(s)`);
+  } else {
+    writeLine(`  ${colors.dim}No sessions to kill${RESET}`);
+  }
+  const projectRoot = getProjectRoot2();
+  const statePath = path2.join(projectRoot, TONIGHT_STATE_FILE);
+  try {
+    const content = await fs2.readFile(statePath, "utf-8");
+    const state = JSON.parse(content);
+    state.stopped = true;
+    state.stoppedReason = "Manual stop";
+    state.totalCost = await getCurrentCost();
+    const reportPath = await generateReport(state, projectRoot);
+    writeLine(`  ${colors.green}\u2713${RESET} Report: ${reportPath}`);
+    await fs2.unlink(statePath).catch(() => {
+    });
+  } catch {
+  }
+  writeLine();
+}
+async function tonightReportCommand() {
+  writeLine();
+  writeLine(`  ${bold}Tonight Report${RESET}`);
+  writeLine();
+  const projectRoot = getProjectRoot2();
+  const logDir = path2.join(projectRoot, TONIGHT_LOG_DIR);
+  try {
+    const files = await fs2.readdir(logDir);
+    const reports = files.filter((f) => f.startsWith("report-")).sort().reverse();
+    if (reports.length === 0) {
+      writeLine(`  ${colors.dim}No reports found${RESET}`);
+      writeLine();
+      return;
+    }
+    const latest = reports[0];
+    const content = await fs2.readFile(path2.join(logDir, latest), "utf-8");
+    writeLine(content);
+  } catch {
+    writeLine(`  ${colors.dim}No reports found${RESET}`);
+  }
+  writeLine();
+}
+
 // src/cli.ts
+if (!process.stdout.isTTY) {
+  chalk4.level = 0;
+}
 var envPaths = [
-  join15(process.cwd(), ".env"),
-  join15(process.cwd(), "..", "hq", ".env"),
-  join15(homedir6(), "agents-squads", "hq", ".env")
+  join17(process.cwd(), ".env"),
+  join17(process.cwd(), "..", "hq", ".env"),
+  join17(homedir6(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync15(envPath)) {
+  if (existsSync17(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
@@ -5689,9 +8171,19 @@ for (const envPath of envPaths) {
 applyStackConfig();
 registerExitHandler();
 var program = new Command();
-program.name("squads").description("A CLI for humans and agents").version(version);
-program.command("init").description("Initialize a new squad project").option("-t, --template <template>", "Project template", "default").action(initCommand);
-program.command("run <target>").description("Run a squad or agent").option("-v, --verbose", "Verbose output").option("-d, --dry-run", "Show what would be run without executing").option("-e, --execute", "Execute agent via Claude CLI (requires claude installed)").option("-a, --agent <agent>", "Run specific agent within squad").option("-t, --timeout <minutes>", "Execution timeout in minutes (default: 30)", "30").action((target, options) => runCommand(target, { ...options, timeout: parseInt(options.timeout, 10) }));
+program.name("squads").description("A CLI for humans and agents").version(version).showSuggestionAfterError(true).configureOutput({
+  outputError: (str, write) => write(str)
+}).exitOverride((err) => {
+  if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+    process.exit(0);
+  }
+  if (err.exitCode !== void 0) {
+    process.exit(err.exitCode);
+  }
+  throw err;
+});
+program.command("init").description("Initialize a new squad project").option("-t, --template <template>", "Project template", "default").option("--skip-infra", "Skip infrastructure setup prompt").action(initCommand);
+program.command("run <target>").description("Run a squad or agent").option("-v, --verbose", "Verbose output").option("-d, --dry-run", "Show what would be run without executing").option("-e, --execute", "Execute agent via Claude CLI (requires claude installed)").option("-a, --agent <agent>", "Run specific agent within squad").option("-t, --timeout <minutes>", "Execution timeout in minutes (default: 30)", "30").option("-p, --parallel", "Run all agents in parallel (N tmux sessions)").option("-l, --lead", "Lead mode: single orchestrator using Task tool for parallelization").option("-f, --foreground", "Run in foreground (no tmux, blocks terminal)").option("--use-api", "Use API credits instead of subscription").action((target, options) => runCommand(target, { ...options, timeout: parseInt(options.timeout, 10) }));
 program.command("list").description("List agents and squads").option("-s, --squads", "List squads only").option("-a, --agents", "List agents only").action(listCommand);
 program.command("status [squad]").description("Show squad status and state").option("-v, --verbose", "Show detailed status").action(statusCommand);
 program.command("dashboard").alias("dash").description("Show comprehensive goals and metrics dashboard").option("-v, --verbose", "Show additional details").option("-c, --ceo", "Executive summary with priorities and blockers").option("-f, --full", "Include GitHub PR/issue stats (slower, ~30s)").action((options) => dashboardCommand({ ...options, fast: !options.full }));
@@ -5702,8 +8194,19 @@ var progress = program.command("progress").description("Track active and complet
 progress.command("start <squad> <description>").description("Register a new active task").action(progressStartCommand);
 progress.command("complete <taskId>").description("Mark a task as completed").option("-f, --failed", "Mark as failed instead").action(progressCompleteCommand);
 program.command("results [squad]").description("Show squad results: git activity + KPI goals vs actuals").option("-d, --days <days>", "Days to look back", "7").option("-v, --verbose", "Show detailed KPIs per goal").action((squad, options) => resultsCommand({ ...options, squad }));
+program.command("history").description("Show recent agent execution history").option("-d, --days <days>", "Days to look back", "7").option("-s, --squad <squad>", "Filter by squad").option("-v, --verbose", "Show cost and token details").option("-j, --json", "Output as JSON").action((options) => historyCommand(options));
+program.command("context-feed").alias("feed").description("Context feed for agents: goals, memory, costs, activity").option("-s, --squad <squad>", "Focus on specific squad").option("-t, --topic <topic>", "Search memory for relevant context").option("-a, --agent", "Output JSON for agent consumption").option("-j, --json", "Output as JSON (alias for --agent)").option("-v, --verbose", "Show additional details").action((options) => contextFeedCommand(options));
 program.command("workers").description("Show active workers: Claude sessions, tasks, dev servers").option("-v, --verbose", "Show more details").option("-k, --kill <pid>", "Kill a process by PID").action(workersCommand);
-var memory = program.command("memory").description("Query and manage squad memory");
+program.command("health").description("Quick health check for all infrastructure services").option("-v, --verbose", "Show optional services").action((options) => healthCommand(options));
+program.command("watch <command> [args...]").description("Live refresh any squads command (like Unix watch)").option("-n, --interval <seconds>", "Refresh interval in seconds", "2").option("--no-clear", "Don't clear screen between refreshes").action((command, args, options) => watchCommand(command, args, {
+  interval: parseInt(options.interval, 10),
+  clear: options.clear
+}));
+program.command("live").description("Live TUI dashboard with real-time metrics (like htop)").option("-m, --minimal", "Minimal view").option("-f, --focus <panel>", "Focus on specific panel (agents, cost, activity, memory)").action((options) => liveCommand(options));
+program.command("top").description("Live process table (like Unix top) - numbers update in place").action(() => topCommand());
+var memory = program.command("memory").description("Query and manage squad memory").action(() => {
+  memory.outputHelp();
+});
 memory.command("query <query>").description("Search across all squad memory").option("-s, --squad <squad>", "Limit search to specific squad").option("-a, --agent <agent>", "Limit search to specific agent").action(memoryQueryCommand);
 memory.command("show <squad>").description("Show memory for a squad").action(memoryShowCommand);
 memory.command("update <squad> <content>").description("Add to squad memory").option("-a, --agent <agent>", "Specific agent (default: squad-lead)").option("-t, --type <type>", "Memory type: state, learnings, feedback", "learnings").action(memoryUpdateCommand);
@@ -5719,7 +8222,9 @@ memory.command("extract").description("Extract memories from recent conversation
   hours: parseInt(opts.hours, 10),
   dryRun: opts.dryRun
 }));
-var goal = program.command("goal").description("Manage squad goals");
+var goal = program.command("goal").description("Manage squad goals").action(() => {
+  goal.outputHelp();
+});
 goal.command("set <squad> <description>").description("Set a goal for a squad").option("-m, --metric <metrics...>", "Metrics to track").action(goalSetCommand);
 goal.command("list [squad]").description("List goals for squad(s)").option("-a, --all", "Show completed goals too").action(goalListCommand);
 goal.command("complete <squad> <index>").description("Mark a goal as completed").action(goalCompleteCommand);
@@ -5735,11 +8240,11 @@ sessions.command("history").description("Show session history and statistics").o
   json: options.json
 }));
 sessions.command("summary").description("Show pretty session summary (auto-detects current session or pass JSON)").option("-d, --data <json>", "JSON data for summary (overrides auto-detection)").option("-f, --file <path>", "Path to JSON file with summary data").option("-j, --json", "Output as JSON instead of pretty format").action(async (options) => {
-  const { buildCurrentSessionSummary } = await import("./sessions-UR3YGSLR.js");
+  const { buildCurrentSessionSummary } = await import("./sessions-JCQ34BEU.js");
   let data;
   if (options.file) {
-    const { readFileSync: readFileSync12 } = await import("fs");
-    data = JSON.parse(readFileSync12(options.file, "utf-8"));
+    const { readFileSync: readFileSync13 } = await import("fs");
+    data = JSON.parse(readFileSync13(options.file, "utf-8"));
   } else if (options.data) {
     data = JSON.parse(options.data);
   } else if (!process.stdin.isTTY) {
@@ -5772,11 +8277,67 @@ stack.command("down").description("Stop Docker containers").action(stackDownComm
 stack.command("health").description("Comprehensive health check with diagnostics").option("-v, --verbose", "Show logs for unhealthy services").action((options) => stackHealthCommand(options.verbose));
 stack.command("logs <service>").description("Show logs for a service (postgres, redis, neo4j, bridge, langfuse, mem0, engram)").option("-n, --tail <lines>", "Number of lines to show", "50").action((service, options) => stackLogsCommand(service, parseInt(options.tail, 10)));
 registerTriggerCommand(program);
+var tonight = program.command("tonight").description("Run agents autonomously overnight with safety limits");
+tonight.command("run <targets...>").description("Start tonight mode with specified squads/agents").option("-c, --cost-cap <usd>", "Max USD to spend (default: 50)", "50").option("-s, --stop-at <time>", "Stop time HH:MM (default: 07:00)", "07:00").option("-r, --max-retries <n>", "Max restarts per agent (default: 3)", "3").option("-d, --dry-run", "Show what would run without executing").option("-v, --verbose", "Verbose output").action((targets, options) => tonightCommand(targets, {
+  costCap: parseFloat(options.costCap),
+  stopAt: options.stopAt,
+  maxRetries: parseInt(options.maxRetries, 10),
+  dryRun: options.dryRun,
+  verbose: options.verbose
+}));
+tonight.command("status").description("Check tonight mode status").action(tonightStatusCommand);
+tonight.command("stop").description("Stop all tonight agents and generate report").action(tonightStopCommand);
+tonight.command("report").description("Show latest tonight report").action(tonightReportCommand);
 program.command("login").description("Log in to Squads (Pro & Enterprise)").action(loginCommand);
 program.command("logout").description("Log out from Squads").action(logoutCommand);
 program.command("whoami").description("Show current logged in user").action(whoamiCommand);
 program.command("update").description("Check for and install updates").option("-y, --yes", "Auto-confirm update without prompting").option("-c, --check", "Check for updates without installing").action((options) => updateCommand(options));
-await program.parseAsync();
+program.command("version").description("Show version information").action(() => {
+  console.log(`squads-cli ${version}`);
+});
+function handleError(error) {
+  const err = error instanceof Error ? error : new Error(String(error));
+  if (err.message.includes("ECONNREFUSED") || err.message.includes("fetch failed")) {
+    console.error(chalk4.red("\nConnection error:"), err.message);
+    console.error(chalk4.dim("\nPossible fixes:"));
+    console.error(chalk4.dim("  1. Check if Docker containers are running: squads stack status"));
+    console.error(chalk4.dim("  2. Start the stack: squads stack up"));
+    console.error(chalk4.dim("  3. Check your network connection"));
+  } else if (err.message.includes("ENOENT")) {
+    console.error(chalk4.red("\nFile not found:"), err.message);
+    console.error(chalk4.dim("\nPossible fixes:"));
+    console.error(chalk4.dim("  1. Make sure you are in the correct directory"));
+    console.error(chalk4.dim("  2. Initialize the project: squads init"));
+  } else if (err.message.includes("permission denied") || err.message.includes("EACCES")) {
+    console.error(chalk4.red("\nPermission denied:"), err.message);
+    console.error(chalk4.dim("\nPossible fixes:"));
+    console.error(chalk4.dim("  1. Check file permissions"));
+    console.error(chalk4.dim("  2. Avoid running with sudo if not needed"));
+  } else if (err.message.includes("rate limit") || err.message.includes("429")) {
+    console.error(chalk4.red("\nRate limit exceeded"));
+    console.error(chalk4.dim("\nPossible fixes:"));
+    console.error(chalk4.dim("  1. Wait a few minutes and try again"));
+    console.error(chalk4.dim("  2. Check your API usage: squads dash"));
+  } else {
+    console.error(chalk4.red("\nError:"), err.message);
+    if (process.env.DEBUG || process.env.VERBOSE) {
+      console.error(chalk4.dim("\nStack trace:"));
+      console.error(chalk4.dim(err.stack));
+    } else {
+      console.error(chalk4.dim("\nRun with DEBUG=1 for more details"));
+    }
+  }
+  console.error(chalk4.dim("\nIf this persists, please report at:"));
+  console.error(chalk4.cyan("  https://github.com/agents-squads/squads-cli/issues\n"));
+  process.exit(1);
+}
+process.on("uncaughtException", handleError);
+process.on("unhandledRejection", handleError);
+try {
+  await program.parseAsync();
+} catch (error) {
+  handleError(error);
+}
 if (!process.argv.slice(2).length) {
   console.log(`
 ${chalk4.bold.magenta("squads")} - AI agent squad management