squads-cli 0.1.2 → 0.2.0

package/dist/cli.js

@@ -8,9 +8,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync14 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir6 } from "os";
 import { Command } from "commander";
 import chalk3 from "chalk";
 
@@ -100,7 +100,7 @@ var SQUAD_LABELS = {
   company: ["company", "strategy"],
   marketing: ["marketing", "content", "seo"]
 };
-function getGitHubStats(basePath, days = 30) {
+function getGitHubStatsOptimized(basePath, days = 30) {
   const stats = {
     prsOpened: 0,
     prsMerged: 0,
@@ -121,74 +121,81 @@ function getGitHubStats(basePath, days = 30) {
   }
   const repos = ["hq", "agents-squads-web"];
   const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+  const results = [];
   for (const repo of repos) {
     const repoPath = join(basePath, repo);
     if (!existsSync(repoPath)) continue;
     try {
-      const prsOutput = execSync(
-        `gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 100 2>/dev/null`,
-        { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      const output = execSync(
+        `echo '{"prs":' && gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 50 2>/dev/null && echo ',"issues":' && gh issue list --state all --json number,title,state,closedAt,labels --limit 50 2>/dev/null && echo '}'`,
+        { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 1e4 }
       );
-      const prs = JSON.parse(prsOutput || "[]");
-      for (const pr of prs) {
-        const created = new Date(pr.createdAt);
-        if (created < new Date(since)) continue;
-        stats.prsOpened++;
-        if (pr.mergedAt) stats.prsMerged++;
-        const squad = detectSquadFromPR(pr, repo);
-        const squadStats = stats.bySquad.get(squad);
-        if (squadStats) {
-          squadStats.prsOpened++;
-          if (pr.mergedAt) squadStats.prsMerged++;
-          if (squadStats.recentPRs.length < 3) {
-            squadStats.recentPRs.push({
-              title: pr.title,
-              number: pr.number,
-              merged: !!pr.mergedAt
-            });
-          }
+      const prsMatch = output.match(/"prs":(\[.*?\]),"issues":/s);
+      const issuesMatch = output.match(/"issues":(\[.*?\])\s*\}/s);
+      const prs = prsMatch ? JSON.parse(prsMatch[1]) : [];
+      const issues = issuesMatch ? JSON.parse(issuesMatch[1]) : [];
+      results.push({ repo, prs, issues });
+    } catch {
+      try {
+        const prsOutput = execSync(
+          `gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 50 2>/dev/null`,
+          { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+        );
+        const issuesOutput = execSync(
+          `gh issue list --state all --json number,title,state,closedAt,labels --limit 50 2>/dev/null`,
+          { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+        );
+        results.push({
+          repo,
+          prs: JSON.parse(prsOutput || "[]"),
+          issues: JSON.parse(issuesOutput || "[]")
+        });
+      } catch {
+      }
+    }
+  }
+  for (const { repo, prs, issues } of results) {
+    for (const pr of prs) {
+      const created = new Date(pr.createdAt);
+      if (created < new Date(since)) continue;
+      stats.prsOpened++;
+      if (pr.mergedAt) stats.prsMerged++;
+      const squad = detectSquadFromPR(pr, repo);
+      const squadStats = stats.bySquad.get(squad);
+      if (squadStats) {
+        squadStats.prsOpened++;
+        if (pr.mergedAt) squadStats.prsMerged++;
+        if (squadStats.recentPRs.length < 3) {
+          squadStats.recentPRs.push({
+            title: pr.title,
+            number: pr.number,
+            merged: !!pr.mergedAt
+          });
         }
       }
-      const issuesOutput = execSync(
-        `gh issue list --state all --json number,title,state,closedAt,labels --limit 100 2>/dev/null`,
-        { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-      );
-      const issues = JSON.parse(issuesOutput || "[]");
-      for (const issue of issues) {
-        const squad = detectSquadFromIssue(issue, repo);
-        const squadStats = stats.bySquad.get(squad);
-        if (issue.state === "CLOSED") {
-          const closed = new Date(issue.closedAt);
-          if (closed >= new Date(since)) {
-            stats.issuesClosed++;
-            if (squadStats) {
-              squadStats.issuesClosed++;
-            }
-          }
-        } else {
-          stats.issuesOpen++;
+    }
+    for (const issue of issues) {
+      const squad = detectSquadFromIssue(issue, repo);
+      const squadStats = stats.bySquad.get(squad);
+      if (issue.state === "CLOSED") {
+        const closed = new Date(issue.closedAt || 0);
+        if (closed >= new Date(since)) {
+          stats.issuesClosed++;
           if (squadStats) {
-            squadStats.issuesOpen++;
-            if (squadStats.recentIssues.length < 3) {
-              squadStats.recentIssues.push({
-                title: issue.title,
-                number: issue.number,
-                state: issue.state
-              });
-            }
+            squadStats.issuesClosed++;
           }
         }
-      }
-    } catch {
-    }
-  }
-  const gitStats = getMultiRepoGitStats(basePath, days);
-  for (const [repo, commits] of gitStats.commitsByRepo) {
-    for (const [squad, repos2] of Object.entries(SQUAD_REPO_MAP)) {
-      if (repos2.includes(repo)) {
-        const squadStats = stats.bySquad.get(squad);
+      } else {
+        stats.issuesOpen++;
         if (squadStats) {
-          squadStats.commits += commits;
+          squadStats.issuesOpen++;
+          if (squadStats.recentIssues.length < 3) {
+            squadStats.recentIssues.push({
+              title: issue.title,
+              number: issue.number,
+              state: issue.state
+            });
+          }
         }
       }
     }
@@ -341,7 +348,8 @@ import { randomUUID } from "crypto";
 var TELEMETRY_DIR = join2(homedir(), ".squads-cli");
 var CONFIG_PATH = join2(TELEMETRY_DIR, "telemetry.json");
 var EVENTS_PATH = join2(TELEMETRY_DIR, "events.json");
-var TELEMETRY_ENDPOINT = process.env.SQUADS_TELEMETRY_URL || (process.env.SQUADS_BRIDGE_URL ? `${process.env.SQUADS_BRIDGE_URL}/api/telemetry` : null);
+var DEFAULT_TELEMETRY_ENDPOINT = "https://qzayrjwxiznkqfvmjxyy.supabase.co/functions/v1/telemetry-ingest";
+var TELEMETRY_ENDPOINT = process.env.SQUADS_TELEMETRY_URL || (process.env.SQUADS_BRIDGE_URL ? `${process.env.SQUADS_BRIDGE_URL}/api/telemetry` : DEFAULT_TELEMETRY_ENDPOINT);
 var eventQueue = [];
 var flushScheduled = false;
 function ensureDir() {
@@ -1428,22 +1436,32 @@ async function runSquad(squad, squadsDir, options) {
       }
     }
   } else {
-    const orchestrator = squad.agents.find(
-      (a) => a.name.includes("lead") || a.trigger === "Manual"
-    );
-    if (orchestrator) {
-      const agentPath = join5(squadsDir, squad.name, `${orchestrator.name}.md`);
+    if (options.agent) {
+      const agentPath = join5(squadsDir, squad.name, `${options.agent}.md`);
       if (existsSync5(agentPath)) {
-        await runAgent(orchestrator.name, agentPath, squad.name, options);
+        await runAgent(options.agent, agentPath, squad.name, options);
+      } else {
+        writeLine(`  ${icons.error} ${colors.red}Agent ${options.agent} not found${RESET}`);
+        return;
       }
     } else {
-      writeLine(`  ${colors.dim}No pipeline defined. Available agents:${RESET}`);
-      for (const agent of squad.agents) {
-        writeLine(`  ${icons.empty} ${colors.cyan}${agent.name}${RESET} ${colors.dim}${agent.role}${RESET}`);
+      const orchestrator = squad.agents.find(
+        (a) => a.name.includes("lead") || a.trigger === "Manual"
+      );
+      if (orchestrator) {
+        const agentPath = join5(squadsDir, squad.name, `${orchestrator.name}.md`);
+        if (existsSync5(agentPath)) {
+          await runAgent(orchestrator.name, agentPath, squad.name, options);
+        }
+      } else {
+        writeLine(`  ${colors.dim}No pipeline defined. Available agents:${RESET}`);
+        for (const agent of squad.agents) {
+          writeLine(`  ${icons.empty} ${colors.cyan}${agent.name}${RESET} ${colors.dim}${agent.role}${RESET}`);
+        }
+        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 a specific agent:${RESET}`);
-      writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET} --agent ${colors.cyan}<name>${RESET}`);
     }
   }
   writeLine();
@@ -1485,18 +1503,16 @@ After completion:
 3. Report what was accomplished`;
   const claudeAvailable = await checkClaudeCliAvailable();
   if (options.execute && claudeAvailable) {
-    spinner.text = `Executing ${agentName} with Claude Code...`;
+    spinner.text = `Launching ${agentName} as background task...`;
     try {
-      const result = await executeWithClaude(prompt, options.verbose);
-      spinner.succeed(`Agent ${agentName} completed`);
-      updateExecutionStatus(squadName, agentName, "completed", "Executed via Claude CLI");
-      if (result) {
-        writeLine(`  ${colors.dim}Output:${RESET}`);
-        writeLine(`  ${result.slice(0, 500)}`);
-        if (result.length > 500) writeLine(`  ${colors.dim}... (truncated)${RESET}`);
-      }
+      const result = await executeWithClaude(prompt, 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}`);
     } catch (error) {
-      spinner.fail(`Agent ${agentName} failed`);
+      spinner.fail(`Agent ${agentName} failed to launch`);
       updateExecutionStatus(squadName, agentName, "failed", String(error));
       writeLine(`  ${colors.red}${String(error)}${RESET}`);
     }
@@ -1509,13 +1525,10 @@ After completion:
       writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
     }
     writeLine();
-    writeLine(`  ${colors.dim}To execute with Claude Code:${RESET}`);
-    writeLine(`  ${colors.dim}$${RESET} claude --print "${prompt.replace(/"/g, '\\"').replace(/\n/g, " ").slice(0, 80)}..."`);
-    writeLine();
-    writeLine(`  ${colors.dim}Or run with --execute flag:${RESET}`);
-    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} --execute`);
+    writeLine(`  ${colors.dim}To launch as background task:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} -a ${colors.cyan}${agentName}${RESET} --execute`);
     writeLine();
-    writeLine(`  ${colors.dim}Or in Claude Code session:${RESET}`);
+    writeLine(`  ${colors.dim}Or run interactively:${RESET}`);
     writeLine(`  ${colors.dim}$${RESET} Run the ${colors.cyan}${agentName}${RESET} agent from ${agentPath}`);
   }
 }
@@ -1526,48 +1539,51 @@ async function checkClaudeCliAvailable() {
     check.on("error", () => resolve(false));
   });
 }
-async function executeWithClaude(prompt, verbose) {
-  return new Promise((resolve, reject) => {
-    const args = ["--print", prompt];
-    if (verbose) {
-      writeLine(`  ${colors.dim}Spawning: claude ${args.slice(0, 1).join(" ")} ...${RESET}`);
-    }
-    const squadMatch = prompt.match(/squad (\w+)/);
-    const agentMatch = prompt.match(/(\w+) agent/);
-    const claude = spawn("claude", args, {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        SQUADS_SQUAD: squadMatch?.[1] || "unknown",
-        SQUADS_AGENT: agentMatch?.[1] || "unknown"
-      }
-    });
-    let output = "";
-    let error = "";
-    claude.stdout?.on("data", (data) => {
-      output += data.toString();
-      if (verbose) {
-        process.stdout.write(data.toString());
-      }
-    });
-    claude.stderr?.on("data", (data) => {
-      error += data.toString();
-    });
-    claude.on("close", (code) => {
-      if (code === 0) {
-        resolve(output);
-      } else {
-        reject(new Error(error || `Claude exited with code ${code}`));
-      }
-    });
-    claude.on("error", (err) => {
-      reject(err);
-    });
-    setTimeout(() => {
-      claude.kill();
-      reject(new Error("Execution timed out after 5 minutes"));
-    }, 5 * 60 * 1e3);
+async function executeWithClaude(prompt, verbose, timeoutMinutes = 30) {
+  const userConfigPath = join5(process.env.HOME || "", ".claude.json");
+  const squadMatch = prompt.match(/squad (\w+)/);
+  const agentMatch = prompt.match(/(\w+) agent/);
+  const squadName = squadMatch?.[1] || "unknown";
+  const agentName = agentMatch?.[1] || "unknown";
+  const timestamp = Date.now();
+  const sessionName = `squads-${squadName}-${agentName}-${timestamp}`;
+  if (verbose) {
+    writeLine(`  ${colors.dim}Spawning tmux session: ${sessionName}${RESET}`);
+  }
+  const escapedPrompt = prompt.replace(/'/g, "'\\''");
+  const claudeCmd = `claude --dangerously-skip-permissions --mcp-config '${userConfigPath}' -- '${escapedPrompt}'`;
+  const tmux = spawn("tmux", [
+    "new-session",
+    "-d",
+    // Detached
+    "-s",
+    sessionName,
+    "-x",
+    "200",
+    // Wide terminal for better output
+    "-y",
+    "50",
+    "/bin/sh",
+    "-c",
+    claudeCmd
+  ], {
+    stdio: "ignore",
+    detached: true,
+    env: {
+      ...process.env,
+      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}`);
+  }
+  return `tmux session: ${sessionName}. Attach: tmux attach -t ${sessionName}`;
 }
 
 // src/commands/list.ts
@@ -1620,139 +1636,704 @@ async function listCommand(options) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync6, statSync } from "fs";
-import { join as join6 } from "path";
-async function statusCommand(squadName, options = {}) {
-  const squadsDir = findSquadsDir();
-  if (!squadsDir) {
-    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
-    writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
-    process.exit(1);
+import { existsSync as existsSync8, statSync } from "fs";
+import { join as join8 } from "path";
+
+// src/lib/sessions.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync, appendFileSync, createReadStream } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
+import { randomBytes } from "crypto";
+import { createInterface } from "readline";
+import { execSync as execSync2 } from "child_process";
+var AI_TOOL_PATTERNS = [
+  { pattern: /^claude$/, name: "claude" },
+  { pattern: /^cursor$/i, name: "cursor" },
+  { pattern: /^aider$/, name: "aider" },
+  { pattern: /^gemini$/i, name: "gemini" },
+  { pattern: /^copilot$/i, name: "copilot" },
+  { pattern: /^cody$/i, name: "cody" },
+  { pattern: /^continue$/i, name: "continue" }
+];
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var HISTORY_FILE = "history.jsonl";
+var ACTIVE_DIR = "active";
+var SQUAD_DIR_MAP = {
+  "hq": "company",
+  "agents-squads-web": "website",
+  "company": "company",
+  "product": "product",
+  "engineering": "engineering",
+  "research": "research",
+  "intelligence": "intelligence",
+  "customer": "customer",
+  "finance": "finance",
+  "marketing": "marketing"
+};
+function findAgentsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const agentsPath = join6(dir, ".agents");
+    if (existsSync6(agentsPath)) {
+      return agentsPath;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
-  if (squadName) {
-    await showSquadStatus(squadName, squadsDir, options);
-  } else {
-    await showOverallStatus(squadsDir, options);
+  return null;
+}
+function getSessionsBaseDir() {
+  const agentsDir = findAgentsDir();
+  if (!agentsDir) return null;
+  const sessionsDir = join6(agentsDir, "sessions");
+  if (!existsSync6(sessionsDir)) {
+    mkdirSync4(sessionsDir, { recursive: true });
   }
+  return sessionsDir;
 }
-async function showOverallStatus(squadsDir, _options) {
-  const squads = listSquads(squadsDir);
-  const memoryDir = findMemoryDir();
-  writeLine();
-  writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET}`);
-  writeLine();
-  const totalSquads = squads.length;
-  const activeCount = squads.length;
-  writeLine(`  ${colors.cyan}${activeCount}${RESET}/${totalSquads} squads  ${colors.dim}\u2502${RESET}  ${colors.dim}memory: ${memoryDir ? "enabled" : "none"}${RESET}`);
-  writeLine();
-  const w = { name: 16, agents: 8, memory: 14, activity: 12 };
-  const tableWidth = w.name + w.agents + w.memory + w.activity + 6;
-  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
-  const header = `  ${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(header);
-  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
-  for (const squadName of squads) {
-    const agents = listAgents(squadsDir, squadName);
-    let memoryStatus = `${colors.dim}none${RESET}`;
-    let lastActivity = `${colors.dim}\u2014${RESET}`;
-    let activityColor = colors.dim;
-    if (memoryDir) {
-      const squadMemoryPath = join6(memoryDir, squadName);
-      if (existsSync6(squadMemoryPath)) {
-        const states = getSquadState(squadName);
-        memoryStatus = `${colors.green}${states.length} entries${RESET}`;
-        let mostRecent = 0;
-        for (const state of states) {
-          const stat = statSync(state.path);
-          if (stat.mtimeMs > mostRecent) {
-            mostRecent = stat.mtimeMs;
-          }
-        }
-        if (mostRecent > 0) {
-          const daysAgo = Math.floor((Date.now() - mostRecent) / (1e3 * 60 * 60 * 24));
-          if (daysAgo === 0) {
-            lastActivity = "today";
-            activityColor = colors.green;
-          } else if (daysAgo === 1) {
-            lastActivity = "yesterday";
-            activityColor = colors.green;
-          } else if (daysAgo < 7) {
-            lastActivity = `${daysAgo}d ago`;
-            activityColor = colors.yellow;
-          } else {
-            lastActivity = `${daysAgo}d ago`;
-            activityColor = colors.dim;
-          }
+function getSessionsDir() {
+  const baseDir = getSessionsBaseDir();
+  if (!baseDir) return null;
+  const activeDir = join6(baseDir, ACTIVE_DIR);
+  if (!existsSync6(activeDir)) {
+    mkdirSync4(activeDir, { recursive: true });
+  }
+  return activeDir;
+}
+function getHistoryFilePath() {
+  const baseDir = getSessionsBaseDir();
+  if (!baseDir) return null;
+  return join6(baseDir, HISTORY_FILE);
+}
+function appendEvent(event) {
+  const historyPath = getHistoryFilePath();
+  if (!historyPath) return;
+  try {
+    const line = JSON.stringify(event) + "\n";
+    appendFileSync(historyPath, line);
+  } catch {
+  }
+}
+function detectSquad(cwd = process.cwd()) {
+  const match = cwd.match(/agents-squads\/([^/]+)/);
+  if (match) {
+    const dir = match[1];
+    return SQUAD_DIR_MAP[dir] || dir;
+  }
+  return null;
+}
+function detectAIProcesses() {
+  const processes = [];
+  try {
+    const psOutput = execSync2("ps -eo pid,tty,comm 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    if (!psOutput) return [];
+    const lines = psOutput.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 3) continue;
+      const pid = parseInt(parts[0], 10);
+      const tty = parts[1];
+      const comm = parts.slice(2).join(" ");
+      if (isNaN(pid)) continue;
+      let toolName = null;
+      for (const { pattern, name } of AI_TOOL_PATTERNS) {
+        if (pattern.test(comm)) {
+          toolName = name;
+          break;
         }
       }
+      if (!toolName) continue;
+      let cwd = "";
+      try {
+        const lsofOutput = execSync2(`lsof -p ${pid} 2>/dev/null | grep cwd | awk '{print $NF}'`, {
+          encoding: "utf-8",
+          timeout: 3e3
+        }).trim();
+        cwd = lsofOutput || "";
+      } catch {
+        cwd = "";
+      }
+      const squad = detectSquad(cwd);
+      processes.push({
+        pid,
+        tty,
+        cwd,
+        squad,
+        tool: toolName
+      });
     }
-    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squadName, w.name)}${RESET}${padEnd(String(agents.length), w.agents)}${padEnd(memoryStatus, w.memory)}${padEnd(`${activityColor}${lastActivity}${RESET}`, w.activity)}${colors.purple}${box.vertical}${RESET}`;
-    writeLine(row);
+  } catch {
   }
-  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
-  writeLine();
-  writeLine(`  ${colors.dim}$${RESET} squads status ${colors.cyan}<squad>${RESET}    ${colors.dim}Squad details${RESET}`);
-  writeLine(`  ${colors.dim}$${RESET} squads dash             ${colors.dim}Full dashboard${RESET}`);
-  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}<squad>${RESET}       ${colors.dim}Execute a squad${RESET}`);
-  writeLine();
+  return processes;
 }
-async function showSquadStatus(squadName, squadsDir, options) {
-  const squad = loadSquad(squadName);
-  if (!squad) {
-    writeLine(`${colors.red}Squad "${squadName}" not found.${RESET}`);
-    process.exit(1);
+function getLiveSessionSummary() {
+  const processes = detectAIProcesses();
+  const bySquad = {};
+  const byTool = {};
+  for (const proc of processes) {
+    const squad = proc.squad || "unknown";
+    bySquad[squad] = (bySquad[squad] || 0) + 1;
+    byTool[proc.tool] = (byTool[proc.tool] || 0) + 1;
   }
-  writeLine();
-  writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET} ${colors.cyan}${squad.name}${RESET}`);
-  writeLine();
-  if (squad.mission) {
-    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
-    writeLine();
+  return {
+    totalSessions: processes.length,
+    bySquad,
+    squadCount: Object.keys(bySquad).length,
+    byTool
+  };
+}
+function generateSessionId() {
+  return randomBytes(8).toString("hex");
+}
+var currentSessionId = null;
+function getSessionId() {
+  if (currentSessionId) return currentSessionId;
+  const sessionsDir = getSessionsDir();
+  if (sessionsDir) {
+    const pid = process.pid;
+    const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = readFileSync5(join6(sessionsDir, file), "utf-8");
+        const session2 = JSON.parse(content);
+        if (session2.pid === pid) {
+          currentSessionId = session2.sessionId;
+          return currentSessionId;
+        }
+      } catch {
+      }
+    }
   }
-  const agents = listAgents(squadsDir, squadName);
-  const w = { name: 24, role: 36 };
-  const tableWidth = w.name + w.role + 4;
-  writeLine(`  ${bold}Agents${RESET} ${colors.dim}(${agents.length})${RESET}`);
-  writeLine();
-  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
-  for (const agent of agents) {
-    const status = agent.status?.toLowerCase() === "active" ? icons.active : icons.pending;
-    const role = options.verbose && agent.role ? `${colors.dim}${agent.role.substring(0, w.role - 2)}${RESET}` : "";
-    const row = `  ${colors.purple}${box.vertical}${RESET} ${status} ${padEnd(agent.name, w.name - 2)}${padEnd(role, w.role)}${colors.purple}${box.vertical}${RESET}`;
-    writeLine(row);
+  currentSessionId = generateSessionId();
+  return currentSessionId;
+}
+function startSession(squad) {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return null;
+  const sessionId = getSessionId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cwd = process.cwd();
+  const detectedSquad = squad || detectSquad(cwd);
+  const session2 = {
+    sessionId,
+    squad: detectedSquad,
+    startedAt: now,
+    lastHeartbeat: now,
+    cwd,
+    pid: process.pid
+  };
+  const sessionPath = join6(sessionsDir, `${sessionId}.json`);
+  writeFileSync5(sessionPath, JSON.stringify(session2, null, 2));
+  appendEvent({
+    type: "start",
+    sessionId,
+    squad: detectedSquad,
+    ts: now,
+    cwd,
+    pid: process.pid
+  });
+  return session2;
+}
+function updateHeartbeat() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return false;
+  const sessionId = getSessionId();
+  const sessionPath = join6(sessionsDir, `${sessionId}.json`);
+  if (!existsSync6(sessionPath)) {
+    startSession();
+    return true;
   }
-  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
-  if (squad.pipelines.length > 0) {
-    writeLine();
-    writeLine(`  ${bold}Pipelines${RESET}`);
-    for (const pipeline of squad.pipelines) {
-      writeLine(`  ${colors.dim}${pipeline.agents.join(" \u2192 ")}${RESET}`);
+  try {
+    const content = readFileSync5(sessionPath, "utf-8");
+    const session2 = JSON.parse(content);
+    session2.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+    writeFileSync5(sessionPath, JSON.stringify(session2, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stopSession() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return false;
+  const sessionId = getSessionId();
+  const sessionPath = join6(sessionsDir, `${sessionId}.json`);
+  if (existsSync6(sessionPath)) {
+    let squad = null;
+    let durationMs;
+    try {
+      const content = readFileSync5(sessionPath, "utf-8");
+      const session2 = JSON.parse(content);
+      squad = session2.squad;
+      durationMs = Date.now() - new Date(session2.startedAt).getTime();
+    } catch {
     }
+    unlinkSync(sessionPath);
+    currentSessionId = null;
+    appendEvent({
+      type: "stop",
+      sessionId,
+      squad,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs
+    });
+    return true;
   }
-  const memoryDir = findMemoryDir();
-  if (memoryDir) {
-    const states = getSquadState(squadName);
-    if (states.length > 0) {
-      writeLine();
-      writeLine(`  ${bold}Memory${RESET} ${colors.dim}(${states.length} entries)${RESET}`);
-      writeLine();
-      for (const state of states) {
-        const updated = state.content.match(/Updated:\s*(\S+)/)?.[1] || "unknown";
-        writeLine(`  ${icons.progress} ${colors.white}${state.agent}${RESET}`);
-        writeLine(`    ${colors.dim}\u2514 updated: ${updated}${RESET}`);
-        if (options.verbose) {
-          const signalsMatch = state.content.match(/## Active Signals([\s\S]*?)(?=##|$)/);
-          if (signalsMatch) {
-            const signalLines = signalsMatch[1].split("\n").filter((l) => l.match(/^\d+\./)).slice(0, 3);
-            for (const sig of signalLines) {
-              writeLine(`    ${colors.dim}  ${sig.trim()}${RESET}`);
-            }
-          }
+  return false;
+}
+function getActiveSessions() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return [];
+  const now = Date.now();
+  const sessions2 = [];
+  try {
+    const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join6(sessionsDir, file);
+        const content = readFileSync5(filePath, "utf-8");
+        const session2 = JSON.parse(content);
+        const lastHeartbeat = new Date(session2.lastHeartbeat).getTime();
+        if (now - lastHeartbeat < STALE_THRESHOLD_MS) {
+          sessions2.push(session2);
         }
+      } catch {
       }
     }
+  } catch {
   }
-  writeLine();
+  return sessions2;
+}
+function getSessionSummary() {
+  const sessions2 = getActiveSessions();
+  const bySquad = {};
+  for (const session2 of sessions2) {
+    const squad = session2.squad || "unknown";
+    bySquad[squad] = (bySquad[squad] || 0) + 1;
+  }
+  return {
+    totalSessions: sessions2.length,
+    bySquad,
+    squadCount: Object.keys(bySquad).length
+  };
+}
+function cleanupStaleSessions() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return 0;
+  const now = Date.now();
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  let cleaned = 0;
+  try {
+    const files = readdirSync3(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join6(sessionsDir, file);
+        const content = readFileSync5(filePath, "utf-8");
+        const session2 = JSON.parse(content);
+        const lastHeartbeat = new Date(session2.lastHeartbeat).getTime();
+        if (now - lastHeartbeat >= STALE_THRESHOLD_MS) {
+          const durationMs = now - new Date(session2.startedAt).getTime();
+          unlinkSync(filePath);
+          cleaned++;
+          appendEvent({
+            type: "stale_cleanup",
+            sessionId: session2.sessionId,
+            squad: session2.squad,
+            ts: nowIso,
+            durationMs
+          });
+        }
+      } catch {
+        try {
+          unlinkSync(join6(sessionsDir, file));
+          cleaned++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+async function readSessionHistory(options = {}) {
+  const historyPath = getHistoryFilePath();
+  if (!historyPath || !existsSync6(historyPath)) return [];
+  const events = [];
+  const sinceMs = options.since?.getTime() || 0;
+  const untilMs = options.until?.getTime() || Date.now();
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: createReadStream(historyPath),
+      crlfDelay: Infinity
+    });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      try {
+        const event = JSON.parse(line);
+        const eventMs = new Date(event.ts).getTime();
+        if (eventMs < sinceMs || eventMs > untilMs) return;
+        if (options.squad && event.squad !== options.squad) return;
+        if (options.type && event.type !== options.type) return;
+        events.push(event);
+      } catch {
+      }
+    });
+    rl.on("close", () => {
+      if (options.limit && events.length > options.limit) {
+        resolve(events.slice(-options.limit));
+      } else {
+        resolve(events);
+      }
+    });
+    rl.on("error", () => {
+      resolve([]);
+    });
+  });
+}
+async function getSessionHistoryStats(options = {}) {
+  const events = await readSessionHistory(options);
+  const stats = {
+    totalSessions: 0,
+    totalDurationMs: 0,
+    avgDurationMs: 0,
+    bySquad: {},
+    byDate: {},
+    peakConcurrent: 0
+  };
+  const activeSessions = /* @__PURE__ */ new Map();
+  let currentConcurrent = 0;
+  for (const event of events) {
+    const squad = event.squad || "unknown";
+    const date = event.ts.split("T")[0];
+    if (event.type === "start") {
+      stats.totalSessions++;
+      stats.byDate[date] = (stats.byDate[date] || 0) + 1;
+      if (!stats.bySquad[squad]) {
+        stats.bySquad[squad] = { count: 0, durationMs: 0 };
+      }
+      stats.bySquad[squad].count++;
+      activeSessions.set(event.sessionId, {
+        squad: event.squad,
+        startTs: new Date(event.ts).getTime()
+      });
+      currentConcurrent++;
+      stats.peakConcurrent = Math.max(stats.peakConcurrent, currentConcurrent);
+    }
+    if (event.type === "stop" || event.type === "stale_cleanup") {
+      const duration = event.durationMs || 0;
+      stats.totalDurationMs += duration;
+      if (stats.bySquad[squad]) {
+        stats.bySquad[squad].durationMs += duration;
+      }
+      if (activeSessions.has(event.sessionId)) {
+        activeSessions.delete(event.sessionId);
+        currentConcurrent = Math.max(0, currentConcurrent - 1);
+      }
+    }
+  }
+  const completedSessions = events.filter((e) => e.type === "stop" || e.type === "stale_cleanup").length;
+  if (completedSessions > 0) {
+    stats.avgDurationMs = Math.round(stats.totalDurationMs / completedSessions);
+  }
+  return stats;
+}
+async function getRecentSessions(limit = 20) {
+  const events = await readSessionHistory({ limit: limit * 3 });
+  const sessionEvents = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!sessionEvents.has(event.sessionId)) {
+      sessionEvents.set(event.sessionId, []);
+    }
+    sessionEvents.get(event.sessionId).push(event);
+  }
+  const startEvents = events.filter((e) => e.type === "start").slice(-limit);
+  return startEvents.reverse();
+}
+
+// src/lib/update.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync2 } from "fs";
+import { join as join7, dirname as dirname4 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync as execSync3 } from "child_process";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname4(__filename2);
+    const possiblePaths = [
+      join7(__dirname2, "..", "..", "package.json"),
+      // From dist/lib/
+      join7(__dirname2, "..", "package.json"),
+      // From dist/
+      join7(__dirname2, "package.json")
+      // Same dir
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (existsSync7(pkgPath)) {
+        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+        return pkg.version || "0.0.0";
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var CURRENT_VERSION = getPackageVersion();
+var CACHE_DIR = join7(homedir2(), ".squads");
+var CACHE_FILE = join7(CACHE_DIR, "update-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function isNewerVersion(v1, v2) {
+  const parts1 = v1.replace(/^v/, "").split(".").map(Number);
+  const parts2 = v2.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p2 > p1) return true;
+    if (p2 < p1) return false;
+  }
+  return false;
+}
+function readCache() {
+  try {
+    if (!existsSync7(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync6(CACHE_FILE, "utf-8"));
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latestVersion) {
+  try {
+    if (!existsSync7(CACHE_DIR)) {
+      mkdirSync5(CACHE_DIR, { recursive: true });
+    }
+    const cache = {
+      latestVersion,
+      checkedAt: Date.now()
+    };
+    writeFileSync6(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function fetchLatestVersion() {
+  try {
+    const result = execSync3("npm view squads-cli version 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function checkForUpdate() {
+  const result = {
+    currentVersion: CURRENT_VERSION,
+    latestVersion: CURRENT_VERSION,
+    updateAvailable: false
+  };
+  const cache = readCache();
+  const now = Date.now();
+  if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
+    result.latestVersion = cache.latestVersion;
+    result.updateAvailable = isNewerVersion(CURRENT_VERSION, cache.latestVersion);
+    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);
+  }
+  return result;
+}
+function performUpdate() {
+  try {
+    execSync3("npm update -g squads-cli", {
+      encoding: "utf-8",
+      stdio: "inherit",
+      timeout: 12e4
+      // 2 minutes
+    });
+    try {
+      unlinkSync2(CACHE_FILE);
+    } catch {
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+function refreshVersionCache() {
+  const latestVersion = fetchLatestVersion();
+  if (latestVersion) {
+    writeCache(latestVersion);
+    return {
+      currentVersion: CURRENT_VERSION,
+      latestVersion,
+      updateAvailable: isNewerVersion(CURRENT_VERSION, latestVersion)
+    };
+  }
+  return checkForUpdate();
+}
+
+// src/commands/status.ts
+async function statusCommand(squadName, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  if (squadName) {
+    await showSquadStatus(squadName, squadsDir, options);
+  } else {
+    await showOverallStatus(squadsDir, options);
+  }
+}
+async function showOverallStatus(squadsDir, _options) {
+  const squads = listSquads(squadsDir);
+  const memoryDir = findMemoryDir();
+  cleanupStaleSessions();
+  const sessionSummary = getLiveSessionSummary();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET}`);
+  const updateInfo = checkForUpdate();
+  if (updateInfo.updateAvailable) {
+    writeLine(`  ${colors.cyan}\u2B06${RESET} Update available: ${colors.dim}${updateInfo.currentVersion}${RESET} \u2192 ${colors.green}${updateInfo.latestVersion}${RESET} ${colors.dim}(run \`squads update\`)${RESET}`);
+  }
+  if (sessionSummary.totalSessions > 0) {
+    const sessionText = sessionSummary.totalSessions === 1 ? "session" : "sessions";
+    const squadText = sessionSummary.squadCount === 1 ? "squad" : "squads";
+    let toolInfo = "";
+    if (sessionSummary.byTool && Object.keys(sessionSummary.byTool).length > 0) {
+      const toolParts = Object.entries(sessionSummary.byTool).sort((a, b) => b[1] - a[1]).map(([tool, count]) => `${colors.dim}${tool}${RESET} ${colors.cyan}${count}${RESET}`);
+      toolInfo = ` ${colors.dim}(${RESET}${toolParts.join(` ${colors.dim}\xB7${RESET} `)}${colors.dim})${RESET}`;
+    }
+    writeLine(`  ${colors.green}${icons.active}${RESET} ${colors.white}${sessionSummary.totalSessions}${RESET} active ${sessionText} ${colors.dim}across${RESET} ${colors.cyan}${sessionSummary.squadCount}${RESET} ${squadText}${toolInfo}`);
+  }
+  writeLine();
+  const totalSquads = squads.length;
+  const activeCount = squads.length;
+  writeLine(`  ${colors.cyan}${activeCount}${RESET}/${totalSquads} squads  ${colors.dim}\u2502${RESET}  ${colors.dim}memory: ${memoryDir ? "enabled" : "none"}${RESET}`);
+  writeLine();
+  const w = { name: 16, agents: 8, memory: 14, activity: 12 };
+  const tableWidth = w.name + w.agents + w.memory + w.activity + 6;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${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(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const squadName of squads) {
+    const agents = listAgents(squadsDir, squadName);
+    let memoryStatus = `${colors.dim}none${RESET}`;
+    let lastActivity = `${colors.dim}\u2014${RESET}`;
+    let activityColor = colors.dim;
+    if (memoryDir) {
+      const squadMemoryPath = join8(memoryDir, squadName);
+      if (existsSync8(squadMemoryPath)) {
+        const states = getSquadState(squadName);
+        memoryStatus = `${colors.green}${states.length} ${states.length === 1 ? "entry" : "entries"}${RESET}`;
+        let mostRecent = 0;
+        for (const state of states) {
+          const stat = statSync(state.path);
+          if (stat.mtimeMs > mostRecent) {
+            mostRecent = stat.mtimeMs;
+          }
+        }
+        if (mostRecent > 0) {
+          const daysAgo = Math.floor((Date.now() - mostRecent) / (1e3 * 60 * 60 * 24));
+          if (daysAgo === 0) {
+            lastActivity = "today";
+            activityColor = colors.green;
+          } else if (daysAgo === 1) {
+            lastActivity = "yesterday";
+            activityColor = colors.green;
+          } else if (daysAgo < 7) {
+            lastActivity = `${daysAgo}d ago`;
+            activityColor = colors.yellow;
+          } else {
+            lastActivity = `${daysAgo}d ago`;
+            activityColor = colors.dim;
+          }
+        }
+      }
+    }
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squadName, w.name)}${RESET}${padEnd(String(agents.length), w.agents)}${padEnd(memoryStatus, w.memory)}${padEnd(`${activityColor}${lastActivity}${RESET}`, w.activity)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads status ${colors.cyan}<squad>${RESET}    ${colors.dim}Squad details${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads dash             ${colors.dim}Full dashboard${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}<squad>${RESET}       ${colors.dim}Execute a squad${RESET}`);
+  writeLine();
+}
+async function showSquadStatus(squadName, squadsDir, options) {
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`${colors.red}Squad "${squadName}" not found.${RESET}`);
+    process.exit(1);
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET} ${colors.cyan}${squad.name}${RESET}`);
+  writeLine();
+  if (squad.mission) {
+    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
+    writeLine();
+  }
+  const agents = listAgents(squadsDir, squadName);
+  const w = { name: 24, role: 36 };
+  const tableWidth = w.name + w.role + 4;
+  writeLine(`  ${bold}Agents${RESET} ${colors.dim}(${agents.length})${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  for (const agent of agents) {
+    const status = agent.status?.toLowerCase() === "active" ? icons.active : icons.pending;
+    const role = options.verbose && agent.role ? `${colors.dim}${agent.role.substring(0, w.role - 2)}${RESET}` : "";
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${status} ${padEnd(agent.name, w.name - 2)}${padEnd(role, w.role)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  if (squad.pipelines.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Pipelines${RESET}`);
+    for (const pipeline of squad.pipelines) {
+      writeLine(`  ${colors.dim}${pipeline.agents.join(" \u2192 ")}${RESET}`);
+    }
+  }
+  const memoryDir = findMemoryDir();
+  if (memoryDir) {
+    const states = getSquadState(squadName);
+    if (states.length > 0) {
+      writeLine();
+      writeLine(`  ${bold}Memory${RESET} ${colors.dim}(${states.length} ${states.length === 1 ? "entry" : "entries"})${RESET}`);
+      writeLine();
+      for (const state of states) {
+        const updated = state.content.match(/Updated:\s*(\S+)/)?.[1] || "unknown";
+        writeLine(`  ${icons.progress} ${colors.white}${state.agent}${RESET}`);
+        writeLine(`    ${colors.dim}\u2514 updated: ${updated}${RESET}`);
+        if (options.verbose) {
+          const signalsMatch = state.content.match(/## Active Signals([\s\S]*?)(?=##|$)/);
+          if (signalsMatch) {
+            const signalLines = signalsMatch[1].split("\n").filter((l) => l.match(/^\d+\./)).slice(0, 3);
+            for (const sig of signalLines) {
+              writeLine(`    ${colors.dim}  ${sig.trim()}${RESET}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  writeLine();
   writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET}           ${colors.dim}Run the squad${RESET}`);
   writeLine(`  ${colors.dim}$${RESET} squads memory show ${colors.cyan}${squadName}${RESET}   ${colors.dim}View full memory${RESET}`);
   writeLine(`  ${colors.dim}$${RESET} squads status ${colors.cyan}${squadName}${RESET} -v     ${colors.dim}Verbose status${RESET}`);
@@ -1997,9 +2578,9 @@ async function memorySearchCommand(query, options = {}) {
 }
 
 // src/commands/sync.ts
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
-import { join as join7 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "fs";
+import { join as join9 } from "path";
 var PATH_TO_SQUAD = {
   "squads-cli": "product",
   "agents-squads-web": "website",
@@ -2027,21 +2608,21 @@ var MESSAGE_TO_SQUAD = {
   "infra": "engineering"
 };
 function getLastSyncTime(memoryDir) {
-  const syncFile = join7(memoryDir, ".last-sync");
-  if (existsSync7(syncFile)) {
-    return readFileSync5(syncFile, "utf-8").trim();
+  const syncFile = join9(memoryDir, ".last-sync");
+  if (existsSync9(syncFile)) {
+    return readFileSync7(syncFile, "utf-8").trim();
   }
   return null;
 }
 function updateLastSyncTime(memoryDir) {
-  const syncFile = join7(memoryDir, ".last-sync");
-  writeFileSync5(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+  const syncFile = join9(memoryDir, ".last-sync");
+  writeFileSync7(syncFile, (/* @__PURE__ */ new Date()).toISOString());
 }
 function getRecentCommits(since) {
   const commits = [];
   try {
     const sinceArg = since ? `--since="${since}"` : "-n 20";
-    const logOutput = execSync2(
+    const logOutput = execSync4(
       `git log ${sinceArg} --format="%H|%aI|%s" --name-only`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -2107,22 +2688,22 @@ ${messages}
 `;
 }
 function appendToSquadMemory(memoryDir, squad, summary) {
-  const squadMemoryDir = join7(memoryDir, squad);
-  if (!existsSync7(squadMemoryDir)) {
-    mkdirSync4(squadMemoryDir, { recursive: true });
+  const squadMemoryDir = join9(memoryDir, squad);
+  if (!existsSync9(squadMemoryDir)) {
+    mkdirSync6(squadMemoryDir, { recursive: true });
   }
   let agentDir;
-  const existingDirs = existsSync7(squadMemoryDir) ? readdirSync3(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  const existingDirs = existsSync9(squadMemoryDir) ? readdirSync4(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
   if (existingDirs.length > 0) {
-    agentDir = join7(squadMemoryDir, existingDirs[0]);
+    agentDir = join9(squadMemoryDir, existingDirs[0]);
   } else {
-    agentDir = join7(squadMemoryDir, `${squad}-lead`);
-    mkdirSync4(agentDir, { recursive: true });
+    agentDir = join9(squadMemoryDir, `${squad}-lead`);
+    mkdirSync6(agentDir, { recursive: true });
   }
-  const statePath = join7(agentDir, "state.md");
+  const statePath = join9(agentDir, "state.md");
   let content = "";
-  if (existsSync7(statePath)) {
-    content = readFileSync5(statePath, "utf-8");
+  if (existsSync9(statePath)) {
+    content = readFileSync7(statePath, "utf-8");
   } else {
     content = `# ${squad} Squad - State
 
@@ -2134,9 +2715,53 @@ Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
     `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
   );
   content += summary;
-  writeFileSync5(statePath, content);
+  writeFileSync7(statePath, content);
   return true;
 }
+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"] });
+    const behindMatch = status.match(/behind (\d+)/);
+    const aheadMatch = status.match(/ahead (\d+)/);
+    const behind = behindMatch ? parseInt(behindMatch[1]) : 0;
+    const ahead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
+    if (behind === 0) {
+      return { success: true, output: "Already up to date", behind: 0, ahead };
+    }
+    const output = execSync4("git pull --rebase origin main", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, output: output.trim(), behind, ahead };
+  } catch (error) {
+    const err = error;
+    return { success: false, output: err.message || "Pull failed", behind: 0, ahead: 0 };
+  }
+}
+function gitPushMemory() {
+  try {
+    const status = execSync4("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"', {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    const output = execSync4("git push origin main", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, output: output.trim() || "Pushed successfully" };
+  } catch (error) {
+    const err = error;
+    return { success: false, output: err.message || "Push failed" };
+  }
+}
 async function syncCommand(options = {}) {
   const memoryDir = findMemoryDir();
   const squadsDir = findSquadsDir();
@@ -2148,6 +2773,25 @@ async function syncCommand(options = {}) {
   writeLine();
   writeLine(`  ${gradient("squads")} ${colors.dim}memory sync${RESET}`);
   writeLine();
+  const doPull = options.pull !== false;
+  const doPush = options.push === true;
+  if (doPull) {
+    writeLine(`  ${icons.progress} Pulling from remote...`);
+    const pullResult = gitPullMemory();
+    if (pullResult.success) {
+      if (pullResult.behind > 0) {
+        writeLine(`  ${icons.success} Pulled ${colors.cyan}${pullResult.behind}${RESET} commits from remote`);
+      } else {
+        writeLine(`  ${icons.success} ${colors.dim}Already up to date${RESET}`);
+      }
+      if (pullResult.ahead > 0) {
+        writeLine(`  ${colors.dim}  ${pullResult.ahead} local commits to push${RESET}`);
+      }
+    } else {
+      writeLine(`  ${icons.error} ${colors.red}Pull failed: ${pullResult.output}${RESET}`);
+    }
+    writeLine();
+  }
   const lastSync = getLastSyncTime(memoryDir);
   if (lastSync) {
     writeLine(`  ${colors.dim}Last sync: ${lastSync.split("T")[0]}${RESET}`);
@@ -2189,8 +2833,21 @@ async function syncCommand(options = {}) {
   writeLine(`  ${colors.green}${updated}${RESET} squad memories updated`);
   writeLine();
   updateLastSyncTime(memoryDir);
+  if (doPush) {
+    writeLine(`  ${icons.progress} Pushing to remote...`);
+    const pushResult = gitPushMemory();
+    if (pushResult.success) {
+      writeLine(`  ${icons.success} ${colors.green}Pushed memory updates to remote${RESET}`);
+    } else {
+      writeLine(`  ${icons.error} ${colors.red}Push failed: ${pushResult.output}${RESET}`);
+    }
+    writeLine();
+  }
   writeLine(`  ${colors.dim}$${RESET} squads memory show ${colors.cyan}<squad>${RESET}   ${colors.dim}View updated memory${RESET}`);
   writeLine(`  ${colors.dim}$${RESET} squads status               ${colors.dim}See all squads${RESET}`);
+  if (!doPush && updated > 0) {
+    writeLine(`  ${colors.dim}$${RESET} squads memory sync --push   ${colors.dim}Push changes to remote${RESET}`);
+  }
   writeLine();
 }
 
@@ -2318,28 +2975,28 @@ async function goalProgressCommand(squadName, goalIndex, progress2) {
 }
 
 // src/commands/feedback.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync4 } from "fs";
-import { join as join8, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync8, existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5 } from "fs";
+import { join as join10, dirname as dirname6 } from "path";
 function getFeedbackPath(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
   const squad = loadSquad(squadName);
   const agentName = squad?.agents[0]?.name || `${squadName}-lead`;
-  return join8(memoryDir, squadName, agentName, "feedback.md");
+  return join10(memoryDir, squadName, agentName, "feedback.md");
 }
 function getOutputPath(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
   const squad = loadSquad(squadName);
   const agentName = squad?.agents[0]?.name || `${squadName}-lead`;
-  return join8(memoryDir, squadName, agentName, "output.md");
+  return join10(memoryDir, squadName, agentName, "output.md");
 }
 function getLastExecution(squadName) {
   const outputPath = getOutputPath(squadName);
-  if (!outputPath || !existsSync8(outputPath)) {
+  if (!outputPath || !existsSync10(outputPath)) {
     return null;
   }
-  const content = readFileSync6(outputPath, "utf-8");
+  const content = readFileSync8(outputPath, "utf-8");
   const lines = content.split("\n");
   let date = "unknown";
   let summary = lines.slice(0, 5).join("\n");
@@ -2390,9 +3047,9 @@ async function feedbackAddCommand(squadName, rating, feedback2, options) {
     return;
   }
   const lastExec = getLastExecution(squadName);
-  const dir = dirname4(feedbackPath);
-  if (!existsSync8(dir)) {
-    mkdirSync5(dir, { recursive: true });
+  const dir = dirname6(feedbackPath);
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let entry = `
@@ -2420,15 +3077,15 @@ _Date: ${date}_
     }
   }
   let existing = "";
-  if (existsSync8(feedbackPath)) {
-    existing = readFileSync6(feedbackPath, "utf-8");
+  if (existsSync10(feedbackPath)) {
+    existing = readFileSync8(feedbackPath, "utf-8");
   } else {
     existing = `# ${squadName} - Feedback Log
 
 > Execution feedback and learnings
 `;
   }
-  writeFileSync6(feedbackPath, existing + entry);
+  writeFileSync8(feedbackPath, existing + entry);
   const stars = `${colors.yellow}${"\u2605".repeat(ratingNum)}${"\u2606".repeat(5 - ratingNum)}${RESET}`;
   writeLine();
   writeLine(`  ${icons.success} Feedback recorded for ${colors.cyan}${squadName}${RESET}`);
@@ -2441,11 +3098,11 @@ _Date: ${date}_
 }
 async function feedbackShowCommand(squadName, options) {
   const feedbackPath = getFeedbackPath(squadName);
-  if (!feedbackPath || !existsSync8(feedbackPath)) {
+  if (!feedbackPath || !existsSync10(feedbackPath)) {
     writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
     return;
   }
-  const content = readFileSync6(feedbackPath, "utf-8");
+  const content = readFileSync8(feedbackPath, "utf-8");
   const entries = parseFeedbackHistory(content);
   const limit = options.limit ? parseInt(options.limit) : 5;
   const recent = entries.slice(-limit).reverse();
@@ -2480,7 +3137,7 @@ async function feedbackStatsCommand() {
   writeLine();
   writeLine(`  ${gradient("squads")} ${colors.dim}feedback stats${RESET}`);
   writeLine();
-  const squads = readdirSync4(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const squads = readdirSync5(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   const w = { squad: 18, avg: 12, count: 8, trend: 6 };
   const tableWidth = w.squad + w.avg + w.count + w.trend + 4;
   writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
@@ -2489,10 +3146,10 @@ async function feedbackStatsCommand() {
   writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
   for (const squad of squads) {
     const feedbackPath = getFeedbackPath(squad);
-    if (!feedbackPath || !existsSync8(feedbackPath)) {
+    if (!feedbackPath || !existsSync10(feedbackPath)) {
       continue;
     }
-    const content = readFileSync6(feedbackPath, "utf-8");
+    const content = readFileSync8(feedbackPath, "utf-8");
     const entries = parseFeedbackHistory(content);
     if (entries.length === 0) continue;
     const avgRating = entries.reduce((sum, e) => sum + e.rating, 0) / entries.length;
@@ -2515,9 +3172,9 @@ async function feedbackStatsCommand() {
 }
 
 // src/commands/dashboard.ts
-import { readdirSync as readdirSync5, existsSync as existsSync9, statSync as statSync2 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir2 } from "os";
+import { readdirSync as readdirSync6, existsSync as existsSync11, statSync as statSync2 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/lib/costs.ts
 var MODEL_PRICING = {
@@ -2528,16 +3185,29 @@ var MODEL_PRICING = {
   "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
   default: { input: 3, output: 15 }
 };
-var DEFAULT_DAILY_BUDGET = 50;
+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;
+async function fetchWithTimeout(url, options = {}, timeoutMs = FETCH_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...options, signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
 function calcCost(model, inputTokens, outputTokens) {
   const pricing = MODEL_PRICING[model] || MODEL_PRICING.default;
   return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
 }
 async function fetchFromBridge(period = "day") {
   try {
-    const response = await fetch(`${BRIDGE_URL}/api/cost/summary?period=${period}`, {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=${period}`, {
       headers: { "Content-Type": "application/json" }
     });
     if (!response.ok) {
@@ -2589,7 +3259,7 @@ async function fetchFromLangfuse(limit = 100) {
   try {
     const auth = Buffer.from(`${publicKey}:${secretKey}`).toString("base64");
     const url = `${host}/api/public/observations?limit=${limit}`;
-    const response = await fetch(url, {
+    const response = await fetchWithTimeout(url, {
       headers: {
         Authorization: `Basic ${auth}`,
         "Content-Type": "application/json"
@@ -2684,41 +3354,78 @@ function formatCostBar(usedPercent, width = 20) {
   const empty = width - filled;
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
-async function fetchRateLimits() {
+async function fetchBridgeStats() {
   try {
-    const response = await fetch(`${BRIDGE_URL}/api/rate-limits`, {
+    const statsResponse = await fetchWithTimeout(`${BRIDGE_URL}/stats`, {
       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()
-      };
+    if (!statsResponse.ok) {
+      return null;
     }
-    return { limits, source: "proxy" };
+    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([
+      fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=day`, {
+        headers: { "Content-Type": "application/json" }
+      }),
+      fetchWithTimeout(`${BRIDGE_URL}/api/cost/summary?period=week`, {
+        headers: { "Content-Type": "application/json" }
+      })
+    ]);
+    const costData = costResponse.ok ? await costResponse.json() : {};
+    const weekData = weekResponse.ok ? await weekResponse.json() : {};
+    return {
+      status: stats.status || "unknown",
+      source: stats.source || "none",
+      today: {
+        generations: stats.today?.generations || 0,
+        inputTokens: stats.today?.input_tokens || 0,
+        outputTokens: stats.today?.output_tokens || 0,
+        costUsd: stats.today?.cost_usd || 0
+      },
+      week: weekData.totals ? {
+        generations: weekData.totals.generations || 0,
+        inputTokens: weekData.totals.input_tokens || 0,
+        outputTokens: weekData.totals.output_tokens || 0,
+        costUsd: weekData.totals.cost_usd || 0,
+        byModel: (weekData.by_model || []).map((m) => ({
+          model: m.model || "unknown",
+          generations: m.generations || 0,
+          costUsd: m.cost_usd || 0
+        }))
+      } : void 0,
+      budget: {
+        daily: stats.budget?.daily || DEFAULT_DAILY_BUDGET,
+        used: stats.budget?.used || 0,
+        remaining: stats.budget?.remaining || DEFAULT_DAILY_BUDGET,
+        usedPct: stats.budget?.used_pct || 0
+      },
+      bySquad: (stats.by_squad || []).map((s) => ({
+        squad: s.squad || "unknown",
+        costUsd: s.cost_usd || 0,
+        generations: s.generations || 0
+      })),
+      byModel: (costData.by_model || []).map((m) => ({
+        model: m.model || "unknown",
+        generations: m.generations || 0,
+        costUsd: m.cost_usd || 0
+      })),
+      health: {
+        postgres: health.postgres || "unknown",
+        redis: health.redis || "unknown",
+        langfuse: health.langfuse || "unknown"
+      }
+    };
   } catch {
-    return { limits: {}, source: "none" };
+    return null;
   }
 }
 async function fetchInsights(period = "week") {
   try {
-    const response = await fetch(`${BRIDGE_URL}/api/insights?period=${period}`, {
+    const response = await fetchWithTimeout(`${BRIDGE_URL}/api/insights?period=${period}`, {
       headers: { "Content-Type": "application/json" }
     });
     if (!response.ok) {
@@ -2793,7 +3500,8 @@ function getPool() {
       connectionString: DATABASE_URL,
       max: 5,
       idleTimeoutMillis: 3e4,
-      connectionTimeoutMillis: 5e3
+      connectionTimeoutMillis: 1500
+      // Fast timeout for CLI responsiveness
     });
     pool.on("error", (err) => {
       console.error("Unexpected database pool error:", err);
@@ -2895,21 +3603,27 @@ async function getDashboardHistory(limit = 30) {
     return [];
   }
 }
+async function closeDatabase() {
+  if (pool) {
+    await pool.end();
+    pool = null;
+  }
+}
 
 // src/commands/dashboard.ts
 function getLastActivityDate(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return "unknown";
-  const squadMemory = join9(memoryDir, squadName);
-  if (!existsSync9(squadMemory)) return "\u2014";
+  const squadMemory = join11(memoryDir, squadName);
+  if (!existsSync11(squadMemory)) return "\u2014";
   let latestTime = 0;
   try {
-    const agents = readdirSync5(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
+    const agents = readdirSync6(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
     for (const agent of agents) {
-      const agentPath = join9(squadMemory, agent.name);
-      const files = readdirSync5(agentPath).filter((f) => f.endsWith(".md"));
+      const agentPath = join11(squadMemory, agent.name);
+      const files = readdirSync6(agentPath).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const filePath = join9(agentPath, file);
+        const filePath = join11(agentPath, file);
         const stats = statSync2(filePath);
         if (stats.mtimeMs > latestTime) {
           latestTime = stats.mtimeMs;
@@ -2937,54 +3651,119 @@ async function dashboardCommand(options = {}) {
     await renderCeoReport(squadsDir);
     return;
   }
+  const baseDir = findAgentsSquadsDir();
   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([
+    // Git stats (local, ~1s)
+    Promise.resolve(baseDir ? getMultiRepoGitStats(baseDir, 30) : null),
+    // GitHub stats (network, ~20-30s) - skip by default for fast mode
+    skipGitHub ? Promise.resolve(null) : Promise.resolve(baseDir ? getGitHubStatsOptimized(baseDir, 30) : null),
+    // Langfuse costs (network, 2s timeout)
+    timeout(fetchCostSummary(100), 2e3, null),
+    // Bridge stats (local network, 2s timeout)
+    timeout(fetchBridgeStats(), 2e3, null),
+    // Activity sparkline (local, <1s)
+    Promise.resolve(baseDir ? getActivitySparkline(baseDir, 14) : []),
+    // Database availability check (1.5s timeout)
+    timeout(isDatabaseAvailable(), 1500, false),
+    // Dashboard history (1.5s timeout)
+    timeout(getDashboardHistory(14).catch(() => []), 1500, []),
+    // Insights (2s timeout)
+    timeout(fetchInsights("week").catch(() => null), 2e3, null)
+  ]);
+  const cache = { gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights };
   const squadData = [];
-  const baseDir = findAgentsSquadsDir();
-  const ghStats = baseDir ? getGitHubStats(baseDir, 30) : null;
   for (const name of squadNames) {
     const squad = loadSquad(name);
     if (!squad) continue;
     const lastActivity = getLastActivityDate(name);
     const github = ghStats?.bySquad.get(name) || null;
     let status = "active";
-    const activeGoals2 = squad.goals.filter((g) => !g.completed);
-    if (activeGoals2.length === 0) {
+    const activeGoals = squad.goals.filter((g) => !g.completed);
+    if (activeGoals.length === 0) {
       status = "needs-goal";
     } else if (lastActivity.includes("w") || lastActivity === "\u2014") {
       status = "stale";
     }
-    const totalGoals2 = squad.goals.length;
-    const completedGoals2 = squad.goals.filter((g) => g.completed).length;
+    const totalGoals = squad.goals.length;
+    const completedGoals = squad.goals.filter((g) => g.completed).length;
     const hasProgress = squad.goals.filter((g) => g.progress).length;
-    const goalProgress = totalGoals2 > 0 ? Math.round((completedGoals2 + hasProgress * 0.3) / totalGoals2 * 100) : 0;
+    const goalProgress = totalGoals > 0 ? Math.round((completedGoals + hasProgress * 0.3) / totalGoals * 100) : 0;
+    const repoSquadMap = {
+      website: ["agents-squads-web"],
+      product: ["squads-cli"],
+      engineering: ["hq", "squads-cli"],
+      research: ["research"],
+      intelligence: ["intelligence"],
+      customer: ["customer"],
+      finance: ["finance"],
+      company: ["company", "hq"],
+      marketing: ["marketing", "agents-squads-web"],
+      cli: ["squads-cli"]
+    };
+    let squadCommits = 0;
+    if (gitStats) {
+      for (const [repo, commits] of gitStats.commitsByRepo) {
+        if (repoSquadMap[name]?.includes(repo)) {
+          squadCommits += commits;
+        }
+      }
+    }
+    const githubStats = github || {
+      prsOpened: 0,
+      prsMerged: 0,
+      issuesClosed: 0,
+      issuesOpen: 0,
+      commits: 0,
+      recentIssues: [],
+      recentPRs: []
+    };
+    githubStats.commits = squadCommits;
     squadData.push({
       name,
       mission: squad.mission,
       goals: squad.goals,
       lastActivity,
       status,
-      github,
+      github: githubStats,
       goalProgress
     });
   }
-  const totalGoals = squadData.reduce((sum, s) => sum + s.goals.length, 0);
-  const activeGoals = squadData.reduce((sum, s) => sum + s.goals.filter((g) => !g.completed).length, 0);
-  const completedGoals = totalGoals - activeGoals;
-  const completionRate = totalGoals > 0 ? Math.round(completedGoals / totalGoals * 100) : 0;
   const activeSquads = squadData.filter((s) => s.status === "active").length;
   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}`);
-  writeLine();
-  const stats = [
-    `${colors.cyan}${activeSquads}${RESET}/${squadData.length} squads`,
-    `${colors.green}${totalPRs}${RESET} PRs merged`,
-    `${colors.purple}${totalIssuesClosed}${RESET} closed`,
-    `${colors.yellow}${totalIssuesOpen}${RESET} open`
-  ].join(`  ${colors.dim}\u2502${RESET}  `);
-  writeLine(`  ${stats}`);
+  const updateInfo = checkForUpdate();
+  if (updateInfo.updateAvailable) {
+    writeLine(`  ${colors.cyan}\u2B06${RESET} Update available: ${colors.dim}${updateInfo.currentVersion}${RESET} \u2192 ${colors.green}${updateInfo.latestVersion}${RESET} ${colors.dim}(run \`squads update\`)${RESET}`);
+  }
+  if (sessionSummary.totalSessions > 0) {
+    const sessionText = sessionSummary.totalSessions === 1 ? "session" : "sessions";
+    const squadText = sessionSummary.squadCount === 1 ? "squad" : "squads";
+    let toolInfo = "";
+    if (sessionSummary.byTool && Object.keys(sessionSummary.byTool).length > 0) {
+      const toolParts = Object.entries(sessionSummary.byTool).sort((a, b) => b[1] - a[1]).map(([tool, count]) => `${colors.dim}${tool}${RESET} ${colors.cyan}${count}${RESET}`);
+      toolInfo = ` ${colors.dim}(${RESET}${toolParts.join(` ${colors.dim}\xB7${RESET} `)}${colors.dim})${RESET}`;
+    }
+    writeLine(`  ${colors.green}${icons.active}${RESET} ${colors.white}${sessionSummary.totalSessions}${RESET} active ${sessionText} ${colors.dim}across${RESET} ${colors.cyan}${sessionSummary.squadCount}${RESET} ${squadText}${toolInfo}`);
+  }
+  writeLine();
+  const statsParts = [`${colors.cyan}${activeSquads}${RESET}/${squadData.length} squads`];
+  if (ghStats) {
+    statsParts.push(`${colors.green}${totalPRs}${RESET} PRs merged`);
+    statsParts.push(`${colors.purple}${totalIssuesClosed}${RESET} closed`);
+    statsParts.push(`${colors.yellow}${totalIssuesOpen}${RESET} open`);
+  } else {
+    statsParts.push(`${colors.cyan}${gitStats?.totalCommits || 0}${RESET} commits`);
+    statsParts.push(`${colors.dim}use -f for PRs/issues${RESET}`);
+  }
+  writeLine(`  ${statsParts.join(`  ${colors.dim}\u2502${RESET}  `)}`);
   writeLine();
   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}`);
@@ -2992,8 +3771,7 @@ async function dashboardCommand(options = {}) {
   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;
   writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
-  const header = `  ${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(header);
+  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}`);
   const sortedSquads = [...squadData].sort((a, b) => {
     const aActivity = (a.github?.commits || 0) + (a.github?.prsMerged || 0) * 5;
@@ -3011,16 +3789,15 @@ async function dashboardCommand(options = {}) {
     const commitColor = commits > 10 ? colors.green : commits > 0 ? colors.cyan : colors.dim;
     const prColor = prs > 0 ? colors.green : colors.dim;
     const issueColor = issuesClosed > 0 ? colors.green : colors.dim;
-    const issuesDisplay = `${issuesClosed}/${issuesOpen}`;
-    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad.name, w.name)}${RESET}${commitColor}${padEnd(String(commits), w.commits)}${RESET}${prColor}${padEnd(String(prs), w.prs)}${RESET}${issueColor}${padEnd(issuesDisplay, w.issues)}${RESET}${padEnd(`${activeCount}/${totalCount}`, w.goals)}${progressBar(squad.goalProgress, 8)} ${colors.purple}${box.vertical}${RESET}`;
-    writeLine(row);
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad.name, w.name)}${RESET}${commitColor}${padEnd(String(commits), w.commits)}${RESET}${prColor}${padEnd(String(prs), w.prs)}${RESET}${issueColor}${padEnd(`${issuesClosed}/${issuesOpen}`, w.issues)}${RESET}${padEnd(`${activeCount}/${totalCount}`, w.goals)}${progressBar(squad.goalProgress, 8)} ${colors.purple}${box.vertical}${RESET}`);
   }
   writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
   writeLine();
-  await renderGitPerformance();
-  await renderTokenEconomics(squadData.map((s) => s.name));
-  await renderHistoricalTrends();
-  await renderInsights();
+  renderGitPerformanceCached(cache);
+  renderTokenEconomicsCached(cache);
+  renderInfrastructureCached(cache);
+  renderHistoricalTrendsCached(cache);
+  renderInsightsCached(cache);
   const allActiveGoals = squadData.flatMap(
     (s) => s.goals.filter((g) => !g.completed).map((g) => ({ squad: s.name, goal: g }))
   );
@@ -3031,12 +3808,9 @@ async function dashboardCommand(options = {}) {
     for (const { squad, goal: goal2 } of allActiveGoals.slice(0, maxGoals)) {
       const hasProgress = goal2.progress && goal2.progress.length > 0;
       const icon = hasProgress ? icons.progress : icons.empty;
-      const squadLabel = `${colors.dim}${squad}${RESET}`;
-      const goalText = truncate(goal2.description, 48);
-      writeLine(`  ${icon} ${squadLabel} ${goalText}`);
+      writeLine(`  ${icon} ${colors.dim}${squad}${RESET} ${truncate(goal2.description, 48)}`);
       if (hasProgress) {
-        const progressText = truncate(goal2.progress, 52);
-        writeLine(`    ${colors.dim}\u2514${RESET} ${colors.green}${progressText}${RESET}`);
+        writeLine(`    ${colors.dim}\u2514${RESET} ${colors.green}${truncate(goal2.progress, 52)}${RESET}`);
       }
     }
     if (allActiveGoals.length > maxGoals) {
@@ -3047,82 +3821,41 @@ async function dashboardCommand(options = {}) {
   writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}<squad>${RESET}    ${colors.dim}Execute a squad${RESET}`);
   writeLine(`  ${colors.dim}$${RESET} squads goal set    ${colors.dim}Add a goal${RESET}`);
   writeLine();
-  await saveSnapshot(squadData, ghStats, baseDir);
-}
-async function saveSnapshot(squadData, ghStats, baseDir) {
-  const dbAvailable = await isDatabaseAvailable();
-  if (!dbAvailable) return;
-  const gitStats = baseDir ? getMultiRepoGitStats(baseDir, 30) : null;
-  const costs = await fetchCostSummary(100);
-  const squadsData = squadData.map((s) => ({
-    name: s.name,
-    commits: s.github?.commits || 0,
-    prsOpened: s.github?.prsOpened || 0,
-    prsMerged: s.github?.prsMerged || 0,
-    issuesClosed: s.github?.issuesClosed || 0,
-    issuesOpen: s.github?.issuesOpen || 0,
-    goalsActive: s.goals.filter((g) => !g.completed).length,
-    goalsTotal: s.goals.length,
-    progress: s.goalProgress
-  }));
-  const authorsData = gitStats ? Array.from(gitStats.commitsByAuthor.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, commits]) => ({ name, commits })) : [];
-  const reposData = gitStats ? Array.from(gitStats.commitsByRepo.entries()).sort((a, b) => b[1] - a[1]).map(([name, commits]) => ({ name, commits })) : [];
-  const totalInputTokens = costs?.bySquad.reduce((sum, s) => sum + s.inputTokens, 0) || 0;
-  const totalOutputTokens = costs?.bySquad.reduce((sum, s) => sum + s.outputTokens, 0) || 0;
-  const overallProgress = squadData.length > 0 ? Math.round(squadData.reduce((sum, s) => sum + s.goalProgress, 0) / squadData.length) : 0;
-  const snapshot = {
-    totalSquads: squadData.length,
-    totalCommits: gitStats?.totalCommits || 0,
-    totalPrsMerged: ghStats?.prsMerged || 0,
-    totalIssuesClosed: ghStats?.issuesClosed || 0,
-    totalIssuesOpen: ghStats?.issuesOpen || 0,
-    goalProgressPct: overallProgress,
-    costUsd: costs?.totalCost || 0,
-    dailyBudgetUsd: costs?.dailyBudget || 50,
-    inputTokens: totalInputTokens,
-    outputTokens: totalOutputTokens,
-    commits30d: gitStats?.totalCommits || 0,
-    avgCommitsPerDay: gitStats?.avgCommitsPerDay || 0,
-    activeDays: gitStats?.activeDays || 0,
-    peakCommits: gitStats?.peakDay?.count || 0,
-    peakDate: gitStats?.peakDay?.date || null,
-    squadsData,
-    authorsData,
-    reposData
-  };
-  await saveDashboardSnapshot(snapshot);
+  saveSnapshotCached(squadData, cache, baseDir).catch(() => {
+  });
+  await closeDatabase();
 }
 function findAgentsSquadsDir() {
   const candidates = [
-    join9(process.cwd(), ".."),
-    join9(homedir2(), "agents-squads")
+    join11(process.cwd(), ".."),
+    join11(homedir3(), "agents-squads")
   ];
   for (const dir of candidates) {
-    if (existsSync9(join9(dir, "hq"))) {
+    if (existsSync11(join11(dir, "hq"))) {
       return dir;
     }
   }
   return null;
 }
-async function renderGitPerformance() {
-  const baseDir = findAgentsSquadsDir();
-  if (!baseDir) {
-    writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(no repos found)${RESET}`);
-    writeLine();
-    return;
-  }
-  const stats = getMultiRepoGitStats(baseDir, 30);
-  const activity = getActivitySparkline(baseDir, 14);
-  if (stats.totalCommits === 0) {
+function formatK(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(0) + "k";
+  return String(n);
+}
+function renderGitPerformanceCached(cache) {
+  const { gitStats: stats, activity } = cache;
+  if (!stats || stats.totalCommits === 0) {
     writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(no commits in 30d)${RESET}`);
     writeLine();
     return;
   }
   writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(30d)${RESET}`);
   writeLine();
-  const spark = sparkline(activity);
-  writeLine(`  ${colors.dim}Last 14d:${RESET} ${spark}`);
-  writeLine();
+  if (activity.length > 0) {
+    const spark = sparkline(activity);
+    writeLine(`  ${colors.dim}Last 14d:${RESET} ${spark}`);
+    writeLine();
+  }
   const metrics = [
     `${colors.cyan}${stats.totalCommits}${RESET} commits`,
     `${colors.green}${stats.avgCommitsPerDay}${RESET}/day`,
@@ -3149,8 +3882,8 @@ async function renderGitPerformance() {
     writeLine();
   }
 }
-async function renderTokenEconomics(squadNames) {
-  const costs = await fetchCostSummary(100);
+function renderTokenEconomicsCached(cache) {
+  const costs = cache.costs;
   if (!costs) {
     writeLine(`  ${bold}Token Economics${RESET} ${colors.dim}(no data)${RESET}`);
     writeLine(`  ${colors.dim}Set LANGFUSE_PUBLIC_KEY & LANGFUSE_SECRET_KEY for cost tracking${RESET}`);
@@ -3165,81 +3898,13 @@ async function renderTokenEconomics(squadNames) {
   writeLine(`  ${colors.green}$${costs.totalCost.toFixed(2)}${RESET} used  ${colors.dim}\u2502${RESET}  ${colors.cyan}$${costs.idleBudget.toFixed(2)}${RESET} idle`);
   writeLine();
   const tier = parseInt(process.env.ANTHROPIC_TIER || "4", 10);
-  const rpmByTier = { 1: 50, 2: 1e3, 3: 2e3, 4: 4e3 };
-  const rpmLimit = rpmByTier[tier] || 4e3;
-  const tokenLimits = {
-    1: { opus: { itpm: 3e4, otpm: 8e3 }, sonnet: { itpm: 3e4, otpm: 8e3 }, haiku: { itpm: 5e4, otpm: 1e4 } },
-    2: { opus: { itpm: 45e4, otpm: 9e4 }, sonnet: { itpm: 45e4, otpm: 9e4 }, haiku: { itpm: 45e4, otpm: 9e4 } },
-    3: { opus: { itpm: 8e5, otpm: 16e4 }, sonnet: { itpm: 8e5, otpm: 16e4 }, haiku: { itpm: 1e6, otpm: 2e5 } },
-    4: { opus: { itpm: 2e6, otpm: 4e5 }, sonnet: { itpm: 2e6, otpm: 4e5 }, haiku: { itpm: 4e6, otpm: 8e5 } }
-  };
-  const modelShortNames = {
-    "claude-opus-4-5-20251101": "opus-4.5",
-    "claude-sonnet-4-20250514": "sonnet-4",
-    "claude-haiku-4-5-20251001": "haiku-4.5",
-    "claude-3-5-sonnet-20241022": "sonnet-3.5",
-    "claude-3-5-haiku-20241022": "haiku-3.5"
-  };
-  const modelToFamily = {
-    "claude-opus-4-5-20251101": "opus",
-    "claude-sonnet-4-20250514": "sonnet",
-    "claude-haiku-4-5-20251001": "haiku",
-    "claude-3-5-sonnet-20241022": "sonnet",
-    "claude-3-5-haiku-20241022": "haiku"
-  };
-  const modelStats = {};
-  for (const squad of costs.bySquad) {
-    for (const [model, count] of Object.entries(squad.models)) {
-      if (!modelStats[model]) {
-        modelStats[model] = { calls: 0, input: 0, output: 0, cached: 0 };
-      }
-      modelStats[model].calls += count;
-    }
-    const totalCalls2 = Object.values(squad.models).reduce((a, b) => a + b, 0);
-    for (const [model, count] of Object.entries(squad.models)) {
-      const ratio = totalCalls2 > 0 ? count / totalCalls2 : 0;
-      modelStats[model].input += Math.round(squad.inputTokens * ratio);
-      modelStats[model].output += Math.round(squad.outputTokens * ratio);
-    }
-  }
-  const totalInput = costs.bySquad.reduce((sum, s) => sum + s.inputTokens, 0);
-  const totalOutput = costs.bySquad.reduce((sum, s) => sum + s.outputTokens, 0);
-  const totalCalls = costs.bySquad.reduce((sum, s) => sum + s.calls, 0);
-  const hourlyRate = costs.totalCost;
+  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;
-  const rateLimits = await fetchRateLimits();
-  const hasRealLimits = rateLimits.source === "proxy" && Object.keys(rateLimits.limits).length > 0;
-  if (hasRealLimits) {
-    writeLine(`  ${colors.dim}Rate Limits${RESET} ${colors.green}(live)${RESET}`);
-    for (const [family, limits] of Object.entries(rateLimits.limits)) {
-      const name = family === "opus" ? "opus" : family === "sonnet" ? "sonnet" : family === "haiku" ? "haiku" : family;
-      const reqUsed = limits.requestsLimit - limits.requestsRemaining;
-      const reqPct = limits.requestsLimit > 0 ? reqUsed / limits.requestsLimit * 100 : 0;
-      const reqColor = reqPct > 80 ? colors.red : reqPct > 50 ? colors.yellow : colors.green;
-      const tokUsed = limits.tokensLimit - limits.tokensRemaining;
-      const tokPct = limits.tokensLimit > 0 ? tokUsed / limits.tokensLimit * 100 : 0;
-      const tokColor = tokPct > 80 ? colors.red : tokPct > 50 ? colors.yellow : colors.green;
-      writeLine(`  ${colors.cyan}${padEnd(name, 8)}${RESET} ${reqColor}${String(reqUsed).padStart(4)}${RESET}${colors.dim}/${limits.requestsLimit}req${RESET}  ${tokColor}${formatK(tokUsed)}${RESET}${colors.dim}/${formatK(limits.tokensLimit)}tok${RESET}`);
-    }
-  } else {
-    writeLine(`  ${colors.dim}Rate Limits (Tier ${tier})${RESET}`);
-    const sortedModels = Object.entries(modelStats).sort((a, b) => b[1].calls - a[1].calls);
-    for (const [model, stats] of sortedModels.slice(0, 3)) {
-      const name = modelShortNames[model] || model.split("-").slice(1, 3).join("-");
-      const family = modelToFamily[model] || "sonnet";
-      const limits = tokenLimits[tier]?.[family] || { itpm: 1e6, otpm: 2e5 };
-      const rpmPct = stats.calls / rpmLimit * 100;
-      const rpmColor = rpmPct > 80 ? colors.red : rpmPct > 50 ? colors.yellow : colors.green;
-      writeLine(`  ${colors.cyan}${padEnd(name, 11)}${RESET} ${rpmColor}${String(stats.calls).padStart(4)}${RESET}${colors.dim}rpm${RESET}  ${colors.dim}${formatK(stats.input)}${RESET}${colors.dim}/${formatK(limits.itpm)}i${RESET}  ${colors.dim}${formatK(stats.output)}${RESET}${colors.dim}/${formatK(limits.otpm)}o${RESET}`);
-    }
-  }
-  writeLine();
-  if (costs.totalCachedTokens > 0 || costs.cacheHitRate > 0) {
-    const cacheColor = costs.cacheHitRate > 50 ? colors.green : costs.cacheHitRate > 20 ? colors.yellow : colors.red;
-    writeLine(`  ${colors.dim}Cache:${RESET} ${cacheColor}${costs.cacheHitRate.toFixed(1)}%${RESET} hit rate  ${colors.dim}(${formatK(costs.totalCachedTokens)} cached / ${formatK(costs.totalInputTokens + costs.totalCachedTokens)} total)${RESET}`);
-    writeLine();
-  }
   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}`);
@@ -3251,100 +3916,83 @@ async function renderTokenEconomics(squadNames) {
   }
   writeLine();
 }
-function formatK(n) {
-  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
-  if (n >= 1e3) return (n / 1e3).toFixed(0) + "k";
-  return String(n);
-}
-async function renderHistoricalTrends() {
-  const dbAvailable = await isDatabaseAvailable();
-  if (!dbAvailable) return;
-  const history = await getDashboardHistory(14);
-  if (history.length < 2) return;
-  writeLine(`  ${bold}Usage Trends${RESET} ${colors.dim}(${history.length}d history)${RESET}`);
-  writeLine();
-  const dailyCosts = history.map((h) => h.costUsd).reverse();
-  const costSparkStr = sparkline(dailyCosts);
-  const totalSpend = dailyCosts.reduce((sum, c) => sum + c, 0);
-  const avgDaily = totalSpend / dailyCosts.length;
-  writeLine(`  ${colors.dim}Cost:${RESET} ${costSparkStr}  ${colors.green}$${totalSpend.toFixed(2)}${RESET} total  ${colors.dim}($${avgDaily.toFixed(2)}/day avg)${RESET}`);
-  const inputTokens = history.map((h) => h.inputTokens).reverse();
-  const totalInput = inputTokens.reduce((sum, t) => sum + t, 0);
-  const tokenSparkStr = sparkline(inputTokens);
-  writeLine(`  ${colors.dim}Tokens:${RESET} ${tokenSparkStr}  ${colors.cyan}${formatK(totalInput)}${RESET} input  ${colors.dim}(${formatK(Math.round(totalInput / inputTokens.length))}/day)${RESET}`);
-  const goalProgress = history.map((h) => h.goalProgressPct).reverse();
-  const latestProgress = goalProgress[goalProgress.length - 1] || 0;
-  const earliestProgress = goalProgress[0] || 0;
-  const progressDelta = latestProgress - earliestProgress;
-  const progressColor = progressDelta > 0 ? colors.green : progressDelta < 0 ? colors.red : colors.dim;
-  const progressSign = progressDelta > 0 ? "+" : "";
-  writeLine(`  ${colors.dim}Goals:${RESET} ${sparkline(goalProgress)}  ${colors.purple}${latestProgress}%${RESET}  ${progressColor}${progressSign}${progressDelta.toFixed(0)}%${RESET}${colors.dim} vs start${RESET}`);
-  writeLine();
-}
-async function renderInsights() {
-  const insights = await fetchInsights("week");
-  if (insights.source === "none" || insights.taskMetrics.length === 0) {
+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();
     return;
   }
-  writeLine(`  ${bold}Agent Insights${RESET} ${colors.dim}(${insights.days}d)${RESET}`);
+  writeLine(`  ${bold}Infrastructure${RESET} ${colors.dim}(${stats.source})${RESET}`);
   writeLine();
-  const totals = insights.taskMetrics.reduce(
-    (acc, t) => ({
-      tasks: acc.tasks + t.tasksTotal,
-      completed: acc.completed + t.tasksCompleted,
-      failed: acc.failed + t.tasksFailed,
-      retries: acc.retries + t.totalRetries,
-      withRetries: acc.withRetries + t.tasksWithRetries
-    }),
-    { tasks: 0, completed: 0, failed: 0, retries: 0, withRetries: 0 }
-  );
-  if (totals.tasks > 0) {
-    const successRate = totals.tasks > 0 ? (totals.completed / totals.tasks * 100).toFixed(0) : "0";
-    const successColor = parseInt(successRate) >= 80 ? colors.green : parseInt(successRate) >= 60 ? colors.yellow : colors.red;
-    writeLine(`  ${colors.dim}Tasks:${RESET} ${colors.green}${totals.completed}${RESET}${colors.dim}/${totals.tasks} completed${RESET}  ${successColor}${successRate}%${RESET}${colors.dim} success${RESET}  ${colors.red}${totals.failed}${RESET}${colors.dim} failed${RESET}`);
-    if (totals.retries > 0) {
-      const retryRate = totals.tasks > 0 ? (totals.withRetries / totals.tasks * 100).toFixed(0) : "0";
-      const retryColor = parseInt(retryRate) > 30 ? colors.red : parseInt(retryRate) > 15 ? colors.yellow : colors.green;
-      writeLine(`  ${colors.dim}Retries:${RESET} ${retryColor}${totals.retries}${RESET}${colors.dim} total${RESET}  ${retryColor}${retryRate}%${RESET}${colors.dim} of tasks needed retry${RESET}`);
+  const pgStatus = stats.health.postgres === "connected" ? `${colors.green}\u25CF${RESET}` : `${colors.red}\u25CF${RESET}`;
+  const redisStatus = stats.health.redis === "connected" ? `${colors.green}\u25CF${RESET}` : stats.health.redis === "disabled" ? `${colors.dim}\u25CB${RESET}` : `${colors.red}\u25CF${RESET}`;
+  const otelWorking = stats.health.postgres === "connected" && stats.today.generations > 0;
+  const otelStatus = otelWorking ? `${colors.green}\u25CF${RESET}` : `${colors.dim}\u25CB${RESET}`;
+  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}`);
+    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);
+        return `${colors.dim}${shortName}${RESET} ${colors.cyan}${m.generations}${RESET}`;
+      }).join("  ");
+      writeLine(`  ${colors.dim}Models:${RESET} ${modelLine}`);
     }
   }
-  const qualityTotals = insights.qualityMetrics.reduce(
-    (acc, q) => ({
-      feedback: acc.feedback + q.feedbackCount,
-      qualitySum: acc.qualitySum + q.avgQuality * q.feedbackCount,
-      helpfulSum: acc.helpfulSum + q.helpfulPct * q.feedbackCount / 100,
-      fixSum: acc.fixSum + q.fixRequiredPct * q.feedbackCount / 100
-    }),
-    { feedback: 0, qualitySum: 0, helpfulSum: 0, fixSum: 0 }
-  );
-  if (qualityTotals.feedback > 0) {
-    const avgQuality = qualityTotals.qualitySum / qualityTotals.feedback;
-    const helpfulPct = qualityTotals.helpfulSum / qualityTotals.feedback * 100;
-    const fixPct = qualityTotals.fixSum / qualityTotals.feedback * 100;
-    const qualityColor = avgQuality >= 4 ? colors.green : avgQuality >= 3 ? colors.yellow : colors.red;
-    const stars = "\u2605".repeat(Math.round(avgQuality)) + "\u2606".repeat(5 - Math.round(avgQuality));
-    writeLine(`  ${colors.dim}Quality:${RESET} ${qualityColor}${stars}${RESET} ${colors.dim}(${avgQuality.toFixed(1)}/5)${RESET}  ${colors.green}${helpfulPct.toFixed(0)}%${RESET}${colors.dim} helpful${RESET}  ${fixPct > 20 ? colors.red : colors.dim}${fixPct.toFixed(0)}% needed fixes${RESET}`);
-  }
-  const contextMetrics = insights.taskMetrics.filter((t) => t.avgContextPct > 0);
-  if (contextMetrics.length > 0) {
-    const avgContext = contextMetrics.reduce((sum, t) => sum + t.avgContextPct, 0) / contextMetrics.length;
-    const maxContext = Math.max(...contextMetrics.map((t) => t.maxContextTokens));
-    const contextColor = avgContext < 40 ? colors.green : avgContext < 70 ? colors.yellow : colors.red;
-    const contextStatus = avgContext < 40 ? "lean" : avgContext < 70 ? "moderate" : "heavy";
-    writeLine(`  ${colors.dim}Context:${RESET} ${contextColor}${avgContext.toFixed(0)}%${RESET}${colors.dim} avg utilization (${contextStatus})${RESET}  ${colors.dim}peak ${formatK(maxContext)} tokens${RESET}`);
-  }
-  writeLine();
-  if (insights.topTools.length > 0) {
-    const toolLine = insights.topTools.slice(0, 5).map((t) => {
-      const successColor = t.successRate >= 95 ? colors.green : t.successRate >= 80 ? colors.yellow : colors.red;
-      return `${colors.dim}${t.toolName.replace("mcp__", "").slice(0, 12)}${RESET} ${successColor}${t.successRate.toFixed(0)}%${RESET}`;
-    }).join("  ");
-    writeLine(`  ${colors.dim}Tools:${RESET} ${toolLine}`);
-    if (insights.toolFailureRate > 5) {
-      writeLine(`  ${colors.yellow}\u26A0${RESET} ${colors.yellow}${insights.toolFailureRate.toFixed(1)}% tool failure rate${RESET}`);
-    }
-    writeLine();
+  if (stats.week && stats.week.generations > 0) {
+    const weekModelLine = stats.week.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);
+      return `${colors.dim}${shortName}${RESET} ${colors.purple}$${m.costUsd.toFixed(0)}${RESET}`;
+    }).join("  ") || "";
+    writeLine(`  ${colors.dim}Week:${RESET}  ${colors.cyan}${stats.week.generations}${RESET}${colors.dim} calls${RESET}  ${colors.purple}$${stats.week.costUsd.toFixed(2)}${RESET}  ${weekModelLine}`);
   }
+  writeLine();
+}
+async function saveSnapshotCached(squadData, cache, baseDir) {
+  if (!cache.dbAvailable) return;
+  const { gitStats, ghStats, costs } = cache;
+  const squadsData = squadData.map((s) => ({
+    name: s.name,
+    commits: s.github?.commits || 0,
+    prsOpened: s.github?.prsOpened || 0,
+    prsMerged: s.github?.prsMerged || 0,
+    issuesClosed: s.github?.issuesClosed || 0,
+    issuesOpen: s.github?.issuesOpen || 0,
+    goalsActive: s.goals.filter((g) => !g.completed).length,
+    goalsTotal: s.goals.length,
+    progress: s.goalProgress
+  }));
+  const authorsData = gitStats ? Array.from(gitStats.commitsByAuthor.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, commits]) => ({ name, commits })) : [];
+  const reposData = gitStats ? Array.from(gitStats.commitsByRepo.entries()).sort((a, b) => b[1] - a[1]).map(([name, commits]) => ({ name, commits })) : [];
+  const totalInputTokens = costs?.bySquad.reduce((sum, s) => sum + s.inputTokens, 0) || 0;
+  const totalOutputTokens = costs?.bySquad.reduce((sum, s) => sum + s.outputTokens, 0) || 0;
+  const overallProgress = squadData.length > 0 ? Math.round(squadData.reduce((sum, s) => sum + s.goalProgress, 0) / squadData.length) : 0;
+  const snapshot = {
+    totalSquads: squadData.length,
+    totalCommits: gitStats?.totalCommits || 0,
+    totalPrsMerged: ghStats?.prsMerged || 0,
+    totalIssuesClosed: ghStats?.issuesClosed || 0,
+    totalIssuesOpen: ghStats?.issuesOpen || 0,
+    goalProgressPct: overallProgress,
+    costUsd: costs?.totalCost || 0,
+    dailyBudgetUsd: costs?.dailyBudget || 50,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    commits30d: gitStats?.totalCommits || 0,
+    avgCommitsPerDay: gitStats?.avgCommitsPerDay || 0,
+    activeDays: gitStats?.activeDays || 0,
+    peakCommits: gitStats?.peakDay?.count || 0,
+    peakDate: gitStats?.peakDay?.date || null,
+    squadsData,
+    authorsData,
+    reposData
+  };
+  const saveTimeout = new Promise((resolve) => setTimeout(resolve, 2e3));
+  await Promise.race([saveDashboardSnapshot(snapshot), saveTimeout]);
 }
 var P0_KEYWORDS = ["revenue", "first", "launch", "publish", "ship", "critical", "urgent"];
 var P1_KEYWORDS = ["track", "establish", "identify", "define", "fix"];
@@ -3453,9 +4101,62 @@ async function renderCeoReport(squadsDir) {
   writeLine(`  ${colors.dim}$${RESET} squads goal list         ${colors.dim}All active goals${RESET}`);
   writeLine();
 }
+function renderHistoricalTrendsCached(cache) {
+  if (!cache.dbAvailable) return;
+  const history = cache.history;
+  if (history.length < 2) return;
+  writeLine(`  ${bold}Usage Trends${RESET} ${colors.dim}(${history.length}d history)${RESET}`);
+  writeLine();
+  const dailyCosts = history.map((h) => h.costUsd).reverse();
+  const costSparkStr = sparkline(dailyCosts);
+  const totalSpend = dailyCosts.reduce((sum, c) => sum + c, 0);
+  const avgDaily = totalSpend / dailyCosts.length;
+  writeLine(`  ${colors.dim}Cost:${RESET} ${costSparkStr}  ${colors.green}$${totalSpend.toFixed(2)}${RESET} total  ${colors.dim}($${avgDaily.toFixed(2)}/day avg)${RESET}`);
+  const inputTokens = history.map((h) => h.inputTokens).reverse();
+  const totalInput = inputTokens.reduce((sum, t) => sum + t, 0);
+  const tokenSparkStr = sparkline(inputTokens);
+  writeLine(`  ${colors.dim}Tokens:${RESET} ${tokenSparkStr}  ${colors.cyan}${formatK(totalInput)}${RESET} input  ${colors.dim}(${formatK(Math.round(totalInput / inputTokens.length))}/day)${RESET}`);
+  const goalProgress = history.map((h) => h.goalProgressPct).reverse();
+  const latestProgress = goalProgress[goalProgress.length - 1] || 0;
+  const earliestProgress = goalProgress[0] || 0;
+  const progressDelta = latestProgress - earliestProgress;
+  const progressColor = progressDelta > 0 ? colors.green : progressDelta < 0 ? colors.red : colors.dim;
+  const progressSign = progressDelta > 0 ? "+" : "";
+  writeLine(`  ${colors.dim}Goals:${RESET} ${sparkline(goalProgress)}  ${colors.purple}${latestProgress}%${RESET}  ${progressColor}${progressSign}${progressDelta.toFixed(0)}%${RESET}${colors.dim} vs start${RESET}`);
+  writeLine();
+}
+function renderInsightsCached(cache) {
+  const insights = cache.insights;
+  if (!insights || insights.source === "none" || insights.taskMetrics.length === 0) {
+    return;
+  }
+  writeLine(`  ${bold}Agent Insights${RESET} ${colors.dim}(${insights.days}d)${RESET}`);
+  writeLine();
+  const totals = insights.taskMetrics.reduce(
+    (acc, t) => ({
+      tasks: acc.tasks + t.tasksTotal,
+      completed: acc.completed + t.tasksCompleted,
+      failed: acc.failed + t.tasksFailed,
+      retries: acc.retries + t.totalRetries,
+      withRetries: acc.withRetries + t.tasksWithRetries
+    }),
+    { tasks: 0, completed: 0, failed: 0, retries: 0, withRetries: 0 }
+  );
+  if (totals.tasks > 0) {
+    const successRate = totals.tasks > 0 ? (totals.completed / totals.tasks * 100).toFixed(0) : "0";
+    const successColor = parseInt(successRate) >= 80 ? colors.green : parseInt(successRate) >= 60 ? colors.yellow : colors.red;
+    writeLine(`  ${colors.dim}Tasks:${RESET} ${colors.green}${totals.completed}${RESET}${colors.dim}/${totals.tasks} completed${RESET}  ${successColor}${successRate}%${RESET}${colors.dim} success${RESET}  ${colors.red}${totals.failed}${RESET}${colors.dim} failed${RESET}`);
+    if (totals.retries > 0) {
+      const retryRate = totals.tasks > 0 ? (totals.withRetries / totals.tasks * 100).toFixed(0) : "0";
+      const retryColor = parseInt(retryRate) > 30 ? colors.red : parseInt(retryRate) > 15 ? colors.yellow : colors.green;
+      writeLine(`  ${colors.dim}Retries:${RESET} ${retryColor}${totals.retries}${RESET}${colors.dim} total${RESET}  ${retryColor}${retryRate}%${RESET}${colors.dim} of tasks needed retry${RESET}`);
+    }
+  }
+  writeLine();
+}
 
 // src/commands/issues.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var DEFAULT_ORG = "agents-squads";
 var DEFAULT_REPOS = ["hq", "agents-squads-web", "squads-cli"];
 async function issuesCommand(options = {}) {
@@ -3465,7 +4166,7 @@ async function issuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}issues${RESET}`);
   writeLine();
   try {
-    execSync3("gh --version", { stdio: "pipe" });
+    execSync5("gh --version", { stdio: "pipe" });
   } catch {
     writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
     writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
@@ -3476,7 +4177,7 @@ async function issuesCommand(options = {}) {
   let totalOpen = 0;
   for (const repo of repos) {
     try {
-      const result = execSync3(
+      const result = execSync5(
         `gh issue list -R ${org}/${repo} --state open --json number,title,state,labels,createdAt --limit 50`,
         { stdio: "pipe", encoding: "utf-8" }
       );
@@ -3527,7 +4228,7 @@ async function issuesCommand(options = {}) {
 }
 
 // src/commands/solve-issues.ts
-import { execSync as execSync4, spawn as spawn2 } from "child_process";
+import { execSync as execSync6, spawn as spawn2 } from "child_process";
 import ora3 from "ora";
 var DEFAULT_ORG2 = "agents-squads";
 var DEFAULT_REPOS2 = ["hq", "agents-squads-web", "squads-cli", "agents-squads"];
@@ -3537,7 +4238,7 @@ async function solveIssuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}solve-issues${RESET}`);
   writeLine();
   try {
-    execSync4("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}`);
@@ -3547,7 +4248,7 @@ async function solveIssuesCommand(options = {}) {
   if (options.issue) {
     const repo = options.repo || "hq";
     try {
-      const result = execSync4(
+      const result = execSync6(
         `gh issue view ${options.issue} -R ${DEFAULT_ORG2}/${repo} --json number,title,labels,body`,
         { stdio: "pipe", encoding: "utf-8" }
       );
@@ -3560,7 +4261,7 @@ async function solveIssuesCommand(options = {}) {
   } else {
     for (const repo of repos) {
       try {
-        const result = execSync4(
+        const result = execSync6(
           `gh issue list -R ${DEFAULT_ORG2}/${repo} --label "ready-to-fix" --state open --json number,title,labels --limit 20`,
           { stdio: "pipe", encoding: "utf-8" }
         );
@@ -3614,7 +4315,7 @@ function showSolveInstructions(issues) {
 async function solveWithClaude(issues) {
   const spinner = ora3("Starting issue solver...").start();
   try {
-    execSync4("which claude", { stdio: "pipe" });
+    execSync6("which claude", { stdio: "pipe" });
   } catch {
     spinner.fail("Claude CLI not found");
     writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
@@ -3700,9 +4401,9 @@ function executeClaudePrompt(prompt) {
 }
 
 // src/commands/open-issues.ts
-import { execSync as execSync5, spawn as spawn3 } from "child_process";
-import { readdirSync as readdirSync6 } from "fs";
-import { join as join10 } from "path";
+import { execSync as execSync7, spawn as spawn3 } from "child_process";
+import { readdirSync as readdirSync7 } from "fs";
+import { join as join12 } from "path";
 import ora4 from "ora";
 var ISSUE_FINDER_PATTERNS = [
   "*-eval.md",
@@ -3757,10 +4458,10 @@ async function openIssuesCommand(options = {}) {
 }
 function findEvalAgents(squadsDir, filterSquad) {
   const agents = [];
-  const squads = readdirSync6(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => !filterSquad || d.name === filterSquad).map((d) => d.name);
+  const squads = readdirSync7(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => !filterSquad || d.name === filterSquad).map((d) => d.name);
   for (const squad of squads) {
-    const squadPath = join10(squadsDir, squad);
-    const files = readdirSync6(squadPath).filter((f) => f.endsWith(".md"));
+    const squadPath = join12(squadsDir, squad);
+    const files = readdirSync7(squadPath).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const isEval = ISSUE_FINDER_PATTERNS.some((pattern) => {
         const regex = new RegExp("^" + pattern.replace("*", ".*") + "$");
@@ -3770,7 +4471,7 @@ function findEvalAgents(squadsDir, filterSquad) {
         agents.push({
           name: file,
           squad,
-          path: join10(squadPath, file)
+          path: join12(squadPath, file)
         });
       }
     }
@@ -3796,7 +4497,7 @@ function showRunInstructions(agents) {
 async function runEvaluators(agents) {
   const spinner = ora4("Starting evaluators...").start();
   try {
-    execSync5("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}`);
@@ -3880,9 +4581,9 @@ import open from "open";
 
 // src/lib/auth.ts
 import { createClient } from "@supabase/supabase-js";
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir4 } from "os";
 import http from "http";
 var PERSONAL_DOMAINS = [
   "gmail.com",
@@ -3910,8 +4611,8 @@ var PERSONAL_DOMAINS = [
   "tutanota.com",
   "hey.com"
 ];
-var AUTH_DIR = join11(homedir3(), ".squads-cli");
-var AUTH_PATH = join11(AUTH_DIR, "auth.json");
+var AUTH_DIR = join13(homedir4(), ".squads-cli");
+var AUTH_PATH = join13(AUTH_DIR, "auth.json");
 function isPersonalEmail(email) {
   const domain = email.split("@")[1]?.toLowerCase();
   return PERSONAL_DOMAINS.includes(domain);
@@ -3919,23 +4620,23 @@ function isPersonalEmail(email) {
 function getEmailDomain(email) {
   return email.split("@")[1]?.toLowerCase() || "";
 }
-function saveSession(session) {
-  if (!existsSync11(AUTH_DIR)) {
-    mkdirSync6(AUTH_DIR, { recursive: true });
+function saveSession(session2) {
+  if (!existsSync13(AUTH_DIR)) {
+    mkdirSync8(AUTH_DIR, { recursive: true });
   }
-  writeFileSync7(AUTH_PATH, JSON.stringify(session, null, 2));
+  writeFileSync9(AUTH_PATH, JSON.stringify(session2, null, 2));
 }
 function loadSession() {
-  if (!existsSync11(AUTH_PATH)) return null;
+  if (!existsSync13(AUTH_PATH)) return null;
   try {
-    return JSON.parse(readFileSync8(AUTH_PATH, "utf-8"));
+    return JSON.parse(readFileSync10(AUTH_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearSession() {
-  if (existsSync11(AUTH_PATH)) {
-    writeFileSync7(AUTH_PATH, "");
+  if (existsSync13(AUTH_PATH)) {
+    writeFileSync9(AUTH_PATH, "");
   }
 }
 function startAuthCallbackServer(port = 54321) {
@@ -4032,7 +4733,7 @@ ${chalk2.dim("Want to stay updated?")}
       await track("cli.login.personal_email", { domain: getEmailDomain(email) });
       return;
     }
-    const session = {
+    const session2 = {
       email,
       domain: getEmailDomain(email),
       status: "pending",
@@ -4040,9 +4741,9 @@ ${chalk2.dim("Want to stay updated?")}
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       accessToken: token
     };
-    saveSession(session);
+    saveSession(session2);
     spinner.succeed(`Logged in as ${chalk2.cyan(email)}`);
-    await track("cli.login.success", { domain: session.domain });
+    await track("cli.login.success", { domain: session2.domain });
     console.log(`
 ${chalk2.green("\u2713 Thanks for signing up!")}
 
@@ -4064,18 +4765,18 @@ ${chalk2.dim("Questions? Email us at")} ${chalk2.cyan("hello@agents-squads.com")
   }
 }
 async function logoutCommand() {
-  const session = loadSession();
-  if (!session) {
+  const session2 = loadSession();
+  if (!session2) {
     console.log(chalk2.yellow("Not logged in."));
     return;
   }
   clearSession();
-  console.log(chalk2.green(`\u2713 Logged out from ${session.email}`));
+  console.log(chalk2.green(`\u2713 Logged out from ${session2.email}`));
   await track("cli.logout");
 }
 async function whoamiCommand() {
-  const session = loadSession();
-  if (!session) {
+  const session2 = loadSession();
+  if (!session2) {
     console.log(chalk2.yellow("Not logged in."));
     console.log(chalk2.dim("Run: squads login"));
     return;
@@ -4083,34 +4784,100 @@ async function whoamiCommand() {
   console.log(`
 ${chalk2.bold("Current Session")}
 ${chalk2.dim("\u2500".repeat(30))}
-Email:   ${chalk2.cyan(session.email)}
-Domain:  ${session.domain}
-Status:  ${session.status === "active" ? chalk2.green("Active") : chalk2.yellow("Pending")}
-Since:   ${new Date(session.createdAt).toLocaleDateString()}
+Email:   ${chalk2.cyan(session2.email)}
+Domain:  ${session2.domain}
+Status:  ${session2.status === "active" ? chalk2.green("Active") : chalk2.yellow("Pending")}
+Since:   ${new Date(session2.createdAt).toLocaleDateString()}
 `);
 }
 
+// src/commands/update.ts
+import { createInterface as createInterface2 } from "readline";
+async function confirm(message) {
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`  ${message} [y/N]: `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function updateCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}update${RESET}`);
+  writeLine();
+  if (options.check) {
+    writeLine(`  ${colors.dim}Checking for updates...${RESET}`);
+    const info2 = refreshVersionCache();
+    writeLine();
+    if (info2.updateAvailable) {
+      writeLine(`  ${colors.cyan}\u2B06${RESET} Update available: ${colors.dim}${info2.currentVersion}${RESET} \u2192 ${colors.green}${info2.latestVersion}${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}Run \`squads update\` to install${RESET}`);
+    } else {
+      writeLine(`  ${colors.green}${icons.success}${RESET} Already on latest version ${colors.cyan}${info2.currentVersion}${RESET}`);
+    }
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.dim}Checking npm registry...${RESET}`);
+  const info = refreshVersionCache();
+  if (!info.updateAvailable) {
+    writeLine();
+    writeLine(`  ${colors.green}${icons.success}${RESET} Already on latest version ${colors.cyan}${info.currentVersion}${RESET}`);
+    writeLine();
+    return;
+  }
+  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 confirm("Update now?");
+  if (!shouldUpdate) {
+    writeLine();
+    writeLine(`  ${colors.dim}Update skipped${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}Installing update...${RESET}`);
+  writeLine();
+  const result = performUpdate();
+  writeLine();
+  if (result.success) {
+    writeLine(`  ${colors.green}${icons.success}${RESET} Updated to ${colors.green}${info.latestVersion}${RESET}`);
+    writeLine(`  ${colors.dim}Restart your terminal to use the new version${RESET}`);
+  } else {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Update failed: ${result.error}`);
+    writeLine(`  ${colors.dim}Try manually: npm update -g squads-cli${RESET}`);
+    process.exitCode = 1;
+  }
+  writeLine();
+}
+
 // src/commands/progress.ts
-import { execSync as execSync6 } from "child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9 } from "fs";
+import { join as join14 } from "path";
 function getTasksFilePath() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     const cwd = process.cwd();
-    const agentsDir = join12(cwd, ".agents");
-    if (!existsSync12(agentsDir)) {
-      mkdirSync7(agentsDir, { recursive: true });
+    const agentsDir = join14(cwd, ".agents");
+    if (!existsSync14(agentsDir)) {
+      mkdirSync9(agentsDir, { recursive: true });
     }
-    return join12(agentsDir, "tasks.json");
+    return join14(agentsDir, "tasks.json");
   }
-  return join12(memoryDir, "..", "tasks.json");
+  return join14(memoryDir, "..", "tasks.json");
 }
 function loadTasks() {
   const tasksPath = getTasksFilePath();
-  if (existsSync12(tasksPath)) {
+  if (existsSync14(tasksPath)) {
     try {
-      return JSON.parse(readFileSync9(tasksPath, "utf-8"));
+      return JSON.parse(readFileSync11(tasksPath, "utf-8"));
     } catch {
       return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
     }
@@ -4120,7 +4887,7 @@ function loadTasks() {
 function saveTasks(data) {
   const tasksPath = getTasksFilePath();
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync8(tasksPath, JSON.stringify(data, null, 2));
+  writeFileSync10(tasksPath, JSON.stringify(data, null, 2));
 }
 function getRecentActivity() {
   const activity = [];
@@ -4136,7 +4903,7 @@ function getRecentActivity() {
     marketing: ["marketing", "content", "social"]
   };
   try {
-    const logOutput = execSync6(
+    const logOutput = execSync8(
       'git log --since="24 hours ago" --format="%h|%aI|%s" 2>/dev/null',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -4270,7 +5037,7 @@ function getElapsedTime(startTime) {
 }
 
 // src/commands/results.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 function getGitStats(days = 7) {
   const stats = /* @__PURE__ */ new Map();
   const squadKeywords = {
@@ -4285,7 +5052,7 @@ function getGitStats(days = 7) {
     marketing: ["marketing"]
   };
   try {
-    const logOutput = execSync7(
+    const logOutput = execSync9(
       `git log --since="${days} days ago" --format="%s" --name-only 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -4324,7 +5091,7 @@ function getGitHubStats2(days = 7) {
   const prsMerged = /* @__PURE__ */ new Map();
   const issuesClosed = /* @__PURE__ */ new Map();
   try {
-    const prsOutput = execSync7(
+    const prsOutput = execSync9(
       `gh pr list --state all --json title,createdAt,mergedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -4339,7 +5106,7 @@ function getGitHubStats2(days = 7) {
         prsMerged.set(squad, (prsMerged.get(squad) || 0) + 1);
       }
     }
-    const issuesOutput = execSync7(
+    const issuesOutput = execSync9(
       `gh issue list --state closed --json title,closedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -4471,19 +5238,19 @@ async function resultsCommand(options = {}) {
 }
 
 // src/commands/workers.ts
-import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { execSync as execSync10 } from "child_process";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join15 } from "path";
 function getTasksFilePath2() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join13(memoryDir, "..", "tasks.json");
+  return join15(memoryDir, "..", "tasks.json");
 }
 function loadActiveTasks() {
   const tasksPath = getTasksFilePath2();
-  if (!tasksPath || !existsSync13(tasksPath)) return [];
+  if (!tasksPath || !existsSync15(tasksPath)) return [];
   try {
-    const data = JSON.parse(readFileSync10(tasksPath, "utf-8"));
+    const data = JSON.parse(readFileSync12(tasksPath, "utf-8"));
     return data.tasks?.filter((t) => t.status === "active") || [];
   } catch {
     return [];
@@ -4492,7 +5259,7 @@ function loadActiveTasks() {
 function getRunningProcesses() {
   const processes = [];
   try {
-    const psOutput = execSync8(
+    const psOutput = execSync10(
       'ps aux | grep -E "claude|squads|astro|node.*agent" | grep -v grep',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -4543,7 +5310,7 @@ async function workersCommand(options = {}) {
   writeLine();
   if (options.kill) {
     try {
-      execSync8(`kill ${options.kill}`, { stdio: "pipe" });
+      execSync10(`kill ${options.kill}`, { stdio: "pipe" });
       writeLine(`  ${icons.success} Killed process ${colors.cyan}${options.kill}${RESET}`);
       writeLine();
       return;
@@ -4629,26 +5396,689 @@ function getElapsedTime2(startTime) {
   return "<1m";
 }
 
+// src/commands/sessions.ts
+async function sessionsCommand(options = {}) {
+  cleanupStaleSessions();
+  const sessions2 = getActiveSessions();
+  const summary = getSessionSummary();
+  if (options.json) {
+    console.log(JSON.stringify({ sessions: sessions2, summary }, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sessions${RESET}`);
+  writeLine();
+  if (sessions2.length === 0) {
+    writeLine(`  ${colors.dim}No active sessions${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Sessions are tracked automatically when Claude Code runs.${RESET}`);
+    writeLine(`  ${colors.dim}Each session updates its heartbeat via squads CLI commands.${RESET}`);
+    writeLine();
+    return;
+  }
+  const squadText = summary.squadCount === 1 ? "squad" : "squads";
+  const sessionText = summary.totalSessions === 1 ? "session" : "sessions";
+  writeLine(`  ${colors.green}${summary.totalSessions}${RESET} active ${sessionText} ${colors.dim}across${RESET} ${colors.cyan}${summary.squadCount}${RESET} ${squadText}`);
+  writeLine();
+  const bySquad = {};
+  for (const session2 of sessions2) {
+    const squad = session2.squad || "unknown";
+    if (!bySquad[squad]) bySquad[squad] = [];
+    bySquad[squad].push(session2);
+  }
+  const w = { squad: 16, sessions: 10, activity: 14 };
+  const tableWidth = w.squad + w.sessions + w.activity + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("SESSIONS", w.sessions)}${RESET}${bold}LAST ACTIVITY${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const [squad, squadSessions] of Object.entries(bySquad).sort()) {
+    let mostRecent = 0;
+    for (const session2 of squadSessions) {
+      const ts = new Date(session2.lastHeartbeat).getTime();
+      if (ts > mostRecent) mostRecent = ts;
+    }
+    const lastActivity = formatTimeAgo(mostRecent);
+    const activityColor = getActivityColor(mostRecent);
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(String(squadSessions.length), w.sessions)}${padEnd(`${activityColor}${lastActivity}${RESET}`, w.activity)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  if (options.verbose) {
+    writeLine();
+    writeLine(`  ${bold}Session Details${RESET}`);
+    writeLine();
+    for (const session2 of sessions2) {
+      const squad = session2.squad || "unknown";
+      const ago = formatTimeAgo(new Date(session2.lastHeartbeat).getTime());
+      writeLine(`  ${icons.active} ${colors.white}${session2.sessionId}${RESET}`);
+      writeLine(`    ${colors.dim}squad: ${squad} | pid: ${session2.pid} | heartbeat: ${ago}${RESET}`);
+      writeLine(`    ${colors.dim}cwd: ${session2.cwd}${RESET}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads sessions -v    ${colors.dim}Show session details${RESET}`);
+  writeLine();
+}
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  if (minutes >= 1) {
+    return `${minutes}m ago`;
+  }
+  return `${seconds}s ago`;
+}
+function getActivityColor(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minutes = Math.floor(diff / (1e3 * 60));
+  if (minutes < 1) return colors.green;
+  if (minutes < 3) return colors.yellow;
+  return colors.dim;
+}
+async function sessionsHistoryCommand(options = {}) {
+  const days = options.days || 7;
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+  const stats = await getSessionHistoryStats({
+    since,
+    squad: options.squad
+  });
+  const recentSessions = await getRecentSessions(10);
+  if (options.json) {
+    console.log(JSON.stringify({ stats, recentSessions }, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sessions history${RESET} ${colors.dim}(${days}d)${RESET}`);
+  writeLine();
+  if (stats.totalSessions === 0) {
+    writeLine(`  ${colors.dim}No session history found${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Session events are logged to .agents/sessions/history.jsonl${RESET}`);
+    writeLine();
+    return;
+  }
+  const avgMinutes = Math.round(stats.avgDurationMs / 6e4);
+  const totalHours = Math.round(stats.totalDurationMs / 36e5 * 10) / 10;
+  writeLine(`  ${bold}Summary${RESET}`);
+  writeLine(`  ${colors.cyan}${stats.totalSessions}${RESET} sessions  ${colors.dim}\u2502${RESET}  ${colors.green}${totalHours}h${RESET} total  ${colors.dim}\u2502${RESET}  ${colors.yellow}${avgMinutes}m${RESET} avg  ${colors.dim}\u2502${RESET}  ${colors.purple}${stats.peakConcurrent}${RESET} peak`);
+  writeLine();
+  const squads = Object.entries(stats.bySquad).sort((a, b) => b[1].count - a[1].count);
+  if (squads.length > 0) {
+    const w = { squad: 16, sessions: 10, duration: 12 };
+    const tableWidth = w.squad + w.sessions + w.duration + 4;
+    writeLine(`  ${bold}By Squad${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("SESSIONS", w.sessions)}${RESET}${bold}DURATION${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(header);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const [squad, data] of squads) {
+      const hours = Math.round(data.durationMs / 36e5 * 10) / 10;
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(String(data.count), w.sessions)}${padEnd(`${hours}h`, w.duration)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  }
+  if (recentSessions.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Recent Sessions${RESET}`);
+    writeLine();
+    for (const event of recentSessions.slice(0, 5)) {
+      const squad = event.squad || "unknown";
+      const date = new Date(event.ts);
+      const timeStr = date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+      const dateStr = date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+      writeLine(`  ${colors.dim}${dateStr} ${timeStr}${RESET}  ${colors.cyan}${squad}${RESET}  ${colors.dim}${event.sessionId.slice(0, 8)}${RESET}`);
+    }
+  }
+  const dates = Object.entries(stats.byDate).sort((a, b) => b[0].localeCompare(a[0])).slice(0, 7);
+  if (dates.length > 1) {
+    writeLine();
+    writeLine(`  ${bold}Daily Activity${RESET}`);
+    writeLine();
+    for (const [date, count] of dates) {
+      const bar = "\u2588".repeat(Math.min(count, 20));
+      writeLine(`  ${colors.dim}${date}${RESET}  ${colors.green}${bar}${RESET} ${count}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads sessions history --days 30   ${colors.dim}Longer history${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads sessions history -s website  ${colors.dim}Filter by squad${RESET}`);
+  writeLine();
+}
+
+// src/commands/session.ts
+async function sessionStartCommand(options = {}) {
+  cleanupStaleSessions();
+  const session2 = startSession(options.squad);
+  if (!options.quiet) {
+    if (session2) {
+      writeLine(`${icons.active} Session started: ${colors.cyan}${session2.sessionId}${RESET}`);
+      if (session2.squad) {
+        writeLine(`  ${colors.dim}Squad: ${session2.squad}${RESET}`);
+      }
+    } else {
+      writeLine(`${colors.yellow}Could not start session (no .agents directory)${RESET}`);
+    }
+  }
+}
+async function sessionStopCommand(options = {}) {
+  const stopped = stopSession();
+  if (!options.quiet) {
+    if (stopped) {
+      writeLine(`${icons.progress} Session stopped`);
+    } else {
+      writeLine(`${colors.dim}No active session to stop${RESET}`);
+    }
+  }
+}
+async function sessionHeartbeatCommand(options = {}) {
+  const updated = updateHeartbeat();
+  if (!options.quiet) {
+    if (updated) {
+      writeLine(`${icons.active} Heartbeat updated`);
+    } else {
+      writeLine(`${colors.dim}No session to update${RESET}`);
+    }
+  }
+}
+async function detectSquadCommand() {
+  const squad = detectSquad();
+  if (squad) {
+    process.stdout.write(squad);
+  }
+}
+
+// src/commands/stack.ts
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir5 } from "os";
+import { execSync as execSync11, spawn as spawn4 } from "child_process";
+var DEFAULT_CONFIG = {
+  SQUADS_DATABASE_URL: "postgresql://squads:squads@localhost:5433/squads",
+  SQUADS_BRIDGE_URL: "http://localhost:8088",
+  LANGFUSE_HOST: "http://localhost:3100",
+  LANGFUSE_PUBLIC_KEY: "",
+  LANGFUSE_SECRET_KEY: "",
+  REDIS_URL: "redis://localhost:6379"
+};
+var CONFIG_PATH2 = join16(homedir5(), ".squadsrc");
+function loadStackConfig() {
+  if (!existsSync16(CONFIG_PATH2)) {
+    return null;
+  }
+  try {
+    const content = readFileSync13(CONFIG_PATH2, "utf-8");
+    const config2 = {};
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = trimmed.match(/^export\s+(\w+)=["']?([^"'\n]*)["']?$/);
+      if (match) {
+        const [, key, value] = match;
+        if (key in DEFAULT_CONFIG) {
+          config2[key] = value;
+        }
+      }
+    }
+    return config2;
+  } catch {
+    return null;
+  }
+}
+function saveStackConfig(config2) {
+  const lines = [
+    "# Squads CLI Local Stack Configuration",
+    "# Generated by: squads stack init",
+    `# Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    "",
+    "# Database",
+    `export SQUADS_DATABASE_URL="${config2.SQUADS_DATABASE_URL}"`,
+    "",
+    "# Bridge API",
+    `export SQUADS_BRIDGE_URL="${config2.SQUADS_BRIDGE_URL}"`,
+    "",
+    "# Langfuse",
+    `export LANGFUSE_HOST="${config2.LANGFUSE_HOST}"`,
+    `export LANGFUSE_PUBLIC_KEY="${config2.LANGFUSE_PUBLIC_KEY}"`,
+    `export LANGFUSE_SECRET_KEY="${config2.LANGFUSE_SECRET_KEY}"`,
+    "",
+    "# Redis",
+    `export REDIS_URL="${config2.REDIS_URL}"`,
+    "",
+    "# To activate: source ~/.squadsrc",
+    ""
+  ];
+  writeFileSync11(CONFIG_PATH2, lines.join("\n"));
+}
+function applyStackConfig() {
+  const config2 = loadStackConfig();
+  if (!config2) return;
+  for (const [key, value] of Object.entries(config2)) {
+    if (value && !process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+function isDockerRunning() {
+  try {
+    execSync11("docker info", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getContainerStatus(name) {
+  try {
+    const runningOutput = execSync11(
+      `docker inspect ${name} --format '{{.State.Running}}'`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    ).trim();
+    const running = runningOutput === "true";
+    if (!running) {
+      return { name, running: false, healthy: false };
+    }
+    let port;
+    try {
+      const portOutput = execSync11(
+        `docker inspect ${name} --format '{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}'`,
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+      ).trim();
+      port = portOutput || void 0;
+    } catch {
+    }
+    let healthy = true;
+    try {
+      const healthOutput = execSync11(
+        `docker inspect ${name} --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}'`,
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+      ).trim();
+      if (healthOutput === "healthy" || healthOutput === "none") {
+        healthy = true;
+      } else if (healthOutput === "starting") {
+        healthy = false;
+      } else {
+        healthy = false;
+      }
+    } catch {
+      healthy = true;
+    }
+    return { name, running, healthy, port };
+  } catch {
+    return { name, running: false, healthy: false };
+  }
+}
+async function checkService(url, timeout = 2e3) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function getLangfuseKeysFromDockerEnv() {
+  const envPaths2 = [
+    join16(process.cwd(), "docker", ".env"),
+    join16(process.cwd(), "..", "squads-cli", "docker", ".env"),
+    join16(homedir5(), "agents-squads", "squads-cli", "docker", ".env")
+  ];
+  for (const envPath of envPaths2) {
+    if (existsSync16(envPath)) {
+      const content = readFileSync13(envPath, "utf-8");
+      const publicMatch = content.match(/LANGFUSE_PUBLIC_KEY=(\S+)/);
+      const secretMatch = content.match(/LANGFUSE_SECRET_KEY=(\S+)/);
+      if (publicMatch && secretMatch) {
+        return {
+          publicKey: publicMatch[1],
+          secretKey: secretMatch[1]
+        };
+      }
+    }
+  }
+  return null;
+}
+function findDockerComposeDir() {
+  const candidates = [
+    join16(process.cwd(), "docker"),
+    join16(process.cwd(), "..", "squads-cli", "docker"),
+    join16(homedir5(), "agents-squads", "squads-cli", "docker")
+  ];
+  for (const dir of candidates) {
+    if (existsSync16(join16(dir, "docker-compose.yml"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function stackInitCommand() {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack init${RESET}`);
+  writeLine();
+  if (!isDockerRunning()) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Docker is not running`);
+    writeLine(`  ${colors.dim}Start Docker Desktop and try again${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.green}${icons.success}${RESET} Docker is running`);
+  const containers = [
+    "squads-postgres",
+    "squads-redis",
+    "squads-bridge",
+    "squads-langfuse",
+    "squads-otel-collector"
+  ];
+  const statuses = containers.map(getContainerStatus);
+  const allRunning = statuses.every((s) => s.running);
+  writeLine();
+  writeLine(`  ${bold}Containers${RESET}`);
+  for (const status of statuses) {
+    const icon = status.running ? status.healthy ? `${colors.green}\u25CF${RESET}` : `${colors.yellow}\u25CF${RESET}` : `${colors.red}\u25CB${RESET}`;
+    const portInfo = status.port ? `${colors.dim}:${status.port}${RESET}` : "";
+    writeLine(`  ${icon} ${status.name}${portInfo}`);
+  }
+  if (!allRunning) {
+    writeLine();
+    writeLine(`  ${colors.yellow}${icons.warning}${RESET} Some containers not running`);
+    writeLine(`  ${colors.dim}Run: squads stack up${RESET}`);
+    writeLine();
+    return;
+  }
+  const langfuseKeys = getLangfuseKeysFromDockerEnv();
+  const config2 = {
+    ...DEFAULT_CONFIG,
+    LANGFUSE_PUBLIC_KEY: langfuseKeys?.publicKey || "",
+    LANGFUSE_SECRET_KEY: langfuseKeys?.secretKey || ""
+  };
+  writeLine();
+  writeLine(`  ${bold}Testing connections${RESET}`);
+  const bridgeOk = await checkService(`${config2.SQUADS_BRIDGE_URL}/health`);
+  const langfuseOk = await checkService(`${config2.LANGFUSE_HOST}/api/public/health`);
+  writeLine(
+    `  ${bridgeOk ? colors.green + icons.success : colors.red + icons.error}${RESET} Bridge ${colors.dim}${config2.SQUADS_BRIDGE_URL}${RESET}`
+  );
+  writeLine(
+    `  ${langfuseOk ? colors.green + icons.success : colors.red + icons.error}${RESET} Langfuse ${colors.dim}${config2.LANGFUSE_HOST}${RESET}`
+  );
+  saveStackConfig(config2);
+  writeLine();
+  writeLine(`  ${colors.green}${icons.success}${RESET} Config saved to ${colors.cyan}~/.squadsrc${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}To activate in current shell:${RESET}`);
+  writeLine(`  ${colors.cyan}source ~/.squadsrc${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Or add to your ~/.zshrc:${RESET}`);
+  writeLine(`  ${colors.cyan}[ -f ~/.squadsrc ] && source ~/.squadsrc${RESET}`);
+  writeLine();
+}
+async function stackStatusCommand() {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack status${RESET}`);
+  writeLine();
+  if (!isDockerRunning()) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Docker is not running`);
+    writeLine();
+    return;
+  }
+  const containers = [
+    { name: "squads-postgres", service: "Database" },
+    { name: "squads-redis", service: "Cache" },
+    { name: "squads-bridge", service: "Bridge API" },
+    { name: "squads-langfuse", service: "Langfuse" },
+    { name: "squads-otel-collector", service: "Telemetry" }
+  ];
+  const w = { service: 12, container: 22, status: 12 };
+  const tableWidth = w.service + w.container + w.status + 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("SERVICE", w.service)}${RESET}${bold}${padEnd("CONTAINER", w.container)}${RESET}${bold}STATUS${RESET}      ${colors.purple}${box.vertical}${RESET}`
+  );
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const { name, service } of containers) {
+    const status = getContainerStatus(name);
+    const statusIcon = status.running ? status.healthy ? `${colors.green}\u25CF healthy${RESET}` : `${colors.yellow}\u25CF starting${RESET}` : `${colors.red}\u25CB stopped${RESET}`;
+    writeLine(
+      `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(service, w.service)}${RESET}${colors.dim}${padEnd(name, w.container)}${RESET}${statusIcon}  ${colors.purple}${box.vertical}${RESET}`
+    );
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  const config2 = loadStackConfig();
+  if (config2) {
+    writeLine(`  ${colors.green}${icons.success}${RESET} Config loaded from ${colors.cyan}~/.squadsrc${RESET}`);
+    const envVars = ["SQUADS_DATABASE_URL", "SQUADS_BRIDGE_URL", "LANGFUSE_HOST"];
+    const missing = envVars.filter((v) => !process.env[v]);
+    if (missing.length > 0) {
+      writeLine(`  ${colors.yellow}${icons.warning}${RESET} Env vars not in shell: ${colors.dim}${missing.join(", ")}${RESET}`);
+      writeLine(`  ${colors.dim}Run: source ~/.squadsrc${RESET}`);
+    } else {
+      writeLine(`  ${colors.green}${icons.success}${RESET} All env vars loaded`);
+    }
+  } else {
+    writeLine(`  ${colors.yellow}${icons.warning}${RESET} No config found`);
+    writeLine(`  ${colors.dim}Run: squads stack init${RESET}`);
+  }
+  writeLine();
+}
+function stackEnvCommand() {
+  const config2 = loadStackConfig();
+  if (!config2) {
+    console.log(`# Squads Local Stack - Default Config`);
+    console.log(`# Run 'squads stack init' to auto-detect and save`);
+    console.log();
+    for (const [key, value] of Object.entries(DEFAULT_CONFIG)) {
+      console.log(`export ${key}="${value}"`);
+    }
+    return;
+  }
+  console.log(`# Squads Local Stack Config`);
+  console.log(`# From: ~/.squadsrc`);
+  console.log();
+  for (const [key, value] of Object.entries(config2)) {
+    console.log(`export ${key}="${value}"`);
+  }
+}
+async function stackUpCommand() {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack up${RESET}`);
+  writeLine();
+  const composeDir = findDockerComposeDir();
+  if (!composeDir) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} docker-compose.yml not found`);
+    writeLine();
+    writeLine(`  ${colors.dim}Expected locations:${RESET}`);
+    writeLine(`  ${colors.dim}  ./docker/docker-compose.yml${RESET}`);
+    writeLine(`  ${colors.dim}  ~/agents-squads/squads-cli/docker/docker-compose.yml${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${icons.progress}${RESET} Starting containers from ${colors.dim}${composeDir}${RESET}`);
+  writeLine();
+  try {
+    const child = spawn4("docker-compose", ["up", "-d"], {
+      cwd: composeDir,
+      stdio: "inherit"
+    });
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`docker-compose exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+    writeLine();
+    writeLine(`  ${colors.green}${icons.success}${RESET} Stack started`);
+    writeLine(`  ${colors.dim}Run: squads stack init${RESET} to configure CLI`);
+    writeLine();
+  } catch (error) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Failed to start stack`);
+    writeLine(`  ${colors.dim}${error}${RESET}`);
+    writeLine();
+  }
+}
+async function stackHealthCommand(verbose = false) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack health${RESET}`);
+  writeLine();
+  if (!isDockerRunning()) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Docker is not running`);
+    writeLine();
+    process.exitCode = 1;
+    return;
+  }
+  const containers = [
+    { name: "squads-postgres", service: "postgres", healthUrl: "", critical: true },
+    { name: "squads-redis", service: "redis", healthUrl: "", critical: true },
+    { name: "squads-neo4j", service: "neo4j", healthUrl: "http://localhost:7474", critical: false },
+    { name: "squads-bridge", service: "bridge", healthUrl: "http://localhost:8088/health", critical: true },
+    { name: "squads-otel-collector", service: "otel", healthUrl: "", critical: false },
+    { name: "squads-langfuse", service: "langfuse", healthUrl: "http://localhost:3100/api/public/health", critical: false },
+    { name: "squads-mem0", service: "mem0", healthUrl: "http://localhost:8000/health", critical: false },
+    { name: "squads-engram-mcp", service: "engram", healthUrl: "http://localhost:8080/", critical: false }
+  ];
+  let hasFailures = false;
+  const results = [];
+  for (const container of containers) {
+    const status = getContainerStatus(container.name);
+    let ok = status.running && status.healthy;
+    let statusText = "";
+    if (!status.running) {
+      statusText = "stopped";
+      ok = false;
+    } else if (!status.healthy) {
+      statusText = "unhealthy";
+      ok = false;
+    } else if (container.healthUrl) {
+      const httpOk = await checkService(container.healthUrl);
+      if (!httpOk) {
+        statusText = "not responding";
+        ok = false;
+      } else {
+        statusText = "healthy";
+      }
+    } else {
+      statusText = "healthy";
+    }
+    let logs;
+    if (!ok && verbose) {
+      try {
+        logs = execSync11(`docker logs ${container.name} --tail 10 2>&1`, {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        logs = "(no logs available)";
+      }
+    }
+    if (!ok && container.critical) {
+      hasFailures = true;
+    }
+    results.push({ name: container.name, service: container.service, ok, status: statusText, logs });
+  }
+  for (const r of results) {
+    const icon = r.ok ? `${colors.green}\u2713${RESET}` : `${colors.red}\u2717${RESET}`;
+    const statusColor = r.ok ? colors.green : colors.red;
+    writeLine(`  ${icon} ${padEnd(r.service, 10)} ${statusColor}${r.status}${RESET}`);
+    if (r.logs && !r.ok) {
+      writeLine(`    ${colors.dim}${"-".repeat(40)}${RESET}`);
+      for (const line of r.logs.split("\n").slice(0, 5)) {
+        writeLine(`    ${colors.dim}${line.substring(0, 70)}${RESET}`);
+      }
+    }
+  }
+  writeLine();
+  const healthy = results.filter((r) => r.ok).length;
+  const total = results.length;
+  if (hasFailures) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} ${healthy}/${total} services healthy - critical failures`);
+    writeLine(`  ${colors.dim}Run with -v for logs: squads stack health -v${RESET}`);
+    process.exitCode = 1;
+  } else if (healthy < total) {
+    writeLine(`  ${colors.yellow}${icons.warning}${RESET} ${healthy}/${total} services healthy - non-critical issues`);
+  } else {
+    writeLine(`  ${colors.green}${icons.success}${RESET} ${healthy}/${total} services healthy`);
+  }
+  writeLine();
+}
+function stackLogsCommand(service, tail = 50) {
+  const containerMap = {
+    postgres: "squads-postgres",
+    redis: "squads-redis",
+    neo4j: "squads-neo4j",
+    bridge: "squads-bridge",
+    otel: "squads-otel-collector",
+    langfuse: "squads-langfuse",
+    mem0: "squads-mem0",
+    engram: "squads-engram-mcp"
+  };
+  const container = containerMap[service] || `squads-${service}`;
+  try {
+    execSync11(`docker logs ${container} --tail ${tail}`, { stdio: "inherit" });
+  } catch {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Container ${container} not found`);
+  }
+}
+async function stackDownCommand() {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack down${RESET}`);
+  writeLine();
+  const composeDir = findDockerComposeDir();
+  if (!composeDir) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} docker-compose.yml not found`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${icons.progress}${RESET} Stopping containers...`);
+  writeLine();
+  try {
+    const child = spawn4("docker-compose", ["down"], {
+      cwd: composeDir,
+      stdio: "inherit"
+    });
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`docker-compose exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+    writeLine();
+    writeLine(`  ${colors.green}${icons.success}${RESET} Stack stopped`);
+    writeLine();
+  } catch (error) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Failed to stop stack`);
+    writeLine(`  ${colors.dim}${error}${RESET}`);
+    writeLine();
+  }
+}
+
 // src/cli.ts
 var envPaths = [
-  join14(process.cwd(), ".env"),
-  join14(process.cwd(), "..", "hq", ".env"),
-  join14(homedir4(), "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 (existsSync14(envPath)) {
+  if (existsSync17(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
 }
+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").action(runCommand);
+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.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").action(dashboardCommand);
+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 }));
 program.command("issues").description("Show GitHub issues across repos").option("-o, --org <org>", "GitHub organization", "agents-squads").option("-r, --repos <repos>", "Comma-separated repo names").action(issuesCommand);
 program.command("solve-issues").description("Solve ready-to-fix issues by creating PRs").option("-r, --repo <repo>", "Target repo (hq, agents-squads-web)").option("-i, --issue <number>", "Specific issue number", parseInt).option("-d, --dry-run", "Show what would be solved").option("-e, --execute", "Execute with Claude CLI").action(solveIssuesCommand);
 program.command("open-issues").description("Run evaluators/critics to find and create issues").option("-s, --squad <squad>", "Target squad (website, engineering, etc.)").option("-a, --agent <agent>", "Specific evaluator agent").option("-d, --dry-run", "Show what would run").option("-e, --execute", "Execute with Claude CLI").action(openIssuesCommand);
@@ -4662,7 +6092,7 @@ memory.command("query <query>").description("Search across all squad memory").op
 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);
 memory.command("list").description("List all memory entries").action(memoryListCommand);
-memory.command("sync").description("Sync memory from recent git commits (auto-update)").option("-v, --verbose", "Show detailed commit info").action(syncCommand);
+memory.command("sync").description("Sync memory from git: pull remote changes, process commits, optionally push").option("-v, --verbose", "Show detailed commit info").option("-p, --push", "Push local memory changes to remote after sync").option("--no-pull", "Skip pulling from remote").action((options) => syncCommand({ verbose: options.verbose, push: options.push, pull: options.pull }));
 memory.command("search <query>").description("Search conversations stored in postgres (via squads-bridge)").option("-l, --limit <limit>", "Number of results", "10").option("-r, --role <role>", "Filter by role: user, assistant, thinking").option("-i, --importance <importance>", "Filter by importance: low, normal, high").action((query, opts) => memorySearchCommand(query, {
   limit: parseInt(opts.limit, 10),
   role: opts.role,
@@ -4677,9 +6107,29 @@ var feedback = program.command("feedback").description("Record and view executio
 feedback.command("add <squad> <rating> <feedback>").description("Add feedback for last execution (rating 1-5)").option("-l, --learning <learnings...>", "Learnings to extract").action(feedbackAddCommand);
 feedback.command("show <squad>").description("Show feedback history").option("-n, --limit <n>", "Number of entries to show", "5").action(feedbackShowCommand);
 feedback.command("stats").description("Show feedback summary across all squads").action(feedbackStatsCommand);
+var sessions = program.command("sessions").description("Show active Claude Code sessions across squads").option("-v, --verbose", "Show session details").option("-j, --json", "Output as JSON").action(sessionsCommand);
+sessions.command("history").description("Show session history and statistics").option("-d, --days <days>", "Days of history to show", "7").option("-s, --squad <squad>", "Filter by squad").option("-j, --json", "Output as JSON").action((options) => sessionsHistoryCommand({
+  days: parseInt(options.days, 10),
+  squad: options.squad,
+  json: options.json
+}));
+var session = program.command("session").description("Manage current session lifecycle");
+session.command("start").description("Register a new session").option("-s, --squad <squad>", "Override squad detection").option("-q, --quiet", "Suppress output").action((options) => sessionStartCommand({ squad: options.squad, quiet: options.quiet }));
+session.command("stop").description("End current session").option("-q, --quiet", "Suppress output").action((options) => sessionStopCommand({ quiet: options.quiet }));
+session.command("heartbeat").description("Update session heartbeat").option("-q, --quiet", "Suppress output").action((options) => sessionHeartbeatCommand({ quiet: options.quiet }));
+program.command("detect-squad").description("Detect current squad based on cwd (for use in hooks)").action(detectSquadCommand);
+var stack = program.command("stack").description("Manage local Docker stack (postgres, redis, langfuse, bridge)");
+stack.command("init").description("Auto-detect Docker containers and configure CLI connection").action(stackInitCommand);
+stack.command("status").description("Show container health and connection status").action(stackStatusCommand);
+stack.command("env").description("Print environment variables for shell export").action(stackEnvCommand);
+stack.command("up").description("Start Docker containers via docker-compose").action(stackUpCommand);
+stack.command("down").description("Stop Docker containers").action(stackDownCommand);
+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)));
 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();
 if (!process.argv.slice(2).length) {
   console.log(`