squads-cli 0.1.2 → 0.3.0

package/dist/cli.js

@@ -1,18 +1,43 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  appendToMemory,
+  findMemoryDir,
+  getSquadState,
+  listMemoryEntries,
+  searchMemory
+} from "./chunk-FUHBEL3L.js";
+import {
+  RESET,
+  barChart,
+  bold,
+  box,
+  cleanupStaleSessions,
+  colors,
+  detectSquad,
+  getLiveSessionSummary,
+  gradient,
+  icons,
+  padEnd,
+  progressBar,
+  sessionsCommand,
+  sessionsHistoryCommand,
+  sessionsSummaryCommand,
+  sparkline,
+  startSession,
+  stopSession,
+  truncate,
+  updateHeartbeat,
+  writeLine
+} from "./chunk-266URT5W.js";
+import "./chunk-7OCVIDC7.js";
 
 // 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 existsSync15 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir6 } from "os";
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 
 // src/version.ts
 var version = "0.1.0";
@@ -100,7 +125,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 +146,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 +373,11 @@ 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 TELEMETRY_ENDPOINT = Buffer.from(
+  "aHR0cHM6Ly9zcXVhZHMtdGVsZW1ldHJ5LTk3ODg3MTgxNzYxMC51cy1jZW50cmFsMS5ydW4uYXBwL3Bpbmc=",
+  "base64"
+).toString();
+var TELEMETRY_KEY = Buffer.from("c3FfdGVsX3YxXzdmOGE5YjJjM2Q0ZTVmNmE=", "base64").toString();
 var eventQueue = [];
 var flushScheduled = false;
 function ensureDir() {
@@ -409,7 +445,10 @@ async function flushEvents() {
   try {
     await fetch(TELEMETRY_ENDPOINT, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: {
+        "Content-Type": "application/json",
+        "X-Squads-Key": TELEMETRY_KEY
+      },
       body: JSON.stringify({ events: batch })
     });
   } catch {
@@ -464,24 +503,19 @@ var exitHandlerRegistered = false;
 function registerExitHandler() {
   if (exitHandlerRegistered) return;
   exitHandlerRegistered = true;
-  const cleanup = () => {
-    if (eventQueue.length > 0 && TELEMETRY_ENDPOINT) {
-      storeEventLocally({
-        event: "cli.exit",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        properties: { pendingEvents: eventQueue.length }
-      });
+  process.on("beforeExit", async () => {
+    if (eventQueue.length > 0) {
+      await flushEvents();
     }
-  };
-  process.on("exit", cleanup);
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(0);
   });
-  process.on("SIGTERM", () => {
-    cleanup();
+  const signalHandler = async (signal) => {
+    if (eventQueue.length > 0) {
+      await flushEvents();
+    }
     process.exit(0);
-  });
+  };
+  process.on("SIGINT", () => signalHandler("SIGINT"));
+  process.on("SIGTERM", () => signalHandler("SIGTERM"));
 }
 
 // src/commands/init.ts
@@ -727,8 +761,8 @@ ${chalk.dim("Put your first squad to work solving a problem in minutes.")}
 // src/commands/run.ts
 import ora2 from "ora";
 import { spawn } from "child_process";
-import { join as join5, dirname as dirname2 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4, dirname } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 
 // src/lib/squad-parser.ts
 import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
@@ -975,378 +1009,22 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
   return false;
 }
 
-// src/lib/memory.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, readdirSync as readdirSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname } from "path";
-function findMemoryDir() {
-  let dir = process.cwd();
-  for (let i = 0; i < 5; i++) {
-    const memoryPath = join4(dir, ".agents", "memory");
-    if (existsSync4(memoryPath)) {
-      return memoryPath;
-    }
-    const parent = join4(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function listMemoryEntries(memoryDir) {
-  const entries = [];
-  const squads = readdirSync2(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-  for (const squad of squads) {
-    const squadPath = join4(memoryDir, squad);
-    const agents = readdirSync2(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-    for (const agent of agents) {
-      const agentPath = join4(squadPath, agent);
-      const files = readdirSync2(agentPath).filter((f) => f.endsWith(".md"));
-      for (const file of files) {
-        const filePath = join4(agentPath, file);
-        const type = file.replace(".md", "");
-        entries.push({
-          squad,
-          agent,
-          type,
-          content: readFileSync3(filePath, "utf-8"),
-          path: filePath
-        });
-      }
-    }
-  }
-  return entries;
-}
-var SEMANTIC_EXPANSIONS = {
-  "pricing": ["price", "cost", "$", "revenue", "fee", "rate"],
-  "price": ["pricing", "cost", "$", "fee"],
-  "revenue": ["income", "sales", "mrr", "arr", "$"],
-  "cost": ["expense", "spend", "budget", "$", "price"],
-  "customer": ["client", "lead", "prospect", "user"],
-  "client": ["customer", "lead", "prospect"],
-  "lead": ["prospect", "customer", "client", "pipeline"],
-  "agent": ["squad", "bot", "ai"],
-  "squad": ["team", "agent", "group"],
-  "status": ["state", "progress", "health"],
-  "bug": ["issue", "error", "problem", "fix"],
-  "feature": ["capability", "function", "ability"]
-};
-function expandQuery(query) {
-  const words = query.toLowerCase().split(/\s+/);
-  const expanded = new Set(words);
-  for (const word of words) {
-    if (SEMANTIC_EXPANSIONS[word]) {
-      SEMANTIC_EXPANSIONS[word].forEach((syn) => expanded.add(syn));
-    }
-  }
-  return Array.from(expanded);
-}
-function getFileAge(filePath) {
-  try {
-    const { statSync: statSync3 } = __require("fs");
-    const stats = statSync3(filePath);
-    const ageMs = Date.now() - stats.mtimeMs;
-    const ageDays = ageMs / (1e3 * 60 * 60 * 24);
-    return ageDays;
-  } catch {
-    return 999;
-  }
-}
-function searchMemory(query, memoryDir) {
-  const dir = memoryDir || findMemoryDir();
-  if (!dir) return [];
-  const entries = listMemoryEntries(dir);
-  const results = [];
-  const queryLower = query.toLowerCase();
-  const expandedTerms = expandQuery(queryLower);
-  for (const entry of entries) {
-    const contentLower = entry.content.toLowerCase();
-    const lines = entry.content.split("\n");
-    const matches = [];
-    let score = 0;
-    let directHits = 0;
-    let expandedHits = 0;
-    const directWords = queryLower.split(/\s+/);
-    for (const word of directWords) {
-      if (contentLower.includes(word)) {
-        directHits += 1;
-        score += 2;
-      }
-    }
-    for (const term of expandedTerms) {
-      if (contentLower.includes(term)) {
-        expandedHits += 1;
-        score += 0.5;
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i];
-          if (line.toLowerCase().includes(term) && line.trim() && !matches.includes(line.trim())) {
-            matches.push(line.trim());
-          }
-        }
-      }
-    }
-    if (contentLower.includes(queryLower)) {
-      score += 5;
-    }
-    const ageDays = getFileAge(entry.path);
-    if (ageDays < 1) {
-      score *= 1.5;
-    } else if (ageDays < 7) {
-      score *= 1.2;
-    } else if (ageDays > 30) {
-      score *= 0.8;
-    }
-    const typeWeights = {
-      "state": 1.2,
-      // Current state slightly preferred
-      "learnings": 1.1,
-      // Learnings are valuable
-      "output": 1,
-      // Recent outputs
-      "feedback": 0.9
-      // Feedback less commonly needed
-    };
-    score *= typeWeights[entry.type] || 1;
-    if (score > 0 && (directHits > 0 || expandedHits > 1)) {
-      results.push({ entry, matches: matches.slice(0, 7), score });
-    }
-  }
-  return results.sort((a, b) => b.score - a.score);
-}
-function getSquadState(squadName) {
-  const memoryDir = findMemoryDir();
-  if (!memoryDir) return [];
-  const squadPath = join4(memoryDir, squadName);
-  if (!existsSync4(squadPath)) return [];
-  const entries = [];
-  const agents = readdirSync2(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-  for (const agent of agents) {
-    const statePath = join4(squadPath, agent, "state.md");
-    if (existsSync4(statePath)) {
-      entries.push({
-        squad: squadName,
-        agent,
-        type: "state",
-        content: readFileSync3(statePath, "utf-8"),
-        path: statePath
-      });
-    }
-  }
-  return entries;
-}
-function updateMemory(squadName, agentName, type, content) {
-  const memoryDir = findMemoryDir();
-  if (!memoryDir) {
-    throw new Error("No .agents/memory directory found");
-  }
-  const filePath = join4(memoryDir, squadName, agentName, `${type}.md`);
-  const dir = dirname(filePath);
-  if (!existsSync4(dir)) {
-    mkdirSync2(dir, { recursive: true });
-  }
-  writeFileSync3(filePath, content);
-}
-function appendToMemory(squadName, agentName, type, addition) {
-  const memoryDir = findMemoryDir();
-  if (!memoryDir) {
-    throw new Error("No .agents/memory directory found");
-  }
-  const filePath = join4(memoryDir, squadName, agentName, `${type}.md`);
-  let existing = "";
-  if (existsSync4(filePath)) {
-    existing = readFileSync3(filePath, "utf-8");
-  }
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const newContent = existing + `
-
----
-_Added: ${timestamp}_
-
-${addition}`;
-  updateMemory(squadName, agentName, type, newContent.trim());
-}
-
-// src/lib/terminal.ts
-var ESC = "\x1B[";
-var RESET = `${ESC}0m`;
-var rgb = (r, g, b) => `${ESC}38;2;${r};${g};${b}m`;
-var colors = {
-  purple: rgb(168, 85, 247),
-  // #a855f7
-  pink: rgb(236, 72, 153),
-  // #ec4899
-  cyan: rgb(6, 182, 212),
-  // #06b6d4
-  green: rgb(16, 185, 129),
-  // #10b981
-  yellow: rgb(234, 179, 8),
-  // #eab308
-  red: rgb(239, 68, 68),
-  // #ef4444
-  gray: rgb(107, 114, 128),
-  // #6b7280
-  dim: rgb(75, 85, 99),
-  // #4b5563
-  white: rgb(255, 255, 255)
-};
-var bold = `${ESC}1m`;
-var dim = `${ESC}2m`;
-var cursor = {
-  hide: `${ESC}?25l`,
-  show: `${ESC}?25h`,
-  up: (n = 1) => `${ESC}${n}A`,
-  down: (n = 1) => `${ESC}${n}B`,
-  left: (n = 1) => `${ESC}${n}D`,
-  right: (n = 1) => `${ESC}${n}C`,
-  to: (x, y) => `${ESC}${y};${x}H`,
-  save: `${ESC}s`,
-  restore: `${ESC}u`
-};
-var clear = {
-  line: `${ESC}2K`,
-  toEnd: `${ESC}0K`,
-  screen: `${ESC}2J${ESC}0;0H`
-};
-function gradient(text) {
-  const stops = [
-    [168, 85, 247],
-    // purple
-    [192, 132, 252],
-    // purple-light
-    [232, 121, 249],
-    // pink
-    [244, 114, 182],
-    // pink-light
-    [251, 113, 133]
-    // rose
-  ];
-  let result = "";
-  for (let i = 0; i < text.length; i++) {
-    const t = i / Math.max(text.length - 1, 1);
-    const stopIndex = t * (stops.length - 1);
-    const lower = Math.floor(stopIndex);
-    const upper = Math.min(lower + 1, stops.length - 1);
-    const blend = stopIndex - lower;
-    const r = Math.round(stops[lower][0] + (stops[upper][0] - stops[lower][0]) * blend);
-    const g = Math.round(stops[lower][1] + (stops[upper][1] - stops[lower][1]) * blend);
-    const b = Math.round(stops[lower][2] + (stops[upper][2] - stops[lower][2]) * blend);
-    result += rgb(r, g, b) + text[i];
-  }
-  return result + RESET;
-}
-function progressBar(percent, width = 20) {
-  const filled = Math.round(percent / 100 * width);
-  const empty = width - filled;
-  let bar = "";
-  for (let i = 0; i < filled; i++) {
-    const t = i / Math.max(filled - 1, 1);
-    const r = Math.round(16 + (168 - 16) * t);
-    const g = Math.round(185 + (85 - 185) * t);
-    const b = Math.round(129 + (247 - 129) * t);
-    bar += rgb(r, g, b) + "\u2501";
-  }
-  bar += colors.dim + "\u2501".repeat(empty) + RESET;
-  return bar;
-}
-var box = {
-  topLeft: "\u250C",
-  topRight: "\u2510",
-  bottomLeft: "\u2514",
-  bottomRight: "\u2518",
-  horizontal: "\u2500",
-  vertical: "\u2502",
-  teeRight: "\u251C",
-  teeLeft: "\u2524"
-};
-function padEnd(str, len) {
-  const visible = str.replace(/\x1b\[[0-9;]*m/g, "");
-  const pad = Math.max(0, len - visible.length);
-  return str + " ".repeat(pad);
-}
-function truncate(str, len) {
-  const visible = str.replace(/\x1b\[[0-9;]*m/g, "");
-  if (visible.length <= len) return str;
-  let result = "";
-  let count = 0;
-  let i = 0;
-  while (i < str.length && count < len - 1) {
-    if (str[i] === "\x1B") {
-      const end = str.indexOf("m", i);
-      if (end !== -1) {
-        result += str.slice(i, end + 1);
-        i = end + 1;
-        continue;
-      }
-    }
-    result += str[i];
-    count++;
-    i++;
-  }
-  return result + colors.dim + "\u2026" + RESET;
-}
-var icons = {
-  success: `${colors.green}\u25CF${RESET}`,
-  warning: `${colors.yellow}\u25CB${RESET}`,
-  error: `${colors.red}\u25CF${RESET}`,
-  pending: `${colors.dim}\u25CB${RESET}`,
-  active: `${colors.green}\u25CF${RESET}`,
-  progress: `${colors.cyan}\u25C6${RESET}`,
-  empty: `${colors.dim}\u25C7${RESET}`
-};
-function writeLine(str = "") {
-  process.stdout.write(str + "\n");
-}
-function sparkline(values, width) {
-  if (values.length === 0) return "";
-  const blocks = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
-  const max = Math.max(...values, 1);
-  let result = "";
-  for (const val of values) {
-    const normalized = val / max;
-    const blockIndex = Math.min(Math.floor(normalized * blocks.length), blocks.length - 1);
-    const intensity = normalized;
-    if (normalized === 0) {
-      result += colors.dim + blocks[0];
-    } else if (normalized < 0.5) {
-      result += colors.cyan + blocks[blockIndex];
-    } else {
-      result += colors.green + blocks[blockIndex];
-    }
-  }
-  return result + RESET;
-}
-function barChart(value, max, width = 20, label) {
-  const filled = Math.round(value / max * width);
-  const empty = width - filled;
-  let bar = "";
-  for (let i = 0; i < filled; i++) {
-    const t = i / Math.max(filled - 1, 1);
-    const r = Math.round(16 + (6 - 16) * t);
-    const g = Math.round(185 + (182 - 185) * t);
-    const b = Math.round(129 + (212 - 129) * t);
-    bar += rgb(r, g, b) + "\u2501";
-  }
-  bar += colors.dim + "\u2501".repeat(empty) + RESET;
-  if (label) {
-    return `${bar} ${label}`;
-  }
-  return bar;
-}
-
 // src/commands/run.ts
 function getExecutionLogPath(squadName, agentName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join5(memoryDir, squadName, agentName, "executions.md");
+  return join4(memoryDir, squadName, agentName, "executions.md");
 }
 function logExecution(record) {
   const logPath = getExecutionLogPath(record.squadName, record.agentName);
   if (!logPath) return;
-  const dir = dirname2(logPath);
-  if (!existsSync5(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = dirname(logPath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
   let content = "";
-  if (existsSync5(logPath)) {
-    content = readFileSync4(logPath, "utf-8");
+  if (existsSync4(logPath)) {
+    content = readFileSync3(logPath, "utf-8");
   } else {
     content = `# ${record.squadName}/${record.agentName} - Execution Log
 
@@ -1358,12 +1036,12 @@ function logExecution(record) {
 ${record.endTime ? `Completed: ${record.endTime}` : ""}
 ${record.outcome ? `Outcome: ${record.outcome}` : ""}
 `;
-  writeFileSync4(logPath, content + entry);
+  writeFileSync3(logPath, content + entry);
 }
 function updateExecutionStatus(squadName, agentName, status, outcome) {
   const logPath = getExecutionLogPath(squadName, agentName);
-  if (!logPath || !existsSync5(logPath)) return;
-  let content = readFileSync4(logPath, "utf-8");
+  if (!logPath || !existsSync4(logPath)) return;
+  let content = readFileSync3(logPath, "utf-8");
   const endTime = (/* @__PURE__ */ new Date()).toISOString();
   content = content.replace(
     /Status: running\n$/,
@@ -1372,7 +1050,7 @@ Completed: ${endTime}
 ${outcome ? `Outcome: ${outcome}
 ` : ""}`
   );
-  writeFileSync4(logPath, content);
+  writeFileSync3(logPath, content);
 }
 async function runCommand(target, options) {
   const squadsDir = findSquadsDir();
@@ -1384,6 +1062,7 @@ async function runCommand(target, options) {
   const squad = loadSquad(target);
   if (squad) {
     await track(Events.CLI_RUN, { type: "squad", target: squad.name });
+    await flushEvents();
     await runSquad(squad, squadsDir, options);
   } else {
     const agents = listAgents(squadsDir);
@@ -1418,8 +1097,8 @@ async function runSquad(squad, squadsDir, options) {
     writeLine();
     for (let i = 0; i < pipeline.agents.length; i++) {
       const agentName = pipeline.agents[i];
-      const agentPath = join5(squadsDir, squad.name, `${agentName}.md`);
-      if (existsSync5(agentPath)) {
+      const agentPath = join4(squadsDir, squad.name, `${agentName}.md`);
+      if (existsSync4(agentPath)) {
         writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
         await runAgent(agentName, agentPath, squad.name, options);
         writeLine();
@@ -1428,22 +1107,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 (existsSync5(agentPath)) {
-        await runAgent(orchestrator.name, agentPath, squad.name, options);
+    if (options.agent) {
+      const agentPath = join4(squadsDir, squad.name, `${options.agent}.md`);
+      if (existsSync4(agentPath)) {
+        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 = join4(squadsDir, squad.name, `${orchestrator.name}.md`);
+        if (existsSync4(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();
@@ -1469,7 +1158,7 @@ async function runAgent(agentName, agentPath, squadName, options) {
     startTime,
     status: "running"
   });
-  const prompt = `Execute the ${agentName} agent from squad ${squadName}.
+  const prompt2 = `Execute the ${agentName} agent from squad ${squadName}.
 
 Read the agent definition at ${agentPath} and follow its instructions exactly.
 
@@ -1485,18 +1174,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(prompt2, options.verbose, options.timeout || 30);
+      spinner.succeed(`Agent ${agentName} launched`);
+      writeLine(`  ${colors.dim}${result}${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}Monitor:${RESET} squads workers`);
+      writeLine(`  ${colors.dim}Memory:${RESET}  squads memory show ${squadName}`);
     } 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 +1196,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(`  ${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 run with --execute flag:${RESET}`);
-    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${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 +1210,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(prompt2, verbose, timeoutMinutes = 30) {
+  const userConfigPath = join4(process.env.HOME || "", ".claude.json");
+  const squadMatch = prompt2.match(/squad (\w+)/);
+  const agentMatch = prompt2.match(/(\w+) agent/);
+  const squadName = squadMatch?.[1] || "unknown";
+  const agentName = agentMatch?.[1] || "unknown";
+  const timestamp = Date.now();
+  const sessionName = `squads-${squadName}-${agentName}-${timestamp}`;
+  if (verbose) {
+    writeLine(`  ${colors.dim}Spawning tmux session: ${sessionName}${RESET}`);
+  }
+  const escapedPrompt = prompt2.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
@@ -1622,6 +1309,141 @@ async function listCommand(options) {
 // src/commands/status.ts
 import { existsSync as existsSync6, statSync } from "fs";
 import { join as join6 } from "path";
+
+// src/lib/update.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, unlinkSync } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync as execSync2 } from "child_process";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const __filename3 = fileURLToPath(import.meta.url);
+    const __dirname3 = dirname2(__filename3);
+    const possiblePaths = [
+      join5(__dirname3, "..", "..", "package.json"),
+      // From dist/lib/
+      join5(__dirname3, "..", "package.json"),
+      // From dist/
+      join5(__dirname3, "package.json")
+      // Same dir
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (existsSync5(pkgPath)) {
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        return pkg.version || "0.0.0";
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var CURRENT_VERSION = getPackageVersion();
+var CACHE_DIR = join5(homedir2(), ".squads");
+var CACHE_FILE = join5(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 (!existsSync5(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latestVersion) {
+  try {
+    if (!existsSync5(CACHE_DIR)) {
+      mkdirSync3(CACHE_DIR, { recursive: true });
+    }
+    const cache = {
+      latestVersion,
+      checkedAt: Date.now()
+    };
+    writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function fetchLatestVersion() {
+  try {
+    const result = execSync2("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 {
+    execSync2("npm update -g squads-cli", {
+      encoding: "utf-8",
+      stdio: "inherit",
+      timeout: 12e4
+      // 2 minutes
+    });
+    try {
+      unlinkSync(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) {
@@ -1638,8 +1460,24 @@ async function statusCommand(squadName, 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;
@@ -1660,7 +1498,7 @@ async function showOverallStatus(squadsDir, _options) {
       const squadMemoryPath = join6(memoryDir, squadName);
       if (existsSync6(squadMemoryPath)) {
         const states = getSquadState(squadName);
-        memoryStatus = `${colors.green}${states.length} entries${RESET}`;
+        memoryStatus = `${colors.green}${states.length} ${states.length === 1 ? "entry" : "entries"}${RESET}`;
         let mostRecent = 0;
         for (const state of states) {
           const stat = statSync(state.path);
@@ -1686,81 +1524,824 @@ async function showOverallStatus(squadsDir, _options) {
         }
       }
     }
-    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);
+    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}`);
+  writeLine();
+}
+
+// src/commands/stack.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, copyFileSync } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { execSync as execSync3, spawn as spawn2 } from "child_process";
+import { createInterface } from "readline";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname3(__filename2);
+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 = join7(homedir3(), ".squadsrc");
+var SQUADS_DATA_DIR = join7(homedir3(), ".squads");
+var SERVICES = {
+  bridge: {
+    name: "Bridge API",
+    description: "Captures conversations and telemetry",
+    required: true,
+    healthUrl: "http://localhost:8088/health",
+    envVars: ["SQUADS_BRIDGE_URL"],
+    setupGuide: [
+      "Run: squads stack up",
+      "Or manually: docker compose up -d bridge"
+    ]
+  },
+  postgres: {
+    name: "PostgreSQL",
+    description: "Stores conversations and telemetry data",
+    required: true,
+    envVars: ["SQUADS_DATABASE_URL"],
+    setupGuide: [
+      "Run: squads stack up",
+      "Or manually: docker compose up -d postgres"
+    ]
+  },
+  mem0: {
+    name: "Mem0 (Engram)",
+    description: "Extracts and stores memories from conversations",
+    required: false,
+    healthUrl: "http://localhost:8000/health",
+    envVars: ["MEM0_API_URL"],
+    setupGuide: [
+      "Run: squads stack up",
+      "Or manually: docker compose -f docker-compose.engram.yml up -d mem0",
+      "",
+      "Mem0 requires an LLM provider. Configure in docker/.env:",
+      "  LLM_PROVIDER=ollama   # For local (free)",
+      "  LLM_PROVIDER=openai   # Requires OPENAI_API_KEY"
+    ]
+  },
+  langfuse: {
+    name: "Langfuse",
+    description: "Telemetry dashboard and cost tracking",
+    required: false,
+    healthUrl: "http://localhost:3100/api/public/health",
+    envVars: ["LANGFUSE_HOST", "LANGFUSE_PUBLIC_KEY", "LANGFUSE_SECRET_KEY"],
+    setupGuide: [
+      "Run: squads stack up",
+      "Then get API keys from: http://localhost:3100",
+      "  1. Create account / login",
+      "  2. Create project",
+      "  3. Copy API keys to docker/.env"
+    ]
+  },
+  redis: {
+    name: "Redis",
+    description: "Caching and rate limiting",
+    required: false,
+    envVars: ["REDIS_URL"],
+    setupGuide: [
+      "Run: squads stack up"
+    ]
+  }
+};
+async function checkServiceAvailable(serviceName, showGuidance = true) {
+  const service = SERVICES[serviceName];
+  if (!service) return false;
+  const containerName = `squads-${serviceName === "mem0" ? "mem0" : serviceName}`;
+  const status = getContainerStatus(containerName);
+  if (!status.running) {
+    if (showGuidance) {
+      showServiceSetupGuide(serviceName, "not running");
+    }
+    return false;
+  }
+  if (service.healthUrl) {
+    const healthy = await checkService(service.healthUrl);
+    if (!healthy) {
+      if (showGuidance) {
+        showServiceSetupGuide(serviceName, "not responding");
+      }
+      return false;
+    }
+  }
+  return true;
+}
+function showServiceSetupGuide(serviceName, issue) {
+  const service = SERVICES[serviceName];
+  if (!service) return;
+  writeLine();
+  writeLine(`  ${colors.yellow}${icons.warning}${RESET} ${bold}${service.name}${RESET} is ${issue}`);
+  writeLine(`  ${colors.dim}${service.description}${RESET}`);
+  writeLine();
+  writeLine(`  ${bold}To fix:${RESET}`);
+  for (const step of service.setupGuide) {
+    if (step === "") {
+      writeLine();
+    } else {
+      writeLine(`  ${colors.dim}${step}${RESET}`);
+    }
+  }
+  if (service.envVars.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Environment variables:${RESET}`);
+    for (const envVar of service.envVars) {
+      const value = process.env[envVar];
+      const status = value ? `${colors.green}\u2713${RESET}` : `${colors.red}\u2717${RESET}`;
+      writeLine(`  ${status} ${colors.cyan}${envVar}${RESET}${value ? ` = ${colors.dim}${value}${RESET}` : ""}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}Full setup: squads stack init${RESET}`);
+  writeLine();
+}
+async function prompt(question, defaultValue) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve) => {
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function confirm(question, defaultYes = true) {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await prompt(`${question} ${suffix}`);
+  if (!answer) return defaultYes;
+  return answer.toLowerCase().startsWith("y");
+}
+function findPackageDockerDir() {
+  const candidates = [
+    // From npm package (relative to dist/commands/stack.js)
+    join7(__dirname2, "..", "..", "docker"),
+    // Local development
+    join7(process.cwd(), "docker"),
+    join7(process.cwd(), "..", "squads-cli", "docker"),
+    join7(homedir3(), "agents-squads", "squads-cli", "docker")
+  ];
+  for (const dir of candidates) {
+    if (existsSync7(join7(dir, "docker-compose.yml"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+function loadStackConfig() {
+  if (!existsSync7(CONFIG_PATH2)) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(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",
+    ""
+  ];
+  writeFileSync5(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 {
+    execSync3("docker info", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getContainerStatus(name) {
+  try {
+    const runningOutput = execSync3(
+      `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 = execSync3(
+        `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 = execSync3(
+        `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 = [
+    join7(process.cwd(), "docker", ".env"),
+    join7(process.cwd(), "..", "squads-cli", "docker", ".env"),
+    join7(homedir3(), "agents-squads", "squads-cli", "docker", ".env")
+  ];
+  for (const envPath of envPaths2) {
+    if (existsSync7(envPath)) {
+      const content = readFileSync5(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 = [
+    join7(process.cwd(), "docker"),
+    join7(process.cwd(), "..", "squads-cli", "docker"),
+    join7(homedir3(), "agents-squads", "squads-cli", "docker")
+  ];
+  for (const dir of candidates) {
+    if (existsSync7(join7(dir, "docker-compose.yml"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function stackInitCommand() {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack init${RESET}`);
+  writeLine();
+  writeLine(`  ${bold}Local Infrastructure Setup Wizard${RESET}`);
+  writeLine(`  ${colors.dim}This will configure Docker services for conversation capture,${RESET}`);
+  writeLine(`  ${colors.dim}memory extraction, and telemetry.${RESET}`);
+  writeLine();
+  writeLine(`  ${bold}Step 1: Docker${RESET}`);
+  if (!isDockerRunning()) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Docker is not running`);
+    writeLine();
+    writeLine(`  ${colors.dim}Please start Docker Desktop and run this command again.${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.green}${icons.success}${RESET} Docker is running`);
+  writeLine();
+  writeLine(`  ${bold}Step 2: Docker Compose Files${RESET}`);
+  let composeDir = findPackageDockerDir();
+  const targetDir = join7(SQUADS_DATA_DIR, "docker");
+  if (!composeDir) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} Docker compose files not found`);
+    writeLine(`  ${colors.dim}This shouldn't happen if you installed via npm.${RESET}`);
+    writeLine(`  ${colors.dim}Try reinstalling: npm install -g squads-cli${RESET}`);
+    writeLine();
+    return;
+  }
+  if (composeDir !== targetDir && !existsSync7(targetDir)) {
+    writeLine(`  ${colors.cyan}${icons.progress}${RESET} Copying docker files to ${colors.dim}~/.squads/docker${RESET}`);
+    try {
+      mkdirSync4(SQUADS_DATA_DIR, { recursive: true });
+      mkdirSync4(targetDir, { recursive: true });
+      const filesToCopy = [
+        "docker-compose.yml",
+        "docker-compose.engram.yml",
+        ".env.example"
+      ];
+      for (const file of filesToCopy) {
+        const src = join7(composeDir, file);
+        const dst = join7(targetDir, file);
+        if (existsSync7(src)) {
+          copyFileSync(src, dst);
+        }
+      }
+      composeDir = targetDir;
+      writeLine(`  ${colors.green}${icons.success}${RESET} Files copied`);
+    } catch (err) {
+      writeLine(`  ${colors.yellow}${icons.warning}${RESET} Could not copy files, using source location`);
+    }
+  } else if (existsSync7(targetDir)) {
+    composeDir = targetDir;
+    writeLine(`  ${colors.green}${icons.success}${RESET} Using ${colors.dim}~/.squads/docker${RESET}`);
+  } else {
+    writeLine(`  ${colors.green}${icons.success}${RESET} Using ${colors.dim}${composeDir}${RESET}`);
+  }
+  writeLine();
+  writeLine(`  ${bold}Step 3: Environment Configuration${RESET}`);
+  const envPath = join7(composeDir, ".env");
+  const envExamplePath = join7(composeDir, ".env.example");
+  if (!existsSync7(envPath)) {
+    if (existsSync7(envExamplePath)) {
+      copyFileSync(envExamplePath, envPath);
+      writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created .env from template`);
+    } else {
+      const minimalEnv = `# Squads Local Stack Configuration
+# Generated by: squads stack init
+
+# Langfuse API Keys (get from http://localhost:3100 after first run)
+LANGFUSE_PUBLIC_KEY=
+LANGFUSE_SECRET_KEY=
+LANGFUSE_HOST=http://langfuse:3000
+
+# Mem0/Engram LLM Provider
+# Options: ollama (free, local), openai (requires API key)
+LLM_PROVIDER=ollama
+OLLAMA_BASE_URL=http://host.docker.internal:11434
+OLLAMA_LLM_MODEL=qwen3:latest
+OLLAMA_EMBEDDING_MODEL=nomic-embed-text:latest
+
+# For OpenAI (if LLM_PROVIDER=openai)
+# OPENAI_API_KEY=sk-...
+
+# Ports (defaults)
+POSTGRES_PORT=5433
+REDIS_PORT=6379
+LANGFUSE_PORT=3100
+OTEL_PORT=4318
+BRIDGE_PORT=8088
+`;
+      writeFileSync5(envPath, minimalEnv);
+      writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created default .env`);
+    }
+  } else {
+    writeLine(`  ${colors.green}${icons.success}${RESET} .env exists`);
+  }
+  const envContent = readFileSync5(envPath, "utf-8");
+  const missingSecrets = [];
+  const llmProvider = envContent.match(/LLM_PROVIDER=(\w+)/)?.[1] || "ollama";
+  if (llmProvider === "openai") {
+    if (!envContent.match(/OPENAI_API_KEY=\S+/)) {
+      missingSecrets.push("OPENAI_API_KEY");
+    }
+  }
+  if (missingSecrets.length > 0) {
+    writeLine();
+    writeLine(`  ${colors.yellow}${icons.warning}${RESET} Missing secrets in .env:`);
+    for (const secret of missingSecrets) {
+      writeLine(`    ${colors.red}\u2022${RESET} ${secret}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}Edit: ${envPath}${RESET}`);
+  }
+  writeLine();
+  writeLine(`  ${bold}Step 4: Start Services${RESET}`);
+  const containers = [
+    { name: "squads-postgres", required: true },
+    { name: "squads-redis", required: true },
+    { name: "squads-bridge", required: true },
+    { name: "squads-langfuse", required: false },
+    { name: "squads-otel-collector", required: false },
+    { name: "squads-mem0", required: false }
+  ];
+  const statuses = containers.map((c) => ({ ...c, ...getContainerStatus(c.name) }));
+  const requiredNotRunning = statuses.filter((s) => s.required && !s.running);
+  for (const status of statuses) {
+    const icon = status.running ? status.healthy ? `${colors.green}\u25CF${RESET}` : `${colors.yellow}\u25CF${RESET}` : `${colors.red}\u25CB${RESET}`;
+    const suffix = status.required ? "" : `${colors.dim}(optional)${RESET}`;
+    writeLine(`  ${icon} ${status.name} ${suffix}`);
+  }
+  writeLine();
+  if (requiredNotRunning.length > 0) {
+    const shouldStart = await confirm("Start required services now?");
+    if (shouldStart) {
+      writeLine();
+      writeLine(`  ${colors.cyan}${icons.progress}${RESET} Starting containers...`);
+      try {
+        execSync3("docker compose up -d", {
+          cwd: composeDir,
+          stdio: "inherit"
+        });
+        writeLine(`  ${colors.cyan}${icons.progress}${RESET} Waiting for services to be ready...`);
+        await new Promise((resolve) => setTimeout(resolve, 5e3));
+        writeLine(`  ${colors.green}${icons.success}${RESET} Services started`);
+      } catch (err) {
+        writeLine(`  ${colors.red}${icons.error}${RESET} Failed to start services`);
+        writeLine(`  ${colors.dim}Try manually: cd ${composeDir} && docker compose up -d${RESET}`);
+      }
+    }
+    writeLine();
+  }
+  writeLine(`  ${bold}Step 5: Langfuse API Keys${RESET}`);
+  const langfuseKeys = getLangfuseKeysFromDockerEnv();
+  if (!langfuseKeys?.publicKey || !langfuseKeys?.secretKey) {
+    writeLine(`  ${colors.yellow}${icons.warning}${RESET} Langfuse API keys not configured`);
+    writeLine();
+    writeLine(`  ${colors.dim}To enable telemetry:${RESET}`);
+    writeLine(`  ${colors.dim}1. Open http://localhost:3100${RESET}`);
+    writeLine(`  ${colors.dim}2. Create account and project${RESET}`);
+    writeLine(`  ${colors.dim}3. Copy API keys to ${envPath}${RESET}`);
+    writeLine(`  ${colors.dim}4. Run: squads stack init (again)${RESET}`);
+  } else {
+    writeLine(`  ${colors.green}${icons.success}${RESET} Langfuse keys configured`);
+  }
+  writeLine();
+  writeLine(`  ${bold}Step 6: CLI Configuration${RESET}`);
+  const config2 = {
+    ...DEFAULT_CONFIG,
+    LANGFUSE_PUBLIC_KEY: langfuseKeys?.publicKey || "",
+    LANGFUSE_SECRET_KEY: langfuseKeys?.secretKey || ""
+  };
+  saveStackConfig(config2);
+  writeLine(`  ${colors.green}${icons.success}${RESET} Config saved to ${colors.cyan}~/.squadsrc${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.green}${bold}Setup Complete!${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}To activate environment:${RESET}`);
+  writeLine(`  ${colors.cyan}source ~/.squadsrc${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Add to ~/.zshrc for persistence:${RESET}`);
+  writeLine(`  ${colors.cyan}[ -f ~/.squadsrc ] && source ~/.squadsrc${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Check status anytime:${RESET}`);
+  writeLine(`  ${colors.cyan}squads stack health${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 = spawn2("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 = execSync3(`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(`  ${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}`);
+  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();
 }
-async function showSquadStatus(squadName, squadsDir, options) {
-  const squad = loadSquad(squadName);
-  if (!squad) {
-    writeLine(`${colors.red}Squad "${squadName}" not found.${RESET}`);
-    process.exit(1);
+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 {
+    execSync3(`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}status${RESET} ${colors.cyan}${squad.name}${RESET}`);
+  writeLine(`  ${gradient("squads")} ${colors.dim}stack down${RESET}`);
   writeLine();
-  if (squad.mission) {
-    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
+  const composeDir = findDockerComposeDir();
+  if (!composeDir) {
+    writeLine(`  ${colors.red}${icons.error}${RESET} docker-compose.yml not found`);
     writeLine();
+    return;
   }
-  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(`  ${colors.cyan}${icons.progress}${RESET} Stopping containers...`);
   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) {
+  try {
+    const child = spawn2("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();
-    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} 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}`);
-  writeLine();
 }
 
 // src/commands/memory.ts
 var SQUADS_BRIDGE_URL = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+var MEM0_API_URL = process.env.MEM0_API_URL || "http://localhost:8000";
 async function memoryQueryCommand(query, options) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
@@ -1986,20 +2567,125 @@ async function memorySearchCommand(query, options = {}) {
     writeLine();
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage.includes("ECONNREFUSED")) {
-      writeLine(`  ${colors.yellow}Cannot connect to squads-bridge${RESET}`);
-      writeLine(`  ${colors.dim}Run: docker compose up -d${RESET}`);
+    if (errorMessage.includes("ECONNREFUSED") || errorMessage.includes("fetch failed")) {
+      showServiceSetupGuide("bridge", "not responding");
     } else {
       writeLine(`  ${colors.red}Error searching conversations: ${errorMessage}${RESET}`);
+      writeLine();
+    }
+  }
+}
+async function memoryExtractCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory extract${RESET}`);
+  writeLine();
+  const hours = options.hours || 24;
+  try {
+    writeLine(`  ${colors.dim}Fetching conversations from last ${hours}h...${RESET}`);
+    const bridgeResponse = await fetch(`${SQUADS_BRIDGE_URL}/api/conversations/recent`);
+    if (!bridgeResponse.ok) {
+      throw new Error(`Bridge API error: ${bridgeResponse.status}`);
+    }
+    const { conversations, count } = await bridgeResponse.json();
+    if (count === 0) {
+      writeLine(`  ${colors.yellow}No recent conversations to extract${RESET}`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${colors.green}${count}${RESET} conversations found`);
+    writeLine();
+    const sessions2 = /* @__PURE__ */ new Map();
+    for (const conv of conversations) {
+      const sessionId = conv.session_id || "unknown";
+      if (!sessions2.has(sessionId)) {
+        sessions2.set(sessionId, []);
+      }
+      sessions2.get(sessionId).push(conv);
+    }
+    writeLine(`  ${colors.cyan}${sessions2.size}${RESET} sessions to process`);
+    writeLine();
+    if (options.dryRun) {
+      writeLine(`  ${colors.yellow}Dry run - not sending to Engram${RESET}`);
+      writeLine();
+      for (const [sessionId, convs] of sessions2) {
+        const squad = convs[0]?.squad || "unknown";
+        const agent = convs[0]?.agent || "unknown";
+        writeLine(`  ${icons.progress} ${colors.dim}${sessionId.slice(0, 8)}${RESET} ${colors.cyan}${squad}/${agent}${RESET} ${colors.dim}(${convs.length} messages)${RESET}`);
+      }
+      writeLine();
+      return;
+    }
+    let extracted = 0;
+    let failed = 0;
+    for (const [sessionId, convs] of sessions2) {
+      const squad = convs[0]?.squad || "hq";
+      const agent = convs[0]?.agent || "unknown";
+      const messages = convs.map((c) => ({
+        role: c.role === "assistant" ? "assistant" : c.role === "user" ? "user" : "system",
+        content: c.content
+      }));
+      try {
+        const mem0Response = await fetch(`${MEM0_API_URL}/memories`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            messages,
+            user_id: squad,
+            agent_id: agent,
+            run_id: sessionId,
+            metadata: {
+              source: "squads-cli",
+              extracted_at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          })
+        });
+        if (mem0Response.ok) {
+          const result = await mem0Response.json();
+          const memCount = result.results?.length || 0;
+          writeLine(`  ${colors.green}${icons.success}${RESET} ${colors.dim}${sessionId.slice(0, 8)}${RESET} ${colors.cyan}${squad}/${agent}${RESET} \u2192 ${colors.green}${memCount}${RESET} memories`);
+          extracted++;
+        } else {
+          writeLine(`  ${colors.red}${icons.error}${RESET} ${colors.dim}${sessionId.slice(0, 8)}${RESET} ${colors.red}Failed: ${mem0Response.status}${RESET}`);
+          failed++;
+        }
+      } catch (err) {
+        writeLine(`  ${colors.red}${icons.error}${RESET} ${colors.dim}${sessionId.slice(0, 8)}${RESET} ${colors.red}Error: ${err}${RESET}`);
+        failed++;
+      }
     }
     writeLine();
+    if (failed === 0) {
+      writeLine(`  ${colors.green}${icons.success}${RESET} Extracted memories from ${extracted} sessions`);
+    } else {
+      writeLine(`  ${colors.yellow}${icons.warning}${RESET} Extracted: ${extracted}, Failed: ${failed}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}$${RESET} squads memory query ${colors.cyan}"<term>"${RESET}    ${colors.dim}Search extracted memories${RESET}`);
+    writeLine();
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("ECONNREFUSED") || errorMessage.includes("fetch failed")) {
+      const bridgeOk = await checkServiceAvailable("bridge", false);
+      const mem0Ok = await checkServiceAvailable("mem0", false);
+      if (!bridgeOk) {
+        showServiceSetupGuide("bridge", "not responding");
+      } else if (!mem0Ok) {
+        showServiceSetupGuide("mem0", "not responding");
+      } else {
+        writeLine(`  ${colors.red}Error: ${errorMessage}${RESET}`);
+        writeLine();
+      }
+    } else {
+      writeLine(`  ${colors.red}Error: ${errorMessage}${RESET}`);
+      writeLine();
+    }
   }
 }
 
 // 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 existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join8 } from "path";
 var PATH_TO_SQUAD = {
   "squads-cli": "product",
   "agents-squads-web": "website",
@@ -2027,21 +2713,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 = join8(memoryDir, ".last-sync");
+  if (existsSync8(syncFile)) {
+    return readFileSync6(syncFile, "utf-8").trim();
   }
   return null;
 }
 function updateLastSyncTime(memoryDir) {
-  const syncFile = join7(memoryDir, ".last-sync");
-  writeFileSync5(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+  const syncFile = join8(memoryDir, ".last-sync");
+  writeFileSync6(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 +2793,22 @@ ${messages}
 `;
 }
 function appendToSquadMemory(memoryDir, squad, summary) {
-  const squadMemoryDir = join7(memoryDir, squad);
-  if (!existsSync7(squadMemoryDir)) {
-    mkdirSync4(squadMemoryDir, { recursive: true });
+  const squadMemoryDir = join8(memoryDir, squad);
+  if (!existsSync8(squadMemoryDir)) {
+    mkdirSync5(squadMemoryDir, { recursive: true });
   }
   let agentDir;
-  const existingDirs = existsSync7(squadMemoryDir) ? readdirSync3(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  const existingDirs = existsSync8(squadMemoryDir) ? readdirSync2(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
   if (existingDirs.length > 0) {
-    agentDir = join7(squadMemoryDir, existingDirs[0]);
+    agentDir = join8(squadMemoryDir, existingDirs[0]);
   } else {
-    agentDir = join7(squadMemoryDir, `${squad}-lead`);
-    mkdirSync4(agentDir, { recursive: true });
+    agentDir = join8(squadMemoryDir, `${squad}-lead`);
+    mkdirSync5(agentDir, { recursive: true });
   }
-  const statePath = join7(agentDir, "state.md");
+  const statePath = join8(agentDir, "state.md");
   let content = "";
-  if (existsSync7(statePath)) {
-    content = readFileSync5(statePath, "utf-8");
+  if (existsSync8(statePath)) {
+    content = readFileSync6(statePath, "utf-8");
   } else {
     content = `# ${squad} Squad - State
 
@@ -2134,9 +2820,53 @@ Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
     `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
   );
   content += summary;
-  writeFileSync5(statePath, content);
+  writeFileSync6(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 +2878,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 +2938,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 +3080,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 readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join9, dirname as dirname5 } 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 join9(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 join9(memoryDir, squadName, agentName, "output.md");
 }
 function getLastExecution(squadName) {
   const outputPath = getOutputPath(squadName);
-  if (!outputPath || !existsSync8(outputPath)) {
+  if (!outputPath || !existsSync9(outputPath)) {
     return null;
   }
-  const content = readFileSync6(outputPath, "utf-8");
+  const content = readFileSync7(outputPath, "utf-8");
   const lines = content.split("\n");
   let date = "unknown";
   let summary = lines.slice(0, 5).join("\n");
@@ -2390,9 +3152,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 = dirname5(feedbackPath);
+  if (!existsSync9(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let entry = `
@@ -2420,15 +3182,15 @@ _Date: ${date}_
     }
   }
   let existing = "";
-  if (existsSync8(feedbackPath)) {
-    existing = readFileSync6(feedbackPath, "utf-8");
+  if (existsSync9(feedbackPath)) {
+    existing = readFileSync7(feedbackPath, "utf-8");
   } else {
     existing = `# ${squadName} - Feedback Log
 
 > Execution feedback and learnings
 `;
   }
-  writeFileSync6(feedbackPath, existing + entry);
+  writeFileSync7(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 +3203,11 @@ _Date: ${date}_
 }
 async function feedbackShowCommand(squadName, options) {
   const feedbackPath = getFeedbackPath(squadName);
-  if (!feedbackPath || !existsSync8(feedbackPath)) {
+  if (!feedbackPath || !existsSync9(feedbackPath)) {
     writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
     return;
   }
-  const content = readFileSync6(feedbackPath, "utf-8");
+  const content = readFileSync7(feedbackPath, "utf-8");
   const entries = parseFeedbackHistory(content);
   const limit = options.limit ? parseInt(options.limit) : 5;
   const recent = entries.slice(-limit).reverse();
@@ -2480,7 +3242,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 = readdirSync3(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 +3251,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 || !existsSync9(feedbackPath)) {
       continue;
     }
-    const content = readFileSync6(feedbackPath, "utf-8");
+    const content = readFileSync7(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 +3277,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 readdirSync4, existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir4 } from "os";
 
 // src/lib/costs.ts
 var MODEL_PRICING = {
@@ -2528,16 +3290,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 +3364,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 +3459,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 +3605,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 +3708,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 = join10(memoryDir, squadName);
+  if (!existsSync10(squadMemory)) return "\u2014";
   let latestTime = 0;
   try {
-    const agents = readdirSync5(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
+    const agents = readdirSync4(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 = join10(squadMemory, agent.name);
+      const files = readdirSync4(agentPath).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const filePath = join9(agentPath, file);
+        const filePath = join10(agentPath, file);
         const stats = statSync2(filePath);
         if (stats.mtimeMs > latestTime) {
           latestTime = stats.mtimeMs;
@@ -2937,54 +3756,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 +3876,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 +3894,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 +3913,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 +3926,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")
+    join10(process.cwd(), ".."),
+    join10(homedir4(), "agents-squads")
   ];
   for (const dir of candidates) {
-    if (existsSync9(join9(dir, "hq"))) {
+    if (existsSync10(join10(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 +3987,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}`);
@@ -3164,82 +4002,14 @@ async function renderTokenEconomics(squadNames) {
   writeLine(`  ${colors.dim}Budget $${costs.dailyBudget}${RESET} [${costBar}] ${costs.usedPercent.toFixed(1)}%`);
   writeLine(`  ${colors.green}$${costs.totalCost.toFixed(2)}${RESET} used  ${colors.dim}\u2502${RESET}  ${colors.cyan}$${costs.idleBudget.toFixed(2)}${RESET} idle`);
   writeLine();
-  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;
+  const tier = parseInt(process.env.ANTHROPIC_TIER || "4", 10);
+  writeLine(`  ${colors.dim}Rate Limits (Tier ${tier})${RESET}`);
+  writeLine();
+  const now = /* @__PURE__ */ new Date();
+  const hoursElapsed = Math.max(now.getHours() + now.getMinutes() / 60, 1);
+  const hourlyRate = costs.totalCost / hoursElapsed;
   const dailyProjection = hourlyRate * 24;
   const monthlyProjection = dailyProjection * 30;
-  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 +4021,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 +4206,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 +4271,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 +4282,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 +4333,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 spawn3 } 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 +4343,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 +4353,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 +4366,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 +4420,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}`);
@@ -3622,9 +4428,9 @@ async function solveWithClaude(issues) {
   }
   for (const issue of issues) {
     spinner.text = `Solving #${issue.number}: ${truncate(issue.title, 40)}`;
-    const prompt = buildSolvePrompt(issue);
+    const prompt2 = buildSolvePrompt(issue);
     try {
-      const result = await executeClaudePrompt(prompt);
+      const result = await executeClaudePrompt(prompt2);
       spinner.succeed(`Solved #${issue.number}`);
       const prMatch = result.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
       if (prMatch) {
@@ -3671,9 +4477,9 @@ If reading the same file twice, STOP and move forward.
 
 Return the PR URL when done.`;
 }
-function executeClaudePrompt(prompt) {
+function executeClaudePrompt(prompt2) {
   return new Promise((resolve, reject) => {
-    const claude = spawn2("claude", ["--print", prompt], {
+    const claude = spawn3("claude", ["--print", prompt2], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let output = "";
@@ -3700,9 +4506,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 spawn4 } from "child_process";
+import { readdirSync as readdirSync5 } from "fs";
+import { join as join11 } from "path";
 import ora4 from "ora";
 var ISSUE_FINDER_PATTERNS = [
   "*-eval.md",
@@ -3757,10 +4563,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 = readdirSync5(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 = join11(squadsDir, squad);
+    const files = readdirSync5(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 +4576,7 @@ function findEvalAgents(squadsDir, filterSquad) {
         agents.push({
           name: file,
           squad,
-          path: join10(squadPath, file)
+          path: join11(squadPath, file)
         });
       }
     }
@@ -3796,7 +4602,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}`);
@@ -3805,9 +4611,9 @@ async function runEvaluators(agents) {
   let issuesCreated = 0;
   for (const agent of agents) {
     spinner.text = `Running ${agent.squad}/${agent.name.replace(".md", "")}...`;
-    const prompt = buildEvalPrompt(agent);
+    const prompt2 = buildEvalPrompt(agent);
     try {
-      const result = await executeClaudePrompt2(prompt);
+      const result = await executeClaudePrompt2(prompt2);
       spinner.succeed(`${agent.name.replace(".md", "")}`);
       const issueMatches = result.match(/Created issue #\d+/g) || [];
       issuesCreated += issueMatches.length;
@@ -3845,9 +4651,9 @@ Read the agent definition at ${agent.path} and follow its instructions exactly.
 
 Do NOT get stuck re-reading files. Evaluate, report findings, create issues, done.`;
 }
-function executeClaudePrompt2(prompt) {
+function executeClaudePrompt2(prompt2) {
   return new Promise((resolve, reject) => {
-    const claude = spawn3("claude", ["--print", prompt], {
+    const claude = spawn4("claude", ["--print", prompt2], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     let output = "";
@@ -3880,9 +4686,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 existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir5 } from "os";
 import http from "http";
 var PERSONAL_DOMAINS = [
   "gmail.com",
@@ -3910,8 +4716,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 = join12(homedir5(), ".squads-cli");
+var AUTH_PATH = join12(AUTH_DIR, "auth.json");
 function isPersonalEmail(email) {
   const domain = email.split("@")[1]?.toLowerCase();
   return PERSONAL_DOMAINS.includes(domain);
@@ -3919,23 +4725,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 (!existsSync12(AUTH_DIR)) {
+    mkdirSync7(AUTH_DIR, { recursive: true });
   }
-  writeFileSync7(AUTH_PATH, JSON.stringify(session, null, 2));
+  writeFileSync8(AUTH_PATH, JSON.stringify(session2, null, 2));
 }
 function loadSession() {
-  if (!existsSync11(AUTH_PATH)) return null;
+  if (!existsSync12(AUTH_PATH)) return null;
   try {
-    return JSON.parse(readFileSync8(AUTH_PATH, "utf-8"));
+    return JSON.parse(readFileSync9(AUTH_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearSession() {
-  if (existsSync11(AUTH_PATH)) {
-    writeFileSync7(AUTH_PATH, "");
+  if (existsSync12(AUTH_PATH)) {
+    writeFileSync8(AUTH_PATH, "");
   }
 }
 function startAuthCallbackServer(port = 54321) {
@@ -4032,7 +4838,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 +4846,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 +4870,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 +4889,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 confirm2(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 confirm2("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 existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
+import { join as join13 } from "path";
 function getTasksFilePath() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) {
     const cwd = process.cwd();
-    const agentsDir = join12(cwd, ".agents");
-    if (!existsSync12(agentsDir)) {
-      mkdirSync7(agentsDir, { recursive: true });
+    const agentsDir = join13(cwd, ".agents");
+    if (!existsSync13(agentsDir)) {
+      mkdirSync8(agentsDir, { recursive: true });
     }
-    return join12(agentsDir, "tasks.json");
+    return join13(agentsDir, "tasks.json");
   }
-  return join12(memoryDir, "..", "tasks.json");
+  return join13(memoryDir, "..", "tasks.json");
 }
 function loadTasks() {
   const tasksPath = getTasksFilePath();
-  if (existsSync12(tasksPath)) {
+  if (existsSync13(tasksPath)) {
     try {
-      return JSON.parse(readFileSync9(tasksPath, "utf-8"));
+      return JSON.parse(readFileSync10(tasksPath, "utf-8"));
     } catch {
       return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
     }
@@ -4120,7 +4992,7 @@ function loadTasks() {
 function saveTasks(data) {
   const tasksPath = getTasksFilePath();
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync8(tasksPath, JSON.stringify(data, null, 2));
+  writeFileSync9(tasksPath, JSON.stringify(data, null, 2));
 }
 function getRecentActivity() {
   const activity = [];
@@ -4136,7 +5008,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 +5142,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 +5157,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 +5196,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 +5211,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 +5343,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 existsSync14, readFileSync as readFileSync11 } from "fs";
+import { join as join14 } from "path";
 function getTasksFilePath2() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join13(memoryDir, "..", "tasks.json");
+  return join14(memoryDir, "..", "tasks.json");
 }
 function loadActiveTasks() {
   const tasksPath = getTasksFilePath2();
-  if (!tasksPath || !existsSync13(tasksPath)) return [];
+  if (!tasksPath || !existsSync14(tasksPath)) return [];
   try {
-    const data = JSON.parse(readFileSync10(tasksPath, "utf-8"));
+    const data = JSON.parse(readFileSync11(tasksPath, "utf-8"));
     return data.tasks?.filter((t) => t.status === "active") || [];
   } catch {
     return [];
@@ -4492,7 +5364,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 +5415,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 +5501,200 @@ function getElapsedTime2(startTime) {
   return "<1m";
 }
 
+// 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/trigger.ts
+import chalk3 from "chalk";
+var SCHEDULER_URL = process.env.SCHEDULER_URL || "http://localhost:8090";
+async function fetchScheduler(path2, options) {
+  const res = await fetch(`${SCHEDULER_URL}${path2}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!res.ok) {
+    const error = await res.text();
+    throw new Error(`Scheduler error: ${res.status} ${error}`);
+  }
+  return res.json();
+}
+async function listTriggers(squad) {
+  const params = squad ? `?squad=${squad}` : "";
+  const triggers = await fetchScheduler(`/triggers${params}`);
+  if (triggers.length === 0) {
+    console.log(chalk3.gray("No triggers found"));
+    return;
+  }
+  console.log(chalk3.bold("\nSmart Triggers\n"));
+  const grouped = triggers.reduce(
+    (acc, t) => {
+      (acc[t.squad] = acc[t.squad] || []).push(t);
+      return acc;
+    },
+    {}
+  );
+  for (const [squadName, squadTriggers] of Object.entries(grouped)) {
+    console.log(chalk3.cyan(`  ${squadName}`));
+    for (const t of squadTriggers) {
+      const status = t.enabled ? chalk3.green("\u25CF") : chalk3.gray("\u25CB");
+      const agent = t.agent ? `/${t.agent}` : "";
+      const fires = t.fire_count > 0 ? chalk3.gray(` (${t.fire_count}x)`) : "";
+      console.log(
+        `    ${status} ${t.name}${chalk3.gray(agent)} P${t.priority}${fires}`
+      );
+    }
+    console.log();
+  }
+}
+async function syncTriggers() {
+  console.log(chalk3.gray("Syncing triggers from SQUAD.md files...\n"));
+  const { execSync: execSync11 } = await import("child_process");
+  const hqPath = process.env.HQ_PATH || `${process.env.HOME}/agents-squads/hq`;
+  try {
+    const output = execSync11(
+      `python ${hqPath}/squads-scheduler/sync_triggers.py`,
+      { encoding: "utf-8", cwd: hqPath }
+    );
+    console.log(output);
+  } catch (error) {
+    const execError = error;
+    console.error(chalk3.red("Sync failed:"), execError.stderr || execError);
+  }
+}
+async function fireTrigger(name) {
+  const triggers = await fetchScheduler(`/triggers`);
+  const trigger = triggers.find((t) => t.name === name);
+  if (!trigger) {
+    console.error(chalk3.red(`Trigger '${name}' not found`));
+    return;
+  }
+  console.log(
+    chalk3.gray(`Firing ${trigger.squad}/${trigger.agent || "*"}...`)
+  );
+  const execution = await fetchScheduler(
+    `/triggers/${trigger.id}/fire`,
+    { method: "POST" }
+  );
+  console.log(chalk3.green(`\u2713 Queued execution ${execution.id.slice(0, 8)}`));
+}
+async function toggleTrigger(name, enable) {
+  const triggers = await fetchScheduler(`/triggers`);
+  const trigger = triggers.find((t) => t.name === name);
+  if (!trigger) {
+    console.error(chalk3.red(`Trigger '${name}' not found`));
+    return;
+  }
+  await fetchScheduler(`/triggers/${trigger.id}`, {
+    method: "PATCH",
+    body: JSON.stringify({ enabled: enable })
+  });
+  const status = enable ? chalk3.green("enabled") : chalk3.gray("disabled");
+  console.log(`${trigger.name} ${status}`);
+}
+async function showStatus() {
+  try {
+    const stats = await fetchScheduler("/stats");
+    console.log(chalk3.bold("\nScheduler Status\n"));
+    console.log(chalk3.cyan("  Triggers"));
+    console.log(`    Total:     ${stats.triggers.total}`);
+    console.log(`    Enabled:   ${chalk3.green(stats.triggers.enabled)}`);
+    console.log(`    Fired 24h: ${stats.triggers.fired_24h}`);
+    console.log(chalk3.cyan("\n  Executions (24h)"));
+    console.log(`    Completed: ${chalk3.green(stats.executions_24h.completed)}`);
+    console.log(`    Failed:    ${chalk3.red(stats.executions_24h.failed)}`);
+    console.log(`    Running:   ${chalk3.yellow(stats.executions_24h.running)}`);
+    console.log(`    Queued:    ${stats.executions_24h.queued}`);
+    console.log();
+  } catch {
+    console.error(chalk3.red("Scheduler not running or unreachable"));
+    console.log(chalk3.gray(`  Expected at: ${SCHEDULER_URL}`));
+  }
+}
+function registerTriggerCommand(program2) {
+  const trigger = program2.command("trigger").description("Manage smart triggers");
+  trigger.command("list [squad]").description("List triggers").action(async (squad) => {
+    await listTriggers(squad);
+  });
+  trigger.command("sync").description("Sync SQUAD.md triggers to scheduler").action(async () => {
+    await syncTriggers();
+  });
+  trigger.command("fire <name>").description("Manually fire a trigger").action(async (name) => {
+    await fireTrigger(name);
+  });
+  trigger.command("enable <name>").description("Enable a trigger").action(async (name) => {
+    await toggleTrigger(name, true);
+  });
+  trigger.command("disable <name>").description("Disable a trigger").action(async (name) => {
+    await toggleTrigger(name, false);
+  });
+  trigger.command("status").description("Show scheduler status").action(async () => {
+    await showStatus();
+  });
+}
+
 // src/cli.ts
 var envPaths = [
-  join14(process.cwd(), ".env"),
-  join14(process.cwd(), "..", "hq", ".env"),
-  join14(homedir4(), "agents-squads", "hq", ".env")
+  join15(process.cwd(), ".env"),
+  join15(process.cwd(), "..", "hq", ".env"),
+  join15(homedir6(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync14(envPath)) {
+  if (existsSync15(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,12 +5708,17 @@ 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,
   importance: opts.importance
 }));
+memory.command("extract").description("Extract memories from recent conversations into Engram").option("-s, --session <session>", "Extract specific session only").option("-h, --hours <hours>", "Look back period in hours", "24").option("-d, --dry-run", "Preview without sending to Engram").action((opts) => memoryExtractCommand({
+  session: opts.session,
+  hours: parseInt(opts.hours, 10),
+  dryRun: opts.dryRun
+}));
 var goal = program.command("goal").description("Manage squad goals");
 goal.command("set <squad> <description>").description("Set a goal for a squad").option("-m, --metric <metrics...>", "Metrics to track").action(goalSetCommand);
 goal.command("list [squad]").description("List goals for squad(s)").option("-a, --all", "Show completed goals too").action(goalListCommand);
@@ -4677,30 +5728,80 @@ 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
+}));
+sessions.command("summary").description("Show pretty session summary (auto-detects current session or pass JSON)").option("-d, --data <json>", "JSON data for summary (overrides auto-detection)").option("-f, --file <path>", "Path to JSON file with summary data").option("-j, --json", "Output as JSON instead of pretty format").action(async (options) => {
+  const { buildCurrentSessionSummary } = await import("./sessions-UR3YGSLR.js");
+  let data;
+  if (options.file) {
+    const { readFileSync: readFileSync12 } = await import("fs");
+    data = JSON.parse(readFileSync12(options.file, "utf-8"));
+  } else if (options.data) {
+    data = JSON.parse(options.data);
+  } else if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const input = Buffer.concat(chunks).toString("utf-8").trim();
+    if (input) {
+      data = JSON.parse(input);
+    } else {
+      data = await buildCurrentSessionSummary();
+    }
+  } else {
+    data = await buildCurrentSessionSummary();
+  }
+  await sessionsSummaryCommand(data, { 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)));
+registerTriggerCommand(program);
 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(`
-${chalk3.bold.magenta("squads")} - AI agent squad management
+${chalk4.bold.magenta("squads")} - AI agent squad management
+
+${chalk4.dim("Quick start:")}
+  ${chalk4.cyan("squads status")}                  View all squads status
+  ${chalk4.cyan("squads run <squad>")}             Run a squad
+  ${chalk4.cyan('squads memory query "<term>"')}   Search squad memory
 
-${chalk3.dim("Quick start:")}
-  ${chalk3.cyan("squads status")}                  View all squads status
-  ${chalk3.cyan("squads run <squad>")}             Run a squad
-  ${chalk3.cyan('squads memory query "<term>"')}   Search squad memory
+${chalk4.dim("Goals & Feedback:")}
+  ${chalk4.cyan('squads goal set <squad> "<goal>"')}    Set a goal
+  ${chalk4.cyan("squads goal list")}                    View active goals
+  ${chalk4.cyan('squads feedback add <squad> 4 "msg"')} Rate last execution
 
-${chalk3.dim("Goals & Feedback:")}
-  ${chalk3.cyan('squads goal set <squad> "<goal>"')}    Set a goal
-  ${chalk3.cyan("squads goal list")}                    View active goals
-  ${chalk3.cyan('squads feedback add <squad> 4 "msg"')} Rate last execution
+${chalk4.dim("Smart Triggers:")}
+  ${chalk4.cyan("squads trigger list")}                 View all triggers
+  ${chalk4.cyan("squads trigger sync")}                 Sync from SQUAD.md
+  ${chalk4.cyan("squads trigger fire <name>")}          Manually fire trigger
 
-${chalk3.dim("Examples:")}
-  ${chalk3.cyan("squads run website")}                  Run website squad
-  ${chalk3.cyan('squads goal set finance "Track costs"')} Set finance goal
-  ${chalk3.cyan("squads feedback stats")}               View feedback summary
+${chalk4.dim("Examples:")}
+  ${chalk4.cyan("squads run website")}                  Run website squad
+  ${chalk4.cyan('squads goal set finance "Track costs"')} Set finance goal
+  ${chalk4.cyan("squads trigger status")}               Scheduler health
 
-${chalk3.dim("Run")} ${chalk3.cyan("squads --help")} ${chalk3.dim("for all commands.")}
+${chalk4.dim("Run")} ${chalk4.cyan("squads --help")} ${chalk4.dim("for all commands.")}
 `);
 }
 //# sourceMappingURL=cli.js.map