squads-cli 0.1.2

package/dist/cli.js

@@ -0,0 +1,4706 @@
+#!/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');
+});
+
+// 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 { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/version.ts
+var version = "0.1.0";
+
+// src/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs/promises";
+import path from "path";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function checkGitStatus(cwd = process.cwd()) {
+  const status = {
+    isGitRepo: false,
+    hasRemote: false,
+    isDirty: false,
+    uncommittedCount: 0
+  };
+  if (!existsSync(join(cwd, ".git"))) {
+    return status;
+  }
+  status.isGitRepo = true;
+  try {
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    status.branch = branch;
+    const remotes = execSync("git remote -v", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (remotes) {
+      status.hasRemote = true;
+      const lines = remotes.split("\n");
+      if (lines.length > 0) {
+        const parts = lines[0].split(/\s+/);
+        status.remoteName = parts[0];
+        status.remoteUrl = parts[1];
+      }
+    }
+    const statusOutput = execSync("git status --porcelain", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (statusOutput) {
+      status.isDirty = true;
+      status.uncommittedCount = statusOutput.split("\n").filter((l) => l.trim()).length;
+    }
+  } catch {
+  }
+  return status;
+}
+function getRepoName(remoteUrl) {
+  if (!remoteUrl) return null;
+  const match = remoteUrl.match(/[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+  return match ? match[1] : null;
+}
+var SQUAD_REPOS = ["hq", "agents-squads-web", "squads-cli", "company", "product", "engineering", "research", "intelligence", "customer", "finance", "marketing"];
+var SQUAD_REPO_MAP = {
+  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"]
+};
+var SQUAD_LABELS = {
+  website: ["website", "web", "frontend", "ui"],
+  product: ["product", "cli", "feature"],
+  engineering: ["engineering", "infra", "backend", "bug"],
+  research: ["research", "analysis"],
+  intelligence: ["intel", "monitoring"],
+  customer: ["customer", "sales", "lead"],
+  finance: ["finance", "cost", "billing"],
+  company: ["company", "strategy"],
+  marketing: ["marketing", "content", "seo"]
+};
+function getGitHubStats(basePath, days = 30) {
+  const stats = {
+    prsOpened: 0,
+    prsMerged: 0,
+    issuesClosed: 0,
+    issuesOpen: 0,
+    bySquad: /* @__PURE__ */ new Map()
+  };
+  for (const squad of Object.keys(SQUAD_REPO_MAP)) {
+    stats.bySquad.set(squad, {
+      prsOpened: 0,
+      prsMerged: 0,
+      issuesClosed: 0,
+      issuesOpen: 0,
+      commits: 0,
+      recentIssues: [],
+      recentPRs: []
+    });
+  }
+  const repos = ["hq", "agents-squads-web"];
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+  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 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 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++;
+          if (squadStats) {
+            squadStats.issuesOpen++;
+            if (squadStats.recentIssues.length < 3) {
+              squadStats.recentIssues.push({
+                title: issue.title,
+                number: issue.number,
+                state: issue.state
+              });
+            }
+          }
+        }
+      }
+    } 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);
+        if (squadStats) {
+          squadStats.commits += commits;
+        }
+      }
+    }
+  }
+  return stats;
+}
+function detectSquadFromPR(pr, repo) {
+  for (const label of pr.labels || []) {
+    const labelLower = label.name.toLowerCase();
+    for (const [squad, patterns] of Object.entries(SQUAD_LABELS)) {
+      if (patterns.some((p) => labelLower.includes(p))) {
+        return squad;
+      }
+    }
+  }
+  const titleLower = pr.title.toLowerCase();
+  for (const [squad, patterns] of Object.entries(SQUAD_LABELS)) {
+    if (patterns.some((p) => titleLower.includes(p))) {
+      return squad;
+    }
+  }
+  if (repo === "agents-squads-web") return "website";
+  if (repo === "squads-cli") return "product";
+  return "engineering";
+}
+function detectSquadFromIssue(issue, repo) {
+  for (const label of issue.labels || []) {
+    const labelLower = label.name.toLowerCase();
+    if (labelLower.startsWith("squad:")) {
+      return labelLower.replace("squad:", "");
+    }
+    for (const [squad, patterns] of Object.entries(SQUAD_LABELS)) {
+      if (patterns.some((p) => labelLower.includes(p))) {
+        return squad;
+      }
+    }
+  }
+  const titleLower = issue.title.toLowerCase();
+  for (const [squad, patterns] of Object.entries(SQUAD_LABELS)) {
+    if (patterns.some((p) => titleLower.includes(p))) {
+      return squad;
+    }
+  }
+  if (repo === "agents-squads-web") return "website";
+  if (repo === "squads-cli") return "product";
+  return "engineering";
+}
+function getMultiRepoGitStats(basePath, days = 30) {
+  const stats = {
+    totalCommits: 0,
+    commitsByDay: /* @__PURE__ */ new Map(),
+    commitsByAuthor: /* @__PURE__ */ new Map(),
+    commitsByRepo: /* @__PURE__ */ new Map(),
+    activeDays: 0,
+    avgCommitsPerDay: 0,
+    peakDay: null,
+    repos: []
+  };
+  for (const repo of SQUAD_REPOS) {
+    const repoPath = join(basePath, repo);
+    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
+      continue;
+    }
+    try {
+      const logOutput = execSync(
+        `git log --since="${days} days ago" --format="%H|%aN|%ad|%s" --date=short 2>/dev/null`,
+        { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      if (!logOutput) continue;
+      const commits = logOutput.split("\n").filter((l) => l.trim());
+      const authors = /* @__PURE__ */ new Set();
+      let lastCommit = "";
+      for (const line of commits) {
+        const [hash, author, date, message] = line.split("|");
+        if (!hash) continue;
+        stats.totalCommits++;
+        authors.add(author);
+        if (!lastCommit) lastCommit = date;
+        const dayCount = stats.commitsByDay.get(date) || 0;
+        stats.commitsByDay.set(date, dayCount + 1);
+        const authorCount = stats.commitsByAuthor.get(author) || 0;
+        stats.commitsByAuthor.set(author, authorCount + 1);
+        const repoCount = stats.commitsByRepo.get(repo) || 0;
+        stats.commitsByRepo.set(repo, repoCount + 1);
+      }
+      stats.repos.push({
+        name: repo,
+        path: repoPath,
+        commits: commits.length,
+        lastCommit,
+        authors: Array.from(authors)
+      });
+    } catch {
+    }
+  }
+  stats.activeDays = stats.commitsByDay.size;
+  stats.avgCommitsPerDay = stats.activeDays > 0 ? Math.round(stats.totalCommits / days * 10) / 10 : 0;
+  let peakCount = 0;
+  let peakDate = "";
+  for (const [date, count] of stats.commitsByDay) {
+    if (count > peakCount) {
+      peakCount = count;
+      peakDate = date;
+    }
+  }
+  if (peakDate) {
+    stats.peakDay = { date: peakDate, count: peakCount };
+  }
+  return stats;
+}
+function getActivitySparkline(basePath, days = 7) {
+  const activity = [];
+  const now = /* @__PURE__ */ new Date();
+  for (let i = days - 1; i >= 0; i--) {
+    const date = new Date(now);
+    date.setDate(date.getDate() - i);
+    const dateStr = date.toISOString().split("T")[0];
+    activity.push(0);
+  }
+  for (const repo of SQUAD_REPOS) {
+    const repoPath = join(basePath, repo);
+    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
+      continue;
+    }
+    try {
+      const logOutput = execSync(
+        `git log --since="${days} days ago" --format="%ad" --date=short 2>/dev/null`,
+        { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      if (!logOutput) continue;
+      for (const dateStr of logOutput.split("\n")) {
+        const commitDate = new Date(dateStr);
+        const daysAgo = Math.floor((now.getTime() - commitDate.getTime()) / (1e3 * 60 * 60 * 24));
+        const index = days - 1 - daysAgo;
+        if (index >= 0 && index < days) {
+          activity[index]++;
+        }
+      }
+    } catch {
+    }
+  }
+  return activity;
+}
+
+// src/lib/telemetry.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+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 eventQueue = [];
+var flushScheduled = false;
+function ensureDir() {
+  if (!existsSync2(TELEMETRY_DIR)) {
+    mkdirSync(TELEMETRY_DIR, { recursive: true });
+  }
+}
+function getConfig() {
+  ensureDir();
+  if (!existsSync2(CONFIG_PATH)) {
+    const config2 = {
+      enabled: true,
+      // Opt-out by default (common for CLIs)
+      anonymousId: randomUUID(),
+      firstRun: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeFileSync(CONFIG_PATH, JSON.stringify(config2, null, 2));
+    return config2;
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return { enabled: false, anonymousId: "", firstRun: "" };
+  }
+}
+function isEnabled() {
+  if (process.env.SQUADS_TELEMETRY_DISABLED === "1") {
+    return false;
+  }
+  if (process.env.DO_NOT_TRACK === "1") {
+    return false;
+  }
+  return getConfig().enabled;
+}
+async function track(event, properties) {
+  if (!isEnabled()) return;
+  const config2 = getConfig();
+  const telemetryEvent = {
+    event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    properties: {
+      ...properties,
+      anonymousId: config2.anonymousId,
+      cliVersion: process.env.npm_package_version || "unknown"
+    }
+  };
+  storeEventLocally(telemetryEvent);
+  eventQueue.push(telemetryEvent);
+  if (TELEMETRY_ENDPOINT && !flushScheduled) {
+    flushScheduled = true;
+    setImmediate(() => {
+      flushEvents().catch(() => {
+      });
+    });
+  }
+}
+async function flushEvents() {
+  if (!TELEMETRY_ENDPOINT || eventQueue.length === 0) {
+    flushScheduled = false;
+    return;
+  }
+  const batch = [...eventQueue];
+  eventQueue = [];
+  flushScheduled = false;
+  try {
+    await fetch(TELEMETRY_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ events: batch })
+    });
+  } catch {
+    eventQueue = [...batch, ...eventQueue].slice(-100);
+  }
+}
+function storeEventLocally(event) {
+  ensureDir();
+  let events = [];
+  if (existsSync2(EVENTS_PATH)) {
+    try {
+      events = JSON.parse(readFileSync(EVENTS_PATH, "utf-8"));
+    } catch {
+      events = [];
+    }
+  }
+  events.push(event);
+  if (events.length > 1e3) {
+    events = events.slice(-1e3);
+  }
+  writeFileSync(EVENTS_PATH, JSON.stringify(events, null, 2));
+}
+var Events = {
+  // Lifecycle
+  CLI_INIT: "cli.init",
+  CLI_ERROR: "cli.error",
+  // Commands
+  CLI_RUN: "cli.run",
+  CLI_STATUS: "cli.status",
+  CLI_DASHBOARD: "cli.dashboard",
+  CLI_WORKERS: "cli.workers",
+  // Goals
+  CLI_GOAL_SET: "cli.goal.set",
+  CLI_GOAL_LIST: "cli.goal.list",
+  CLI_GOAL_COMPLETE: "cli.goal.complete",
+  CLI_GOAL_PROGRESS: "cli.goal.progress",
+  // Memory
+  CLI_MEMORY_QUERY: "cli.memory.query",
+  CLI_MEMORY_SHOW: "cli.memory.show",
+  CLI_MEMORY_UPDATE: "cli.memory.update",
+  CLI_MEMORY_LIST: "cli.memory.list",
+  CLI_MEMORY_SYNC: "cli.memory.sync",
+  // Feedback
+  CLI_FEEDBACK_ADD: "cli.feedback.add",
+  CLI_FEEDBACK_SHOW: "cli.feedback.show",
+  CLI_FEEDBACK_STATS: "cli.feedback.stats",
+  // Auth
+  CLI_LOGIN: "cli.login",
+  CLI_LOGOUT: "cli.logout"
+};
+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("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const cwd = process.cwd();
+  console.log(chalk.dim("Checking project setup...\n"));
+  const gitStatus = checkGitStatus(cwd);
+  if (!gitStatus.isGitRepo) {
+    console.log(chalk.yellow("\u26A0 No git repository found."));
+    console.log(chalk.dim("  Squads work best with git for version control and GitHub integration."));
+    console.log(chalk.dim("  Run: git init && git remote add origin <your-repo-url>\n"));
+  } else {
+    console.log(chalk.green("\u2713 Git repository detected"));
+    if (gitStatus.hasRemote) {
+      const repoName = getRepoName(gitStatus.remoteUrl);
+      console.log(chalk.green(`\u2713 Remote: ${chalk.cyan(repoName || gitStatus.remoteUrl)}`));
+    } else {
+      console.log(chalk.yellow("\u26A0 No remote configured."));
+      console.log(chalk.dim("  Add a remote: git remote add origin <your-repo-url>\n"));
+    }
+    if (gitStatus.isDirty) {
+      console.log(chalk.yellow(`\u26A0 ${gitStatus.uncommittedCount} uncommitted changes`));
+    }
+  }
+  console.log();
+  const spinner = ora("Initializing squad project...").start();
+  try {
+    const dirs = [
+      ".agents/squads",
+      ".agents/memory",
+      ".agents/outputs",
+      ".claude"
+    ];
+    for (const dir of dirs) {
+      await fs.mkdir(path.join(cwd, dir), { recursive: true });
+    }
+    const commitTemplate = `
+
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# Commit message format (delete this comment block):
+#
+# <type>(<scope>): <subject>
+#
+# <body>
+#
+# \u{1F916} Generated with [Agents Squads](https://agents-squads.com)
+#
+# Co-Authored-By: <model> <email>
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# AI Models (add those that contributed to this commit):
+#
+# Model               | Email                      | API Key
+# --------------------|----------------------------|------------------
+# Claude Opus 4.5     | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
+# Claude Sonnet 4     | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
+# Claude Haiku 3.5    | <noreply@anthropic.com>    | ANTHROPIC_API_KEY
+# GPT-4o              | <noreply@openai.com>       | OPENAI_API_KEY
+# GPT-o1              | <noreply@openai.com>       | OPENAI_API_KEY
+# Gemini 2.0 Flash    | <noreply@google.com>       | GEMINI_API_KEY
+# Grok 3              | <noreply@x.ai>             | XAI_API_KEY
+# Perplexity          | <noreply@perplexity.ai>    | PERPLEXITY_API_KEY
+# Manus AI            | <noreply@manus.im>         | MANUS_API_KEY
+#
+# Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+# Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>
+# Co-Authored-By: Claude Haiku 3.5 <noreply@anthropic.com>
+# Co-Authored-By: GPT-4o <noreply@openai.com>
+# Co-Authored-By: GPT-o1 <noreply@openai.com>
+# Co-Authored-By: Gemini 2.0 Flash <noreply@google.com>
+# Co-Authored-By: Grok 3 <noreply@x.ai>
+# Co-Authored-By: Perplexity <noreply@perplexity.ai>
+# Co-Authored-By: Manus AI <noreply@manus.im>
+# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`;
+    await fs.writeFile(
+      path.join(cwd, ".agents/commit-template.txt"),
+      commitTemplate
+    );
+    const mailmap = `# Git author name consolidation
+# Format: Proper Name <proper@email> Commit Name <commit@email>
+# Add entries to consolidate multiple git identities
+
+# AI Contributors
+Agents Squads <agents@agents-squads.com> Agents Squads <agents@agents-squads.com>
+`;
+    await fs.writeFile(path.join(cwd, ".mailmap"), mailmap);
+    const claudeSettings = {
+      hooks: {
+        SessionStart: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: "squads status",
+                timeout: 10
+              }
+            ]
+          }
+        ],
+        Stop: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: "squads memory sync",
+                timeout: 15
+              }
+            ]
+          }
+        ]
+      }
+    };
+    await fs.writeFile(
+      path.join(cwd, ".claude/settings.json"),
+      JSON.stringify(claudeSettings, null, 2)
+    );
+    const exampleAgent = `# Example Agent
+
+## Purpose
+Demonstrate basic agent structure.
+
+## Model
+claude-sonnet-4
+
+## Tools
+- Read
+- Write
+- WebSearch
+
+## Instructions
+1. Greet the user
+2. Ask how you can help
+3. Execute the task
+
+## Output
+Markdown summary of actions taken.
+`;
+    await fs.writeFile(
+      path.join(cwd, ".agents/squads/example-agent.md"),
+      exampleAgent
+    );
+    const claudeMdPath = path.join(cwd, "CLAUDE.md");
+    try {
+      await fs.access(claudeMdPath);
+    } catch {
+      await fs.writeFile(
+        claudeMdPath,
+        `# Project Instructions
+
+## Squads CLI
+
+This project uses AI agent squads. The \`squads\` CLI provides persistent memory across sessions.
+
+### Key Commands
+
+| Command | Purpose |
+|---------|---------|
+| \`squads status\` | Overview of all squads (runs on session start) |
+| \`squads dash\` | Full operational dashboard |
+| \`squads dash --ceo\` | Executive summary with P0/P1 priorities |
+| \`squads goal list\` | View all active goals |
+| \`squads memory query "<topic>"\` | Search squad memory before researching |
+| \`squads run <squad>\` | Execute a squad |
+
+### Workflow
+
+1. **Session Start**: \`squads status\` runs automatically via hook
+2. **Before Research**: Query memory to avoid re-doing work
+3. **Session End**: Memory syncs automatically from git commits
+
+### Git Commit Format
+
+All commits should use the Agents Squads format:
+
+\`\`\`
+<type>(<scope>): <subject>
+
+<body>
+
+\u{1F916} Generated with [Agents Squads](https://agents-squads.com)
+
+Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+\`\`\`
+
+**AI Models** (include those that contributed):
+
+| Model | Co-Author Email | API Key Required |
+|-------|-----------------|------------------|
+| Claude Opus 4.5 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
+| Claude Sonnet 4 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
+| Claude Haiku 3.5 | \`<noreply@anthropic.com>\` | \`ANTHROPIC_API_KEY\` |
+| GPT-4o | \`<noreply@openai.com>\` | \`OPENAI_API_KEY\` |
+| GPT-o1 | \`<noreply@openai.com>\` | \`OPENAI_API_KEY\` |
+| Gemini 2.0 Flash | \`<noreply@google.com>\` | \`GEMINI_API_KEY\` |
+| Grok 3 | \`<noreply@x.ai>\` | \`XAI_API_KEY\` |
+| Perplexity | \`<noreply@perplexity.ai>\` | \`PERPLEXITY_API_KEY\` |
+| Manus AI | \`<noreply@manus.im>\` | \`MANUS_API_KEY\` |
+
+### For Reports
+
+Always use CLI commands for status reports:
+- Executive summary: \`squads dash --ceo\`
+- Operational view: \`squads dash\`
+- Goals: \`squads goal list\`
+`
+      );
+    }
+    spinner.succeed("Squad project initialized!");
+    await track(Events.CLI_INIT, {
+      hasGit: gitStatus.isGitRepo,
+      hasRemote: gitStatus.hasRemote,
+      template: options.template
+    });
+    console.log(`
+${chalk.green("Success!")} Created squad project structure:
+
+  ${chalk.cyan(".agents/")}
+  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("squads/")}           Squad & agent definitions
+  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("memory/")}           Persistent squad memory
+  ${chalk.dim("\u251C\u2500\u2500")} ${chalk.cyan("outputs/")}          Squad outputs
+  ${chalk.dim("\u2514\u2500\u2500")} ${chalk.cyan("commit-template.txt")} Git commit format
+
+  ${chalk.cyan(".mailmap")}              Author name consolidation
+
+${chalk.dim("Commit format:")}
+  \u{1F916} Generated with [Agents Squads](https://agents-squads.com)
+  Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
+
+${chalk.dim("Next steps:")}
+  ${chalk.cyan("1.")} Create a squad: ${chalk.yellow("mkdir .agents/squads/my-squad && touch .agents/squads/my-squad/SQUAD.md")}
+  ${chalk.cyan("2.")} Set a goal: ${chalk.yellow('squads goal set my-squad "Solve a problem"')}
+  ${chalk.cyan("3.")} Run it: ${chalk.yellow("squads run my-squad")}
+
+${chalk.dim("Put your first squad to work solving a problem in minutes.")}
+`);
+  } catch (error) {
+    spinner.fail("Failed to initialize project");
+    console.error(chalk.red(error));
+    process.exit(1);
+  }
+}
+
+// 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";
+
+// src/lib/squad-parser.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, basename } from "path";
+function findSquadsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const squadsPath = join3(dir, ".agents", "squads");
+    if (existsSync3(squadsPath)) {
+      return squadsPath;
+    }
+    const parent = join3(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function listSquads(squadsDir) {
+  const squads = [];
+  const entries = readdirSync(squadsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith("_")) {
+      const squadFile = join3(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync3(squadFile)) {
+        squads.push(entry.name);
+      }
+    }
+  }
+  return squads;
+}
+function listAgents(squadsDir, squadName) {
+  const agents = [];
+  const dirs = squadName ? [squadName] : readdirSync(squadsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name);
+  for (const dir of dirs) {
+    const squadPath = join3(squadsDir, dir);
+    if (!existsSync3(squadPath)) continue;
+    const files = readdirSync(squadPath);
+    for (const file of files) {
+      if (file.endsWith(".md") && file !== "SQUAD.md") {
+        const agentName = file.replace(".md", "");
+        agents.push({
+          name: agentName,
+          role: `Agent in ${dir}`,
+          trigger: "manual",
+          filePath: join3(squadPath, file)
+        });
+      }
+    }
+  }
+  return agents;
+}
+function parseSquadFile(filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split("\n");
+  const squad = {
+    name: basename(filePath).replace(".md", ""),
+    mission: "",
+    agents: [],
+    pipelines: [],
+    triggers: { scheduled: [], event: [], manual: [] },
+    dependencies: [],
+    outputPath: "",
+    goals: []
+  };
+  let currentSection = "";
+  let inTable = false;
+  let tableHeaders = [];
+  for (const line of lines) {
+    if (line.startsWith("# Squad:")) {
+      squad.name = line.replace("# Squad:", "").trim().toLowerCase();
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      inTable = false;
+      continue;
+    }
+    if (currentSection === "mission" && line.trim() && !line.startsWith("#")) {
+      if (!squad.mission) {
+        squad.mission = line.trim();
+      }
+    }
+    if (currentSection.includes("agent") || currentSection.includes("orchestrator") || currentSection.includes("evaluator") || currentSection.includes("builder") || currentSection.includes("priority")) {
+      if (line.includes("|") && line.includes("Agent")) {
+        inTable = true;
+        tableHeaders = line.split("|").map((h) => h.trim().toLowerCase());
+        continue;
+      }
+      if (inTable && line.includes("|") && !line.includes("---")) {
+        const cells = line.split("|").map((c) => c.trim().replace(/`/g, ""));
+        const agentIdx = tableHeaders.findIndex((h) => h === "agent");
+        const roleIdx = tableHeaders.findIndex((h) => h === "role");
+        const triggerIdx = tableHeaders.findIndex((h) => h === "trigger");
+        const statusIdx = tableHeaders.findIndex((h) => h === "status");
+        if (agentIdx >= 0 && cells[agentIdx]) {
+          squad.agents.push({
+            name: cells[agentIdx],
+            role: roleIdx >= 0 ? cells[roleIdx] : "",
+            trigger: triggerIdx >= 0 ? cells[triggerIdx] : "manual",
+            status: statusIdx >= 0 ? cells[statusIdx] : "active"
+          });
+        }
+      }
+    }
+    if (line.includes("\u2192") && line.includes("`")) {
+      const pipelineMatch = line.match(/`([^`]+)`\s*→\s*`([^`]+)`/g);
+      if (pipelineMatch) {
+        const agentNames = line.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("pipeline:")) {
+      const pipelineContent = line.split(":")[1];
+      if (pipelineContent && pipelineContent.includes("\u2192")) {
+        const agentNames = pipelineContent.match(/`([^`]+)`/g)?.map((m) => m.replace(/`/g, "")) || [];
+        if (agentNames.length >= 2) {
+          squad.pipelines.push({
+            name: "default",
+            agents: agentNames
+          });
+        }
+      }
+    }
+    if (line.toLowerCase().includes("primary") && line.includes("`")) {
+      const match = line.match(/`([^`]+)`/);
+      if (match) {
+        squad.outputPath = match[1].replace(/\/$/, "");
+      }
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        const completed = goalMatch[1] === "x";
+        let description = goalMatch[2].trim();
+        let progress2;
+        const progressMatch = description.match(/\(progress:\s*([^)]+)\)/i);
+        if (progressMatch) {
+          progress2 = progressMatch[1];
+          description = description.replace(progressMatch[0], "").trim();
+        }
+        squad.goals.push({
+          description,
+          completed,
+          progress: progress2
+        });
+      }
+    }
+  }
+  return squad;
+}
+function loadSquad(squadName) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return null;
+  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync3(squadFile)) return null;
+  return parseSquadFile(squadFile);
+}
+function loadAgentDefinition(agentPath) {
+  if (!existsSync3(agentPath)) return "";
+  return readFileSync2(agentPath, "utf-8");
+}
+function addGoalToSquad(squadName, goal2) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync3(squadFile)) return false;
+  let content = readFileSync2(squadFile, "utf-8");
+  if (!content.includes("## Goals")) {
+    const insertPoint = content.indexOf("## Dependencies");
+    if (insertPoint > 0) {
+      content = content.slice(0, insertPoint) + `## Goals
+
+- [ ] ${goal2}
+
+` + content.slice(insertPoint);
+    } else {
+      content += `
+## Goals
+
+- [ ] ${goal2}
+`;
+    }
+  } else {
+    const goalsIdx = content.indexOf("## Goals");
+    const nextSectionIdx = content.indexOf("\n## ", goalsIdx + 1);
+    const endIdx = nextSectionIdx > 0 ? nextSectionIdx : content.length;
+    const goalsSection = content.slice(goalsIdx, endIdx);
+    const lastGoalMatch = goalsSection.match(/^-\s*\[[ x]\].+$/gm);
+    if (lastGoalMatch) {
+      const lastGoal = lastGoalMatch[lastGoalMatch.length - 1];
+      const lastGoalIdx = content.lastIndexOf(lastGoal, endIdx);
+      const insertPos = lastGoalIdx + lastGoal.length;
+      content = content.slice(0, insertPos) + `
+- [ ] ${goal2}` + content.slice(insertPos);
+    } else {
+      const headerEnd = goalsIdx + "## Goals".length;
+      content = content.slice(0, headerEnd) + `
+
+- [ ] ${goal2}` + content.slice(headerEnd);
+    }
+  }
+  writeFileSync2(squadFile, content);
+  return true;
+}
+function updateGoalInSquad(squadName, goalIndex, updates) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) return false;
+  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync3(squadFile)) return false;
+  const content = readFileSync2(squadFile, "utf-8");
+  const lines = content.split("\n");
+  let currentSection = "";
+  let goalCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line.replace("## ", "").trim().toLowerCase();
+      continue;
+    }
+    if (currentSection === "goals") {
+      const goalMatch = line.match(/^-\s*\[([ x])\]\s*(.+)$/);
+      if (goalMatch) {
+        if (goalCount === goalIndex) {
+          let newLine = "- [" + (updates.completed ? "x" : " ") + "] " + goalMatch[2];
+          if (updates.progress !== void 0) {
+            newLine = newLine.replace(/\s*\(progress:\s*[^)]+\)/i, "");
+            if (updates.progress) {
+              newLine += ` (progress: ${updates.progress})`;
+            }
+          }
+          lines[i] = newLine;
+          writeFileSync2(squadFile, lines.join("\n"));
+          return true;
+        }
+        goalCount++;
+      }
+    }
+  }
+  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");
+}
+function logExecution(record) {
+  const logPath = getExecutionLogPath(record.squadName, record.agentName);
+  if (!logPath) return;
+  const dir = dirname2(logPath);
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync5(logPath)) {
+    content = readFileSync4(logPath, "utf-8");
+  } else {
+    content = `# ${record.squadName}/${record.agentName} - Execution Log
+
+`;
+  }
+  const entry = `
+---
+**${record.startTime}** | Status: ${record.status}
+${record.endTime ? `Completed: ${record.endTime}` : ""}
+${record.outcome ? `Outcome: ${record.outcome}` : ""}
+`;
+  writeFileSync4(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");
+  const endTime = (/* @__PURE__ */ new Date()).toISOString();
+  content = content.replace(
+    /Status: running\n$/,
+    `Status: ${status}
+Completed: ${endTime}
+${outcome ? `Outcome: ${outcome}
+` : ""}`
+  );
+  writeFileSync4(logPath, content);
+}
+async function runCommand(target, options) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  const squad = loadSquad(target);
+  if (squad) {
+    await track(Events.CLI_RUN, { type: "squad", target: squad.name });
+    await runSquad(squad, squadsDir, options);
+  } else {
+    const agents = listAgents(squadsDir);
+    const agent = agents.find((a) => a.name === target);
+    if (agent && agent.filePath) {
+      const pathParts = agent.filePath.split("/");
+      const squadIdx = pathParts.indexOf("squads");
+      const squadName = squadIdx >= 0 ? pathParts[squadIdx + 1] : "unknown";
+      await runAgent(agent.name, agent.filePath, squadName, options);
+    } else {
+      writeLine(`  ${colors.red}Squad or agent "${target}" not found${RESET}`);
+      writeLine(`  ${colors.dim}Run \`squads list\` to see available squads and agents.${RESET}`);
+      process.exit(1);
+    }
+  }
+}
+async function runSquad(squad, squadsDir, options) {
+  if (!squad) return;
+  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}run${RESET} ${colors.cyan}${squad.name}${RESET}`);
+  writeLine();
+  if (squad.mission) {
+    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}Started: ${startTime}${RESET}`);
+  writeLine();
+  if (squad.pipelines.length > 0) {
+    const pipeline = squad.pipelines[0];
+    writeLine(`  ${bold}Pipeline${RESET} ${colors.dim}${pipeline.agents.join(" \u2192 ")}${RESET}`);
+    writeLine();
+    for (let i = 0; i < pipeline.agents.length; i++) {
+      const agentName = pipeline.agents[i];
+      const agentPath = join5(squadsDir, squad.name, `${agentName}.md`);
+      if (existsSync5(agentPath)) {
+        writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
+        await runAgent(agentName, agentPath, squad.name, options);
+        writeLine();
+      } else {
+        writeLine(`  ${icons.warning} ${colors.yellow}Agent ${agentName} not found, skipping${RESET}`);
+      }
+    }
+  } 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);
+      }
+    } 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}After execution, record outcome:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads feedback add ${colors.cyan}${squad.name}${RESET} ${colors.cyan}<1-5>${RESET} ${colors.cyan}"<feedback>"${RESET}`);
+  writeLine();
+}
+async function runAgent(agentName, agentPath, squadName, options) {
+  const spinner = ora2(`Running agent: ${agentName}`).start();
+  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  const definition = loadAgentDefinition(agentPath);
+  if (options.dryRun) {
+    spinner.info(`[DRY RUN] Would run ${agentName}`);
+    if (options.verbose) {
+      writeLine(`  ${colors.dim}Agent definition:${RESET}`);
+      writeLine(`  ${colors.dim}${definition.slice(0, 500)}...${RESET}`);
+    }
+    return;
+  }
+  logExecution({
+    squadName,
+    agentName,
+    startTime,
+    status: "running"
+  });
+  const prompt = `Execute the ${agentName} agent from squad ${squadName}.
+
+Read the agent definition at ${agentPath} and follow its instructions exactly.
+
+The agent definition contains:
+- Purpose/role
+- Tools it can use (MCP servers, skills)
+- Step-by-step instructions
+- Expected output format
+
+After completion:
+1. Update the agent's memory in .agents/memory/${squadName}/${agentName}/state.md
+2. Log any learnings to learnings.md
+3. Report what was accomplished`;
+  const claudeAvailable = await checkClaudeCliAvailable();
+  if (options.execute && claudeAvailable) {
+    spinner.text = `Executing ${agentName} with Claude Code...`;
+    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}`);
+      }
+    } catch (error) {
+      spinner.fail(`Agent ${agentName} failed`);
+      updateExecutionStatus(squadName, agentName, "failed", String(error));
+      writeLine(`  ${colors.red}${String(error)}${RESET}`);
+    }
+  } else {
+    spinner.succeed(`Agent ${agentName} ready`);
+    writeLine(`  ${colors.dim}Execution logged: ${startTime}${RESET}`);
+    if (!claudeAvailable) {
+      writeLine();
+      writeLine(`  ${colors.yellow}Claude CLI not found${RESET}`);
+      writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}To execute with Claude Code:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} claude --print "${prompt.replace(/"/g, '\\"').replace(/\n/g, " ").slice(0, 80)}..."`);
+    writeLine();
+    writeLine(`  ${colors.dim}Or run with --execute flag:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squadName}${RESET} --execute`);
+    writeLine();
+    writeLine(`  ${colors.dim}Or in Claude Code session:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} Run the ${colors.cyan}${agentName}${RESET} agent from ${agentPath}`);
+  }
+}
+async function checkClaudeCliAvailable() {
+  return new Promise((resolve) => {
+    const check = spawn("which", ["claude"], { stdio: "pipe" });
+    check.on("close", (code) => resolve(code === 0));
+    check.on("error", () => resolve(false));
+  });
+}
+async function 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);
+  });
+}
+
+// src/commands/list.ts
+async function listCommand(options) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  const squads = listSquads(squadsDir);
+  const allAgents = listAgents(squadsDir);
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}list${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.cyan}${squads.length}${RESET} squads  ${colors.dim}\u2502${RESET}  ${colors.cyan}${allAgents.length}${RESET} agents`);
+  writeLine();
+  if (!options.agents) {
+    const w = { name: 16, agents: 8, lead: 24 };
+    const tableWidth = w.name + w.agents + w.lead + 4;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("AGENTS", w.agents)}${RESET}${bold}LEAD${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(header);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const squadName of squads) {
+      const agents = listAgents(squadsDir, squadName);
+      const lead = agents.find((a) => a.name.includes("lead"))?.name || agents[0]?.name || "-";
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squadName, w.name)}${RESET}${padEnd(String(agents.length), w.agents)}${colors.dim}${padEnd(lead, w.lead)}${RESET}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+    writeLine();
+  }
+  if (!options.squads && options.agents) {
+    writeLine(`  ${bold}Agents${RESET}`);
+    writeLine();
+    for (const agent of allAgents) {
+      const squadPart = agent.squad ? `${colors.dim}${agent.squad}/${RESET}` : "";
+      const statusIcon = agent.status?.toLowerCase() === "active" ? icons.active : icons.pending;
+      writeLine(`  ${statusIcon} ${squadPart}${colors.white}${agent.name}${RESET}`);
+      if (agent.role) {
+        writeLine(`    ${colors.dim}\u2514 ${agent.role}${RESET}`);
+      }
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads status ${colors.cyan}<squad>${RESET}   ${colors.dim}Squad details${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}<squad>${RESET}      ${colors.dim}Execute a squad${RESET}`);
+  writeLine();
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync6, statSync } from "fs";
+import { join as join6 } from "path";
+async function statusCommand(squadName, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  if (squadName) {
+    await showSquadStatus(squadName, squadsDir, options);
+  } else {
+    await showOverallStatus(squadsDir, options);
+  }
+}
+async function showOverallStatus(squadsDir, _options) {
+  const squads = listSquads(squadsDir);
+  const memoryDir = findMemoryDir();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}status${RESET}`);
+  writeLine();
+  const totalSquads = squads.length;
+  const activeCount = squads.length;
+  writeLine(`  ${colors.cyan}${activeCount}${RESET}/${totalSquads} squads  ${colors.dim}\u2502${RESET}  ${colors.dim}memory: ${memoryDir ? "enabled" : "none"}${RESET}`);
+  writeLine();
+  const w = { name: 16, agents: 8, memory: 14, activity: 12 };
+  const tableWidth = w.name + w.agents + w.memory + w.activity + 6;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("AGENTS", w.agents)}${RESET}${bold}${padEnd("MEMORY", w.memory)}${RESET}${bold}ACTIVITY${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const squadName of squads) {
+    const agents = listAgents(squadsDir, squadName);
+    let memoryStatus = `${colors.dim}none${RESET}`;
+    let lastActivity = `${colors.dim}\u2014${RESET}`;
+    let activityColor = colors.dim;
+    if (memoryDir) {
+      const squadMemoryPath = join6(memoryDir, squadName);
+      if (existsSync6(squadMemoryPath)) {
+        const states = getSquadState(squadName);
+        memoryStatus = `${colors.green}${states.length} entries${RESET}`;
+        let mostRecent = 0;
+        for (const state of states) {
+          const stat = statSync(state.path);
+          if (stat.mtimeMs > mostRecent) {
+            mostRecent = stat.mtimeMs;
+          }
+        }
+        if (mostRecent > 0) {
+          const daysAgo = Math.floor((Date.now() - mostRecent) / (1e3 * 60 * 60 * 24));
+          if (daysAgo === 0) {
+            lastActivity = "today";
+            activityColor = colors.green;
+          } else if (daysAgo === 1) {
+            lastActivity = "yesterday";
+            activityColor = colors.green;
+          } else if (daysAgo < 7) {
+            lastActivity = `${daysAgo}d ago`;
+            activityColor = colors.yellow;
+          } else {
+            lastActivity = `${daysAgo}d ago`;
+            activityColor = colors.dim;
+          }
+        }
+      }
+    }
+    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} 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";
+async function memoryQueryCommand(query, options) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory query${RESET} "${colors.cyan}${query}${RESET}"`);
+  writeLine();
+  const results = searchMemory(query, memoryDir);
+  if (results.length === 0) {
+    writeLine(`  ${colors.yellow}No results found.${RESET}`);
+    writeLine();
+    return;
+  }
+  let filtered = results;
+  if (options.squad) {
+    filtered = filtered.filter((r) => r.entry.squad === options.squad);
+  }
+  if (options.agent) {
+    filtered = filtered.filter((r) => r.entry.agent === options.agent);
+  }
+  writeLine(`  ${colors.green}${filtered.length}${RESET} results found`);
+  writeLine();
+  const w = { location: 28, type: 10, score: 8 };
+  const tableWidth = w.location + w.type + w.score + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("LOCATION", w.location)}${RESET}${bold}${padEnd("TYPE", w.type)}${RESET}${bold}SCORE${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const result of filtered.slice(0, 8)) {
+    const { entry, score } = result;
+    const location = `${entry.squad}/${entry.agent}`;
+    const scoreColor = score > 5 ? colors.green : score > 2 ? colors.yellow : colors.dim;
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(location, w.location)}${RESET}${colors.dim}${padEnd(entry.type, w.type)}${RESET}${scoreColor}${padEnd(score.toFixed(1), w.score)}${RESET}${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(`  ${bold}Matches${RESET}`);
+  writeLine();
+  for (const result of filtered.slice(0, 5)) {
+    const { entry, matches } = result;
+    for (const match of matches.slice(0, 2)) {
+      const highlighted = match.replace(
+        new RegExp(query, "gi"),
+        (m) => `${colors.yellow}${m}${RESET}`
+      );
+      writeLine(`  ${icons.empty} ${truncate(highlighted, 60)}`);
+      writeLine(`    ${colors.dim}\u2514 ${entry.squad}/${entry.agent}${RESET}`);
+    }
+  }
+  if (filtered.length > 5) {
+    writeLine(`  ${colors.dim}  +${filtered.length - 5} more results${RESET}`);
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads memory show ${colors.cyan}<squad>${RESET}   ${colors.dim}View full memory${RESET}`);
+  writeLine();
+}
+async function memoryShowCommand(squadName, _options) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
+    process.exit(1);
+  }
+  const states = getSquadState(squadName);
+  if (states.length === 0) {
+    writeLine(`  ${colors.yellow}No memory found for squad: ${squadName}${RESET}`);
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory${RESET} ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}${states.length} entries${RESET}`);
+  writeLine();
+  for (const state of states) {
+    writeLine(`  ${icons.progress} ${colors.white}${state.agent}${RESET} ${colors.dim}(${state.type || "state"})${RESET}`);
+    writeLine(`  ${colors.dim}${box.horizontal.repeat(40)}${RESET}`);
+    const lines = state.content.split("\n").slice(0, 12);
+    for (const line of lines) {
+      writeLine(`  ${colors.dim}${truncate(line, 70)}${RESET}`);
+    }
+    if (state.content.split("\n").length > 12) {
+      writeLine(`  ${colors.dim}... (more content)${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads memory query ${colors.cyan}"<term>"${RESET}   ${colors.dim}Search memory${RESET}`);
+  writeLine();
+}
+async function memoryUpdateCommand(squadName, content, options) {
+  const agentName = options.agent || `${squadName}-lead`;
+  const type = options.type || "learnings";
+  writeLine();
+  try {
+    appendToMemory(squadName, agentName, type, content);
+    writeLine(`  ${icons.success} Updated ${colors.cyan}${type}${RESET} for ${colors.white}${squadName}/${agentName}${RESET}`);
+  } catch (error) {
+    writeLine(`  ${icons.error} ${colors.red}Failed to update memory: ${error}${RESET}`);
+    process.exit(1);
+  }
+  writeLine();
+}
+async function memoryListCommand() {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}No .agents/memory directory found${RESET}`);
+    process.exit(1);
+  }
+  const entries = listMemoryEntries(memoryDir);
+  const bySquad = {};
+  for (const entry of entries) {
+    if (!bySquad[entry.squad]) {
+      bySquad[entry.squad] = [];
+    }
+    bySquad[entry.squad].push(entry);
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory list${RESET}`);
+  writeLine();
+  const squadNames = Object.keys(bySquad);
+  writeLine(`  ${colors.cyan}${entries.length}${RESET} entries across ${squadNames.length} squads`);
+  writeLine();
+  const w = { squad: 16, agents: 8, types: 28 };
+  const tableWidth = w.squad + w.agents + w.types + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("AGENTS", w.agents)}${RESET}${bold}TYPES${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const [squad, squadEntries] of Object.entries(bySquad)) {
+    const agents = new Set(squadEntries.map((e) => e.agent));
+    const types = [...new Set(squadEntries.map((e) => e.type))].join(", ");
+    const typesDisplay = truncate(types, w.types - 2);
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(String(agents.size), w.agents)}${colors.dim}${padEnd(typesDisplay, w.types)}${RESET}${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 memory show ${colors.cyan}<squad>${RESET}     ${colors.dim}View squad memory${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads memory query ${colors.cyan}"<term>"${RESET}   ${colors.dim}Search all memory${RESET}`);
+  writeLine();
+}
+async function memorySearchCommand(query, options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory search${RESET} "${colors.cyan}${query}${RESET}"`);
+  writeLine();
+  const limit = options.limit || 10;
+  const params = new URLSearchParams({ q: query, limit: String(limit) });
+  if (options.role) {
+    params.append("role", options.role);
+  }
+  if (options.importance) {
+    params.append("importance", options.importance);
+  }
+  try {
+    const response = await fetch(`${SQUADS_BRIDGE_URL}/api/conversations/search?${params}`);
+    if (!response.ok) {
+      if (response.status === 503) {
+        writeLine(`  ${colors.yellow}Database not available${RESET}`);
+        writeLine(`  ${colors.dim}Run: docker compose up -d${RESET}`);
+        writeLine();
+        return;
+      }
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const conversations = data.results;
+    const total = data.count;
+    if (conversations.length === 0) {
+      writeLine(`  ${colors.yellow}No conversations found for "${query}"${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}Conversations are captured via hooks. Make sure:${RESET}`);
+      writeLine(`  ${colors.dim}  1. squads-bridge is running (docker compose up)${RESET}`);
+      writeLine(`  ${colors.dim}  2. engram hook is configured in Claude settings${RESET}`);
+      writeLine();
+      return;
+    }
+    writeLine(`  ${colors.green}${conversations.length}${RESET} of ${total} results`);
+    writeLine();
+    const w = { time: 12, role: 10, type: 10, content: 50 };
+    const tableWidth = w.time + w.role + w.type + w.content + 6;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("TIME", w.time)}${RESET}${bold}${padEnd("ROLE", w.role)}${RESET}${bold}${padEnd("TYPE", w.type)}${RESET}${bold}${padEnd("CONTENT", w.content)}${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(header);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const conv of conversations) {
+      const time = new Date(conv.created_at).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+      const roleColor = conv.role === "user" ? colors.cyan : conv.role === "thinking" ? colors.yellow : colors.green;
+      const importanceIcon = conv.importance === "high" ? icons.success : "";
+      const contentPreview = truncate((conv.content || "").replace(/\n/g, " "), w.content - 2);
+      const highlighted = contentPreview.replace(
+        new RegExp(query, "gi"),
+        (m) => `${colors.yellow}${m}${RESET}${colors.dim}`
+      );
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.dim}${padEnd(time, w.time)}${RESET}${roleColor}${padEnd(conv.role || "", w.role)}${RESET}${colors.dim}${padEnd(conv.type || "message", w.type)}${RESET}${colors.dim}${padEnd(highlighted + importanceIcon, w.content)}${RESET} ${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(`  ${bold}Top Matches${RESET}`);
+    writeLine();
+    for (const conv of conversations.slice(0, 3)) {
+      const time = new Date(conv.created_at).toLocaleString("en-US", {
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      const roleIcon = conv.role === "user" ? "\u{1F464}" : conv.role === "thinking" ? "\u{1F4AD}" : "\u{1F916}";
+      writeLine(`  ${roleIcon} ${colors.dim}${time}${RESET} ${conv.importance === "high" ? colors.yellow + "[high]" + RESET : ""}`);
+      const content = conv.content || "";
+      const preview = content.substring(0, 200).replace(/\n/g, " ");
+      const highlighted = preview.replace(
+        new RegExp(query, "gi"),
+        (m) => `${colors.yellow}${m}${RESET}`
+      );
+      writeLine(`    ${highlighted}${content.length > 200 ? "..." : ""}`);
+      writeLine();
+    }
+    writeLine(`  ${colors.dim}$${RESET} squads memory search ${colors.cyan}"<term>"${RESET} --role user     ${colors.dim}Filter by role${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads memory search ${colors.cyan}"<term>"${RESET} --importance high   ${colors.dim}Filter by importance${RESET}`);
+    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}`);
+    } else {
+      writeLine(`  ${colors.red}Error searching conversations: ${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";
+var PATH_TO_SQUAD = {
+  "squads-cli": "product",
+  "agents-squads-web": "website",
+  "research": "research",
+  "intelligence": "intelligence",
+  "customer": "customer",
+  "finance": "finance",
+  "engineering": "engineering",
+  "product": "product",
+  "company": "company",
+  ".agents/squads": "engineering",
+  ".agents/memory": "engineering"
+};
+var MESSAGE_TO_SQUAD = {
+  "cli": "product",
+  "website": "website",
+  "web": "website",
+  "homepage": "website",
+  "research": "research",
+  "intel": "intelligence",
+  "lead": "customer",
+  "finance": "finance",
+  "cost": "finance",
+  "engineering": "engineering",
+  "infra": "engineering"
+};
+function getLastSyncTime(memoryDir) {
+  const syncFile = join7(memoryDir, ".last-sync");
+  if (existsSync7(syncFile)) {
+    return readFileSync5(syncFile, "utf-8").trim();
+  }
+  return null;
+}
+function updateLastSyncTime(memoryDir) {
+  const syncFile = join7(memoryDir, ".last-sync");
+  writeFileSync5(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+}
+function getRecentCommits(since) {
+  const commits = [];
+  try {
+    const sinceArg = since ? `--since="${since}"` : "-n 20";
+    const logOutput = execSync2(
+      `git log ${sinceArg} --format="%H|%aI|%s" --name-only`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!logOutput) return commits;
+    const entries = logOutput.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) continue;
+      const [header, ...fileLines] = lines;
+      const [hash, date, ...messageParts] = header.split("|");
+      const message = messageParts.join("|");
+      if (hash && date && message) {
+        commits.push({
+          hash: hash.substring(0, 7),
+          date: date.split("T")[0],
+          message,
+          files: fileLines.filter((f) => f && !f.includes("|"))
+        });
+      }
+    }
+  } catch (error) {
+  }
+  return commits;
+}
+function detectSquadsFromCommit(commit) {
+  const squads = /* @__PURE__ */ new Set();
+  for (const file of commit.files) {
+    for (const [pathPattern, squad] of Object.entries(PATH_TO_SQUAD)) {
+      if (file.includes(pathPattern)) {
+        squads.add(squad);
+      }
+    }
+  }
+  const msgLower = commit.message.toLowerCase();
+  for (const [keyword, squad] of Object.entries(MESSAGE_TO_SQUAD)) {
+    if (msgLower.includes(keyword)) {
+      squads.add(squad);
+    }
+  }
+  return Array.from(squads);
+}
+function groupCommitsBySquad(commits) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const squads = detectSquadsFromCommit(commit);
+    for (const squad of squads) {
+      if (!grouped.has(squad)) {
+        grouped.set(squad, []);
+      }
+      grouped.get(squad).push(commit);
+    }
+  }
+  return grouped;
+}
+function generateSummary(commits) {
+  if (commits.length === 0) return "";
+  const messages = commits.map((c) => `- ${c.message}`).join("\n");
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `
+## Session Update (${date})
+
+${messages}
+`;
+}
+function appendToSquadMemory(memoryDir, squad, summary) {
+  const squadMemoryDir = join7(memoryDir, squad);
+  if (!existsSync7(squadMemoryDir)) {
+    mkdirSync4(squadMemoryDir, { recursive: true });
+  }
+  let agentDir;
+  const existingDirs = existsSync7(squadMemoryDir) ? readdirSync3(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  if (existingDirs.length > 0) {
+    agentDir = join7(squadMemoryDir, existingDirs[0]);
+  } else {
+    agentDir = join7(squadMemoryDir, `${squad}-lead`);
+    mkdirSync4(agentDir, { recursive: true });
+  }
+  const statePath = join7(agentDir, "state.md");
+  let content = "";
+  if (existsSync7(statePath)) {
+    content = readFileSync5(statePath, "utf-8");
+  } else {
+    content = `# ${squad} Squad - State
+
+Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+`;
+  }
+  content = content.replace(
+    /Updated:\s*\d{4}-\d{2}-\d{2}/,
+    `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
+  );
+  content += summary;
+  writeFileSync5(statePath, content);
+  return true;
+}
+async function syncCommand(options = {}) {
+  const memoryDir = findMemoryDir();
+  const squadsDir = findSquadsDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.yellow}No .agents/memory directory found${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}memory sync${RESET}`);
+  writeLine();
+  const lastSync = getLastSyncTime(memoryDir);
+  if (lastSync) {
+    writeLine(`  ${colors.dim}Last sync: ${lastSync.split("T")[0]}${RESET}`);
+  } else {
+    writeLine(`  ${colors.dim}First sync${RESET}`);
+  }
+  writeLine();
+  const commits = getRecentCommits(lastSync || void 0);
+  if (commits.length === 0) {
+    writeLine(`  ${colors.yellow}No new commits since last sync${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${commits.length}${RESET} commits to process`);
+  writeLine();
+  const bySquad = groupCommitsBySquad(commits);
+  if (bySquad.size === 0) {
+    writeLine(`  ${colors.yellow}No squad-related commits found${RESET}`);
+    writeLine();
+    updateLastSyncTime(memoryDir);
+    return;
+  }
+  let updated = 0;
+  for (const [squad, squadCommits] of bySquad) {
+    const summary = generateSummary(squadCommits);
+    if (options.verbose) {
+      writeLine(`  ${icons.progress} ${colors.cyan}${squad}${RESET}`);
+      for (const commit of squadCommits) {
+        writeLine(`    ${colors.dim}${commit.hash} ${commit.message}${RESET}`);
+      }
+    }
+    const success = appendToSquadMemory(memoryDir, squad, summary);
+    if (success) {
+      writeLine(`  ${icons.success} ${colors.cyan}${squad}${RESET} ${colors.dim}(${squadCommits.length} commits)${RESET}`);
+      updated++;
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.green}${updated}${RESET} squad memories updated`);
+  writeLine();
+  updateLastSyncTime(memoryDir);
+  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}`);
+  writeLine();
+}
+
+// src/commands/goal.ts
+async function goalSetCommand(squadName, description, options) {
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
+    return;
+  }
+  let goalText = description;
+  if (options.metric && options.metric.length > 0) {
+    goalText += ` [metrics: ${options.metric.join(", ")}]`;
+  }
+  const success = addGoalToSquad(squadName, goalText);
+  writeLine();
+  if (success) {
+    writeLine(`  ${icons.success} Goal added to ${colors.cyan}${squadName}${RESET}`);
+    writeLine(`  ${bold}${description}${RESET}`);
+    if (options.metric && options.metric.length > 0) {
+      writeLine(`  ${colors.dim}Metrics: ${options.metric.join(", ")}${RESET}`);
+    }
+  } else {
+    writeLine(`  ${colors.red}Failed to add goal${RESET}`);
+  }
+  writeLine();
+}
+async function goalListCommand(squadName, options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    return;
+  }
+  const squadsToCheck = squadName ? [squadName] : listSquads(squadsDir);
+  let totalActive = 0;
+  let totalCompleted = 0;
+  let hasGoals = false;
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}goal list${RESET}`);
+  writeLine();
+  for (const name of squadsToCheck) {
+    const squad = loadSquad(name);
+    if (!squad || squad.goals.length === 0) {
+      if (squadName) {
+        writeLine(`  ${colors.yellow}No goals set for ${name}${RESET}`);
+      }
+      continue;
+    }
+    hasGoals = true;
+    const activeGoals = squad.goals.filter((g) => !g.completed);
+    const completedGoals = squad.goals.filter((g) => g.completed);
+    totalActive += activeGoals.length;
+    totalCompleted += completedGoals.length;
+    if (activeGoals.length === 0 && !options.all) continue;
+    writeLine(`  ${colors.cyan}${name}${RESET}`);
+    if (squad.mission) {
+      writeLine(`  ${colors.dim}${truncate(squad.mission, 60)}${RESET}`);
+    }
+    writeLine();
+    for (const goal2 of activeGoals) {
+      const globalIdx = squad.goals.indexOf(goal2) + 1;
+      writeLine(`  ${icons.active} ${colors.dim}[${globalIdx}]${RESET} ${goal2.description}`);
+      if (goal2.progress) {
+        writeLine(`    ${colors.dim}\u2514 ${goal2.progress}${RESET}`);
+      }
+    }
+    if (options.all && completedGoals.length > 0) {
+      for (const goal2 of completedGoals) {
+        const globalIdx = squad.goals.indexOf(goal2) + 1;
+        writeLine(`  ${icons.success} ${colors.dim}[${globalIdx}] ${goal2.description}${RESET}`);
+      }
+    }
+    writeLine();
+  }
+  if (hasGoals) {
+    writeLine(`  ${colors.green}${totalActive}${RESET} active  ${colors.dim}\u2502${RESET}  ${colors.dim}${totalCompleted} completed${RESET}`);
+  } else if (!squadName) {
+    writeLine(`  ${colors.yellow}No goals defined yet${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}$${RESET} squads goal set ${colors.cyan}<squad>${RESET} ${colors.cyan}"<goal>"${RESET}`);
+  }
+  writeLine();
+}
+async function goalCompleteCommand(squadName, goalIndex) {
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
+    return;
+  }
+  const idx = parseInt(goalIndex) - 1;
+  if (idx < 0 || idx >= squad.goals.length) {
+    writeLine(`  ${colors.red}Invalid goal index: ${goalIndex}${RESET}`);
+    writeLine(`  ${colors.dim}Squad has ${squad.goals.length} goal(s)${RESET}`);
+    return;
+  }
+  const success = updateGoalInSquad(squadName, idx, { completed: true });
+  writeLine();
+  if (success) {
+    writeLine(`  ${icons.success} Goal completed: ${colors.cyan}${squad.goals[idx].description}${RESET}`);
+  } else {
+    writeLine(`  ${colors.red}Failed to update goal${RESET}`);
+  }
+  writeLine();
+}
+async function goalProgressCommand(squadName, goalIndex, progress2) {
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`  ${colors.red}Squad "${squadName}" not found${RESET}`);
+    return;
+  }
+  const idx = parseInt(goalIndex) - 1;
+  if (idx < 0 || idx >= squad.goals.length) {
+    writeLine(`  ${colors.red}Invalid goal index: ${goalIndex}${RESET}`);
+    return;
+  }
+  const success = updateGoalInSquad(squadName, idx, { progress: progress2 });
+  writeLine();
+  if (success) {
+    writeLine(`  ${icons.success} Progress updated: ${colors.cyan}${squad.goals[idx].description}${RESET}`);
+    writeLine(`  ${colors.dim}${progress2}${RESET}`);
+  } else {
+    writeLine(`  ${colors.red}Failed to update progress${RESET}`);
+  }
+  writeLine();
+}
+
+// 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";
+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");
+}
+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");
+}
+function getLastExecution(squadName) {
+  const outputPath = getOutputPath(squadName);
+  if (!outputPath || !existsSync8(outputPath)) {
+    return null;
+  }
+  const content = readFileSync6(outputPath, "utf-8");
+  const lines = content.split("\n");
+  let date = "unknown";
+  let summary = lines.slice(0, 5).join("\n");
+  const dateMatch = content.match(/(\d{4}-\d{2}-\d{2})/);
+  if (dateMatch) {
+    date = dateMatch[1];
+  }
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (titleMatch) {
+    summary = titleMatch[1];
+  }
+  return { date, summary };
+}
+function parseFeedbackHistory(content) {
+  const entries = [];
+  const sections = content.split(/---\n/).filter((s) => s.trim());
+  for (const section of sections) {
+    const dateMatch = section.match(/_Date:\s*(.+)_/);
+    const ratingMatch = section.match(/\*\*Rating\*\*:\s*(\d)\/5/);
+    const feedbackMatch = section.match(/\*\*Feedback\*\*:\s*(.+)/);
+    const executionMatch = section.match(/\*\*Execution\*\*:\s*(.+)/);
+    if (dateMatch && ratingMatch) {
+      const entry = {
+        date: dateMatch[1],
+        execution: executionMatch?.[1] || "unknown",
+        rating: parseInt(ratingMatch[1]),
+        feedback: feedbackMatch?.[1] || "",
+        learnings: []
+      };
+      const learningsMatch = section.match(/\*\*Learnings\*\*:\n((?:- .+\n?)+)/);
+      if (learningsMatch) {
+        entry.learnings = learningsMatch[1].split("\n").filter((l) => l.startsWith("- ")).map((l) => l.replace(/^- /, ""));
+      }
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+async function feedbackAddCommand(squadName, rating, feedback2, options) {
+  const feedbackPath = getFeedbackPath(squadName);
+  if (!feedbackPath) {
+    writeLine(`  ${colors.red}Could not find memory directory${RESET}`);
+    return;
+  }
+  const ratingNum = parseInt(rating);
+  if (isNaN(ratingNum) || ratingNum < 1 || ratingNum > 5) {
+    writeLine(`  ${colors.red}Rating must be 1-5${RESET}`);
+    return;
+  }
+  const lastExec = getLastExecution(squadName);
+  const dir = dirname4(feedbackPath);
+  if (!existsSync8(dir)) {
+    mkdirSync5(dir, { recursive: true });
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  let entry = `
+---
+_Date: ${date}_
+
+`;
+  entry += `**Execution**: ${lastExec?.summary || "Manual feedback"}
+`;
+  entry += `**Rating**: ${ratingNum}/5 ${"\u2605".repeat(ratingNum)}${"\u2606".repeat(5 - ratingNum)}
+`;
+  entry += `**Feedback**: ${feedback2}
+`;
+  if (options.learning && options.learning.length > 0) {
+    entry += `**Learnings**:
+`;
+    for (const learning of options.learning) {
+      entry += `- ${learning}
+`;
+    }
+    const squad = loadSquad(squadName);
+    const agentName = squad?.agents[0]?.name || `${squadName}-lead`;
+    for (const learning of options.learning) {
+      appendToMemory(squadName, agentName, "learnings", `From feedback (${date}): ${learning}`);
+    }
+  }
+  let existing = "";
+  if (existsSync8(feedbackPath)) {
+    existing = readFileSync6(feedbackPath, "utf-8");
+  } else {
+    existing = `# ${squadName} - Feedback Log
+
+> Execution feedback and learnings
+`;
+  }
+  writeFileSync6(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}`);
+  writeLine(`  Rating: ${stars}`);
+  writeLine(`  ${feedback2}`);
+  if (options.learning && options.learning.length > 0) {
+    writeLine(`  ${colors.dim}+ ${options.learning.length} learning(s) added${RESET}`);
+  }
+  writeLine();
+}
+async function feedbackShowCommand(squadName, options) {
+  const feedbackPath = getFeedbackPath(squadName);
+  if (!feedbackPath || !existsSync8(feedbackPath)) {
+    writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
+    return;
+  }
+  const content = readFileSync6(feedbackPath, "utf-8");
+  const entries = parseFeedbackHistory(content);
+  const limit = options.limit ? parseInt(options.limit) : 5;
+  const recent = entries.slice(-limit).reverse();
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}feedback${RESET} ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  if (recent.length === 0) {
+    writeLine(`  ${colors.dim}No feedback entries yet${RESET}`);
+    return;
+  }
+  const avgRating = entries.reduce((sum, e) => sum + e.rating, 0) / entries.length;
+  writeLine(`  ${colors.dim}Average: ${avgRating.toFixed(1)}/5 (${entries.length} entries)${RESET}`);
+  writeLine();
+  for (const entry of recent) {
+    const stars = `${colors.yellow}${"\u2605".repeat(entry.rating)}${"\u2606".repeat(5 - entry.rating)}${RESET}`;
+    writeLine(`  ${colors.dim}${entry.date}${RESET} ${stars}`);
+    writeLine(`  ${entry.feedback}`);
+    if (entry.learnings && entry.learnings.length > 0) {
+      for (const learning of entry.learnings) {
+        writeLine(`  ${colors.green}\u2192 ${learning}${RESET}`);
+      }
+    }
+    writeLine();
+  }
+}
+async function feedbackStatsCommand() {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    writeLine(`  ${colors.red}Could not find memory directory${RESET}`);
+    return;
+  }
+  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 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}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("AVG", w.avg)}${RESET}${bold}${padEnd("COUNT", w.count)}${RESET}${bold}TREND${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const squad of squads) {
+    const feedbackPath = getFeedbackPath(squad);
+    if (!feedbackPath || !existsSync8(feedbackPath)) {
+      continue;
+    }
+    const content = readFileSync6(feedbackPath, "utf-8");
+    const entries = parseFeedbackHistory(content);
+    if (entries.length === 0) continue;
+    const avgRating = entries.reduce((sum, e) => sum + e.rating, 0) / entries.length;
+    let trend = `${colors.dim}\u2192${RESET}`;
+    if (entries.length >= 4) {
+      const recent = entries.slice(-3).reduce((s, e) => s + e.rating, 0) / 3;
+      const older = entries.slice(-6, -3).reduce((s, e) => s + e.rating, 0) / Math.min(3, entries.slice(-6, -3).length);
+      if (recent > older + 0.3) trend = `${colors.green}\u2191${RESET}`;
+      else if (recent < older - 0.3) trend = `${colors.red}\u2193${RESET}`;
+    }
+    const stars = `${colors.yellow}${"\u2605".repeat(Math.round(avgRating))}${"\u2606".repeat(5 - Math.round(avgRating))}${RESET}`;
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(stars, w.avg + 20)}${padEnd(String(entries.length), w.count)}${trend} ${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 feedback show ${colors.cyan}<squad>${RESET}   ${colors.dim}View squad feedback${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads feedback add ${colors.cyan}<squad>${RESET}    ${colors.dim}Add new feedback${RESET}`);
+  writeLine();
+}
+
+// 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";
+
+// src/lib/costs.ts
+var MODEL_PRICING = {
+  "claude-opus-4-5-20251101": { input: 15, output: 75 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  default: { input: 3, output: 15 }
+};
+var DEFAULT_DAILY_BUDGET = 50;
+var DEFAULT_DAILY_CALL_LIMIT = 1e3;
+var BRIDGE_URL = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+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}`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const dailyBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+    const totalCost = data.totals?.cost_usd || 0;
+    const bySquad = (data.by_squad || []).map((s) => ({
+      squad: s.squad,
+      calls: s.generations || 0,
+      inputTokens: s.input_tokens || 0,
+      outputTokens: s.output_tokens || 0,
+      cachedTokens: s.cached_tokens || 0,
+      cost: s.cost_usd || 0,
+      models: {}
+    }));
+    const totalCalls = bySquad.reduce((sum, s) => sum + s.calls, 0);
+    const dailyCallLimit = parseFloat(process.env.SQUADS_DAILY_CALL_LIMIT || "") || DEFAULT_DAILY_CALL_LIMIT;
+    const totalCachedTokens = bySquad.reduce((sum, s) => sum + s.cachedTokens, 0);
+    const totalInputTokens = bySquad.reduce((sum, s) => sum + s.inputTokens, 0);
+    const totalAllInput = totalInputTokens + totalCachedTokens;
+    const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    return {
+      totalCost,
+      dailyBudget,
+      usedPercent: totalCost / dailyBudget * 100,
+      idleBudget: dailyBudget - totalCost,
+      totalCalls,
+      dailyCallLimit,
+      callsPercent: totalCalls / dailyCallLimit * 100,
+      totalCachedTokens,
+      totalInputTokens,
+      cacheHitRate,
+      bySquad,
+      source: "postgres"
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchFromLangfuse(limit = 100) {
+  const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+  const secretKey = process.env.LANGFUSE_SECRET_KEY;
+  const host = process.env.LANGFUSE_HOST || process.env.LANGFUSE_BASE_URL || "https://us.cloud.langfuse.com";
+  if (!publicKey || !secretKey) {
+    return null;
+  }
+  try {
+    const auth = Buffer.from(`${publicKey}:${secretKey}`).toString("base64");
+    const url = `${host}/api/public/observations?limit=${limit}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Basic ${auth}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const observations = data.data || [];
+    const bySquad = {};
+    for (const obs of observations) {
+      if (obs.type !== "GENERATION") continue;
+      const metadata = obs.metadata || {};
+      const squad = metadata.squad || "unknown";
+      const model = obs.model || "unknown";
+      const usage = obs.usage || {};
+      const inputTokens = usage.input || 0;
+      const outputTokens = usage.output || 0;
+      const cost = calcCost(model, inputTokens, outputTokens);
+      if (!bySquad[squad]) {
+        bySquad[squad] = {
+          squad,
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedTokens: 0,
+          cost: 0,
+          models: {}
+        };
+      }
+      bySquad[squad].calls += 1;
+      bySquad[squad].inputTokens += inputTokens;
+      bySquad[squad].outputTokens += outputTokens;
+      bySquad[squad].cost += cost;
+      bySquad[squad].models[model] = (bySquad[squad].models[model] || 0) + 1;
+    }
+    const squadList = Object.values(bySquad).sort((a, b) => b.cost - a.cost);
+    const totalCost = squadList.reduce((sum, s) => sum + s.cost, 0);
+    const dailyBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+    const totalCalls = squadList.reduce((sum, s) => sum + s.calls, 0);
+    const dailyCallLimit = parseFloat(process.env.SQUADS_DAILY_CALL_LIMIT || "") || DEFAULT_DAILY_CALL_LIMIT;
+    const totalCachedTokens = squadList.reduce((sum, s) => sum + s.cachedTokens, 0);
+    const totalInputTokens = squadList.reduce((sum, s) => sum + s.inputTokens, 0);
+    const totalAllInput = totalInputTokens + totalCachedTokens;
+    const cacheHitRate = totalAllInput > 0 ? totalCachedTokens / totalAllInput * 100 : 0;
+    return {
+      totalCost,
+      dailyBudget,
+      usedPercent: totalCost / dailyBudget * 100,
+      idleBudget: dailyBudget - totalCost,
+      totalCalls,
+      dailyCallLimit,
+      callsPercent: totalCalls / dailyCallLimit * 100,
+      totalCachedTokens,
+      totalInputTokens,
+      cacheHitRate,
+      bySquad: squadList,
+      source: "langfuse"
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchCostSummary(limit = 100, period = "day") {
+  const bridgeResult = await fetchFromBridge(period);
+  if (bridgeResult) {
+    return bridgeResult;
+  }
+  const langfuseResult = await fetchFromLangfuse(limit);
+  if (langfuseResult) {
+    return langfuseResult;
+  }
+  const defaultBudget = parseFloat(process.env.SQUADS_DAILY_BUDGET || "") || DEFAULT_DAILY_BUDGET;
+  return {
+    totalCost: 0,
+    dailyBudget: defaultBudget,
+    usedPercent: 0,
+    idleBudget: defaultBudget,
+    totalCalls: 0,
+    dailyCallLimit: DEFAULT_DAILY_CALL_LIMIT,
+    callsPercent: 0,
+    totalCachedTokens: 0,
+    totalInputTokens: 0,
+    cacheHitRate: 0,
+    bySquad: [],
+    source: "none"
+  };
+}
+function formatCostBar(usedPercent, width = 20) {
+  const filled = Math.min(Math.round(usedPercent / 100 * width), width);
+  const empty = width - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+async function fetchRateLimits() {
+  try {
+    const response = await fetch(`${BRIDGE_URL}/api/rate-limits`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return { limits: {}, source: "none" };
+    }
+    const data = await response.json();
+    const rateLimits = data.rate_limits || {};
+    const limits = {};
+    for (const [key, value] of Object.entries(rateLimits)) {
+      limits[key] = {
+        model: value.model || key,
+        requestsLimit: value.requests_limit || 0,
+        requestsRemaining: value.requests_remaining || 0,
+        requestsReset: value.requests_reset,
+        tokensLimit: value.tokens_limit || 0,
+        tokensRemaining: value.tokens_remaining || 0,
+        tokensReset: value.tokens_reset,
+        inputTokensLimit: value.input_tokens_limit,
+        inputTokensRemaining: value.input_tokens_remaining,
+        outputTokensLimit: value.output_tokens_limit,
+        outputTokensRemaining: value.output_tokens_remaining,
+        capturedAt: value.captured_at || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return { limits, source: "proxy" };
+  } catch {
+    return { limits: {}, source: "none" };
+  }
+}
+async function fetchInsights(period = "week") {
+  try {
+    const response = await fetch(`${BRIDGE_URL}/api/insights?period=${period}`, {
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      return {
+        period,
+        days: period === "day" ? 1 : period === "week" ? 7 : 30,
+        taskMetrics: [],
+        qualityMetrics: [],
+        topTools: [],
+        toolFailureRate: 0,
+        source: "none"
+      };
+    }
+    const data = await response.json();
+    return {
+      period: data.period || period,
+      days: data.days || 7,
+      taskMetrics: (data.task_metrics || []).map((t) => ({
+        squad: t.squad,
+        tasksTotal: t.tasks_total || 0,
+        tasksCompleted: t.tasks_completed || 0,
+        tasksFailed: t.tasks_failed || 0,
+        successRate: t.success_rate || 0,
+        totalRetries: t.total_retries || 0,
+        tasksWithRetries: t.tasks_with_retries || 0,
+        avgRetries: t.avg_retries || 0,
+        avgDurationMs: t.avg_duration_ms || 0,
+        avgTokens: t.avg_tokens || 0,
+        avgCost: t.avg_cost || 0,
+        avgContextPct: t.avg_context_pct || 0,
+        maxContextTokens: t.max_context_tokens || 0
+      })),
+      qualityMetrics: (data.quality_metrics || []).map((q) => ({
+        squad: q.squad,
+        feedbackCount: q.feedback_count || 0,
+        avgQuality: q.avg_quality || 0,
+        helpfulPct: q.helpful_pct || 0,
+        fixRequiredPct: q.fix_required_pct || 0
+      })),
+      topTools: (data.top_tools || []).map((t) => ({
+        toolName: t.tool_name,
+        usageCount: t.usage_count || 0,
+        successRate: t.success_rate || 0,
+        avgDurationMs: t.avg_duration_ms || 0
+      })),
+      toolFailureRate: data.tool_failure_rate || 0,
+      source: "bridge"
+    };
+  } catch {
+    return {
+      period,
+      days: period === "day" ? 1 : period === "week" ? 7 : 30,
+      taskMetrics: [],
+      qualityMetrics: [],
+      topTools: [],
+      toolFailureRate: 0,
+      source: "none"
+    };
+  }
+}
+
+// src/lib/db.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pg = require2("pg");
+var { Pool } = pg;
+var DATABASE_URL = process.env.SQUADS_DATABASE_URL || "postgresql://squads:squads_local_dev@localhost:5433/squads";
+var pool = null;
+function getPool() {
+  if (!pool) {
+    pool = new Pool({
+      connectionString: DATABASE_URL,
+      max: 5,
+      idleTimeoutMillis: 3e4,
+      connectionTimeoutMillis: 5e3
+    });
+    pool.on("error", (err) => {
+      console.error("Unexpected database pool error:", err);
+    });
+  }
+  return pool;
+}
+async function isDatabaseAvailable() {
+  try {
+    const pool2 = getPool();
+    const client = await pool2.connect();
+    await client.query("SELECT 1");
+    client.release();
+    return true;
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error("DB availability check failed:", err);
+    }
+    return false;
+  }
+}
+async function saveDashboardSnapshot(snapshot) {
+  try {
+    const pool2 = getPool();
+    const client = await pool2.connect();
+    const result = await client.query(`
+      INSERT INTO squads.dashboard_snapshots (
+        total_squads, total_commits, total_prs_merged, total_issues_closed, total_issues_open,
+        goal_progress_pct, cost_usd, daily_budget_usd, input_tokens, output_tokens,
+        commits_30d, avg_commits_per_day, active_days, peak_commits, peak_date,
+        squads_data, authors_data, repos_data
+      ) VALUES (
+        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18
+      ) RETURNING id
+    `, [
+      snapshot.totalSquads,
+      snapshot.totalCommits,
+      snapshot.totalPrsMerged,
+      snapshot.totalIssuesClosed,
+      snapshot.totalIssuesOpen,
+      snapshot.goalProgressPct,
+      snapshot.costUsd,
+      snapshot.dailyBudgetUsd,
+      snapshot.inputTokens,
+      snapshot.outputTokens,
+      snapshot.commits30d,
+      snapshot.avgCommitsPerDay,
+      snapshot.activeDays,
+      snapshot.peakCommits,
+      snapshot.peakDate,
+      JSON.stringify(snapshot.squadsData),
+      JSON.stringify(snapshot.authorsData),
+      JSON.stringify(snapshot.reposData)
+    ]);
+    client.release();
+    return result.rows[0]?.id ?? null;
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error("DB save error:", err);
+    }
+    return null;
+  }
+}
+async function getDashboardHistory(limit = 30) {
+  try {
+    const client = await getPool().connect();
+    const result = await client.query(`
+      SELECT
+        total_squads, total_commits, total_prs_merged, total_issues_closed, total_issues_open,
+        goal_progress_pct, cost_usd, daily_budget_usd, input_tokens, output_tokens,
+        commits_30d, avg_commits_per_day, active_days, peak_commits, peak_date,
+        squads_data, authors_data, repos_data, captured_at
+      FROM squads.dashboard_snapshots
+      ORDER BY captured_at DESC
+      LIMIT $1
+    `, [limit]);
+    client.release();
+    return result.rows.map((row) => ({
+      totalSquads: row.total_squads,
+      totalCommits: row.total_commits,
+      totalPrsMerged: row.total_prs_merged,
+      totalIssuesClosed: row.total_issues_closed,
+      totalIssuesOpen: row.total_issues_open,
+      goalProgressPct: row.goal_progress_pct,
+      costUsd: parseFloat(String(row.cost_usd)),
+      dailyBudgetUsd: parseFloat(String(row.daily_budget_usd)),
+      inputTokens: row.input_tokens,
+      outputTokens: row.output_tokens,
+      commits30d: row.commits_30d,
+      avgCommitsPerDay: parseFloat(String(row.avg_commits_per_day)),
+      activeDays: row.active_days,
+      peakCommits: row.peak_commits,
+      peakDate: row.peak_date,
+      squadsData: row.squads_data || [],
+      authorsData: row.authors_data || [],
+      reposData: row.repos_data || []
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/dashboard.ts
+function getLastActivityDate(squadName) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return "unknown";
+  const squadMemory = join9(memoryDir, squadName);
+  if (!existsSync9(squadMemory)) return "\u2014";
+  let latestTime = 0;
+  try {
+    const agents = readdirSync5(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"));
+      for (const file of files) {
+        const filePath = join9(agentPath, file);
+        const stats = statSync2(filePath);
+        if (stats.mtimeMs > latestTime) {
+          latestTime = stats.mtimeMs;
+        }
+      }
+    }
+  } catch {
+    return "\u2014";
+  }
+  if (latestTime === 0) return "\u2014";
+  const ageMs = Date.now() - latestTime;
+  const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
+  if (ageDays === 0) return "today";
+  if (ageDays === 1) return "1d";
+  if (ageDays < 7) return `${ageDays}d`;
+  return `${Math.floor(ageDays / 7)}w`;
+}
+async function dashboardCommand(options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    return;
+  }
+  if (options.ceo) {
+    await renderCeoReport(squadsDir);
+    return;
+  }
+  const squadNames = listSquads(squadsDir);
+  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) {
+      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 hasProgress = squad.goals.filter((g) => g.progress).length;
+    const goalProgress = totalGoals2 > 0 ? Math.round((completedGoals2 + hasProgress * 0.3) / totalGoals2 * 100) : 0;
+    squadData.push({
+      name,
+      mission: squad.mission,
+      goals: squad.goals,
+      lastActivity,
+      status,
+      github,
+      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;
+  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}`);
+  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}`);
+  writeLine();
+  const w = { name: 13, commits: 7, prs: 4, issues: 6, goals: 6, bar: 10 };
+  const tableWidth = w.name + w.commits + w.prs + w.issues + w.goals + w.bar + 12;
+  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.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;
+    const bActivity = (b.github?.commits || 0) + (b.github?.prsMerged || 0) * 5;
+    return bActivity - aActivity;
+  });
+  for (const squad of sortedSquads) {
+    const gh = squad.github;
+    const commits = gh?.commits || 0;
+    const prs = gh?.prsMerged || 0;
+    const issuesClosed = gh?.issuesClosed || 0;
+    const issuesOpen = gh?.issuesOpen || 0;
+    const activeCount = squad.goals.filter((g) => !g.completed).length;
+    const totalCount = squad.goals.length;
+    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.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();
+  const allActiveGoals = squadData.flatMap(
+    (s) => s.goals.filter((g) => !g.completed).map((g) => ({ squad: s.name, goal: g }))
+  );
+  if (allActiveGoals.length > 0) {
+    writeLine(`  ${bold}Goals${RESET}`);
+    writeLine();
+    const maxGoals = 6;
+    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}`);
+      if (hasProgress) {
+        const progressText = truncate(goal2.progress, 52);
+        writeLine(`    ${colors.dim}\u2514${RESET} ${colors.green}${progressText}${RESET}`);
+      }
+    }
+    if (allActiveGoals.length > maxGoals) {
+      writeLine(`  ${colors.dim}  +${allActiveGoals.length - maxGoals} more${RESET}`);
+    }
+    writeLine();
+  }
+  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);
+}
+function findAgentsSquadsDir() {
+  const candidates = [
+    join9(process.cwd(), ".."),
+    join9(homedir2(), "agents-squads")
+  ];
+  for (const dir of candidates) {
+    if (existsSync9(join9(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) {
+    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();
+  const metrics = [
+    `${colors.cyan}${stats.totalCommits}${RESET} commits`,
+    `${colors.green}${stats.avgCommitsPerDay}${RESET}/day`,
+    `${colors.purple}${stats.activeDays}${RESET} active days`
+  ];
+  if (stats.peakDay) {
+    metrics.push(`${colors.yellow}${stats.peakDay.count}${RESET} peak ${colors.dim}(${stats.peakDay.date})${RESET}`);
+  }
+  writeLine(`  ${metrics.join(`  ${colors.dim}\u2502${RESET}  `)}`);
+  writeLine();
+  const sortedRepos = Array.from(stats.commitsByRepo.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (sortedRepos.length > 0) {
+    const maxRepoCommits = sortedRepos[0][1];
+    for (const [repo, commits] of sortedRepos) {
+      const bar = barChart(commits, maxRepoCommits, 12);
+      writeLine(`  ${colors.cyan}${padEnd(repo, 20)}${RESET}${bar} ${colors.dim}${commits}${RESET}`);
+    }
+    writeLine();
+  }
+  const sortedAuthors = Array.from(stats.commitsByAuthor.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3);
+  if (sortedAuthors.length > 0) {
+    const authorLine = sortedAuthors.map(([author, count]) => `${colors.dim}${truncate(author, 15)}${RESET} ${colors.cyan}${count}${RESET}`).join(`  ${colors.dim}\u2502${RESET}  `);
+    writeLine(`  ${colors.dim}By author:${RESET} ${authorLine}`);
+    writeLine();
+  }
+}
+async function renderTokenEconomics(squadNames) {
+  const costs = await fetchCostSummary(100);
+  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}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${bold}Token Economics${RESET} ${colors.dim}(last 100 calls)${RESET}`);
+  writeLine();
+  const barWidth = 32;
+  const costBar = formatCostBar(costs.usedPercent, barWidth);
+  writeLine(`  ${colors.dim}Budget $${costs.dailyBudget}${RESET} [${costBar}] ${costs.usedPercent.toFixed(1)}%`);
+  writeLine(`  ${colors.green}$${costs.totalCost.toFixed(2)}${RESET} used  ${colors.dim}\u2502${RESET}  ${colors.cyan}$${costs.idleBudget.toFixed(2)}${RESET} idle`);
+  writeLine();
+  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 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}`);
+  if (dailyProjection > costs.dailyBudget * 0.8) {
+    writeLine(`  ${colors.yellow}\u26A0${RESET} ${colors.yellow}Projected to exceed daily budget${RESET}`);
+  }
+  if (costs.usedPercent > 80) {
+    writeLine(`  ${colors.red}\u26A0${RESET} ${colors.red}${costs.usedPercent.toFixed(0)}% of daily budget used${RESET}`);
+  }
+  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) {
+    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}`);
+    }
+  }
+  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();
+  }
+}
+var P0_KEYWORDS = ["revenue", "first", "launch", "publish", "ship", "critical", "urgent"];
+var P1_KEYWORDS = ["track", "establish", "identify", "define", "fix"];
+function inferPriority(goal2) {
+  const lower = goal2.toLowerCase();
+  if (P0_KEYWORDS.some((k) => lower.includes(k))) return "P0";
+  if (P1_KEYWORDS.some((k) => lower.includes(k))) return "P1";
+  return "P2";
+}
+async function renderCeoReport(squadsDir) {
+  const squadNames = listSquads(squadsDir);
+  const allGoals = [];
+  const blockers = [];
+  let activeSquads = 0;
+  let staleSquads = 0;
+  for (const name of squadNames) {
+    const squad = loadSquad(name);
+    if (!squad) continue;
+    const lastActivity = getLastActivityDate(name);
+    const activeGoals = squad.goals.filter((g) => !g.completed);
+    if (activeGoals.length === 0) {
+      blockers.push(`${name}: No active goals`);
+    } else if (lastActivity.includes("w") || lastActivity === "\u2014") {
+      blockers.push(`${name}: Stale (${lastActivity})`);
+      staleSquads++;
+    } else {
+      activeSquads++;
+    }
+    for (const goal2 of activeGoals) {
+      allGoals.push({
+        squad: name,
+        goal: goal2,
+        priority: inferPriority(goal2.description)
+      });
+    }
+  }
+  allGoals.sort((a, b) => {
+    const order = { P0: 0, P1: 1, P2: 2 };
+    return order[a.priority] - order[b.priority];
+  });
+  const p0Goals = allGoals.filter((g) => g.priority === "P0");
+  const p1Goals = allGoals.filter((g) => g.priority === "P1");
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}CEO Report${RESET}`);
+  writeLine(`  ${colors.dim}${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}${RESET}`);
+  writeLine();
+  const w = { label: 20, value: 12 };
+  const tableWidth = w.label + w.value + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("METRIC", w.label)}${RESET}${bold}VALUE${RESET}       ${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${padEnd("Active Squads", w.label)}${colors.green}${padEnd(`${activeSquads}/${squadNames.length}`, w.value)}${RESET}${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${padEnd("P0 Goals", w.label)}${colors.red}${padEnd(String(p0Goals.length), w.value)}${RESET}${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${padEnd("P1 Goals", w.label)}${colors.yellow}${padEnd(String(p1Goals.length), w.value)}${RESET}${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${padEnd("Blockers", w.label)}${blockers.length > 0 ? colors.red : colors.green}${padEnd(String(blockers.length), w.value)}${RESET}${colors.purple}${box.vertical}${RESET}`);
+  const costs = await fetchCostSummary(100);
+  if (costs) {
+    const spendStr = `$${costs.totalCost.toFixed(2)} / $${costs.dailyBudget}`;
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${padEnd("Daily Spend", w.label)}${colors.green}${padEnd(spendStr, w.value)}${RESET}${colors.purple}${box.vertical}${RESET}`);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  if (p0Goals.length > 0) {
+    writeLine(`  ${bold}${colors.red}P0${RESET} ${bold}Priorities${RESET} ${colors.dim}(revenue/launch critical)${RESET}`);
+    writeLine();
+    for (const { squad, goal: goal2 } of p0Goals.slice(0, 5)) {
+      writeLine(`  ${icons.error} ${colors.cyan}${squad}${RESET} ${goal2.description}`);
+      if (goal2.progress) {
+        writeLine(`    ${colors.dim}\u2514 ${goal2.progress}${RESET}`);
+      }
+    }
+    writeLine();
+  }
+  if (p1Goals.length > 0) {
+    writeLine(`  ${bold}${colors.yellow}P1${RESET} ${bold}Important${RESET} ${colors.dim}(tracking/foundations)${RESET}`);
+    writeLine();
+    for (const { squad, goal: goal2 } of p1Goals.slice(0, 3)) {
+      writeLine(`  ${icons.warning} ${colors.cyan}${squad}${RESET} ${truncate(goal2.description, 50)}`);
+    }
+    if (p1Goals.length > 3) {
+      writeLine(`  ${colors.dim}  +${p1Goals.length - 3} more${RESET}`);
+    }
+    writeLine();
+  }
+  if (blockers.length > 0) {
+    writeLine(`  ${bold}Blockers${RESET}`);
+    writeLine();
+    for (const blocker of blockers.slice(0, 3)) {
+      writeLine(`  ${icons.error} ${colors.red}${blocker}${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${bold}Next Steps${RESET}`);
+  writeLine();
+  if (p0Goals.length > 0) {
+    writeLine(`  ${icons.active} Focus on P0: ${colors.cyan}${p0Goals[0].squad}${RESET} - ${truncate(p0Goals[0].goal.description, 40)}`);
+  }
+  if (blockers.length > 0) {
+    writeLine(`  ${icons.warning} Unblock: ${colors.yellow}${blockers[0]}${RESET}`);
+  }
+  if (staleSquads > 0) {
+    writeLine(`  ${icons.progress} Revive ${staleSquads} stale squad(s)`);
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads dash              ${colors.dim}Full operational view${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads goal list         ${colors.dim}All active goals${RESET}`);
+  writeLine();
+}
+
+// src/commands/issues.ts
+import { execSync as execSync3 } from "child_process";
+var DEFAULT_ORG = "agents-squads";
+var DEFAULT_REPOS = ["hq", "agents-squads-web", "squads-cli"];
+async function issuesCommand(options = {}) {
+  const org = options.org || DEFAULT_ORG;
+  const repos = options.repos ? options.repos.split(",") : DEFAULT_REPOS;
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}issues${RESET}`);
+  writeLine();
+  try {
+    execSync3("gh --version", { stdio: "pipe" });
+  } catch {
+    writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
+    writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
+    writeLine();
+    return;
+  }
+  const repoData = [];
+  let totalOpen = 0;
+  for (const repo of repos) {
+    try {
+      const result = execSync3(
+        `gh issue list -R ${org}/${repo} --state open --json number,title,state,labels,createdAt --limit 50`,
+        { stdio: "pipe", encoding: "utf-8" }
+      );
+      const issues = JSON.parse(result);
+      repoData.push({ repo, issues });
+      totalOpen += issues.length;
+    } catch (e) {
+      repoData.push({ repo, issues: [], error: "not found or no access" });
+    }
+  }
+  const reposWithIssues = repoData.filter((r) => r.issues.length > 0).length;
+  writeLine(`  ${colors.cyan}${totalOpen}${RESET} open issues  ${colors.dim}\u2502${RESET}  ${reposWithIssues}/${repos.length} repos`);
+  writeLine();
+  const w = { repo: 20, open: 6, latest: 40 };
+  const tableWidth = w.repo + w.open + w.latest + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("REPO", w.repo)}${RESET}${bold}${padEnd("OPEN", w.open)}${RESET}${bold}LATEST${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const { repo, issues, error } of repoData) {
+    const count = issues.length;
+    const countColor = count > 5 ? colors.red : count > 0 ? colors.yellow : colors.green;
+    let latest = `${colors.dim}\u2014${RESET}`;
+    if (error) {
+      latest = `${colors.dim}${error}${RESET}`;
+    } else if (issues.length > 0) {
+      latest = truncate(issues[0].title, w.latest - 2);
+    }
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(repo, w.repo)}${RESET}${countColor}${padEnd(String(count), w.open)}${RESET}${padEnd(latest, w.latest + 10)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  const allIssues = repoData.flatMap((r) => r.issues.map((i) => ({ ...i, repo: r.repo }))).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, 6);
+  if (allIssues.length > 0) {
+    writeLine(`  ${bold}Recent${RESET}`);
+    writeLine();
+    for (const issue of allIssues) {
+      const labelStr = issue.labels.length > 0 ? `${colors.dim}[${issue.labels.map((l) => l.name || l).join(", ")}]${RESET}` : "";
+      writeLine(`  ${icons.empty} ${colors.dim}#${issue.number}${RESET} ${truncate(issue.title, 50)} ${labelStr}`);
+      writeLine(`    ${colors.dim}\u2514 ${issue.repo}${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} gh issue list -R ${colors.cyan}${org}/<repo>${RESET}   ${colors.dim}View repo issues${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} gh issue create -R ${colors.cyan}${org}/<repo>${RESET}  ${colors.dim}Create issue${RESET}`);
+  writeLine();
+}
+
+// src/commands/solve-issues.ts
+import { execSync as execSync4, spawn as spawn2 } from "child_process";
+import ora3 from "ora";
+var DEFAULT_ORG2 = "agents-squads";
+var DEFAULT_REPOS2 = ["hq", "agents-squads-web", "squads-cli", "agents-squads"];
+async function solveIssuesCommand(options = {}) {
+  const repos = options.repo ? [options.repo] : DEFAULT_REPOS2;
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}solve-issues${RESET}`);
+  writeLine();
+  try {
+    execSync4("gh --version", { stdio: "pipe" });
+  } catch {
+    writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
+    writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
+    return;
+  }
+  const issuesToSolve = [];
+  if (options.issue) {
+    const repo = options.repo || "hq";
+    try {
+      const result = execSync4(
+        `gh issue view ${options.issue} -R ${DEFAULT_ORG2}/${repo} --json number,title,labels,body`,
+        { stdio: "pipe", encoding: "utf-8" }
+      );
+      const issue = JSON.parse(result);
+      issuesToSolve.push({ ...issue, repo });
+    } catch {
+      writeLine(`  ${colors.red}Issue #${options.issue} not found in ${repo}${RESET}`);
+      return;
+    }
+  } else {
+    for (const repo of repos) {
+      try {
+        const result = execSync4(
+          `gh issue list -R ${DEFAULT_ORG2}/${repo} --label "ready-to-fix" --state open --json number,title,labels --limit 20`,
+          { stdio: "pipe", encoding: "utf-8" }
+        );
+        const issues = JSON.parse(result);
+        for (const issue of issues) {
+          issuesToSolve.push({ ...issue, repo });
+        }
+      } catch {
+      }
+    }
+  }
+  if (issuesToSolve.length === 0) {
+    writeLine(`  ${colors.yellow}No issues with 'ready-to-fix' label found${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Label an issue to make it solvable:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} gh issue edit ${colors.cyan}<number>${RESET} -R ${colors.cyan}${DEFAULT_ORG2}/<repo>${RESET} --add-label ready-to-fix`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${colors.cyan}${issuesToSolve.length}${RESET} issue${issuesToSolve.length > 1 ? "s" : ""} to solve`);
+  writeLine();
+  for (const issue of issuesToSolve) {
+    const labels = issue.labels.map((l) => l.name).join(", ");
+    writeLine(`  ${icons.empty} ${colors.dim}#${issue.number}${RESET} ${truncate(issue.title, 50)}`);
+    writeLine(`    ${colors.dim}\u2514 ${issue.repo} [${labels}]${RESET}`);
+  }
+  writeLine();
+  if (options.dryRun) {
+    writeLine(`  ${colors.yellow}[DRY RUN] Would solve ${issuesToSolve.length} issues${RESET}`);
+    return;
+  }
+  if (options.execute) {
+    await solveWithClaude(issuesToSolve);
+  } else {
+    showSolveInstructions(issuesToSolve);
+  }
+}
+function showSolveInstructions(issues) {
+  writeLine(`  ${bold}To solve these issues:${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 1: In Claude Code session${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} /solve-issue ${colors.cyan}${issues[0].repo}${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 2: Execute with Claude CLI${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads solve-issues --execute`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 3: Solve specific issue${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads solve-issues --repo ${colors.cyan}${issues[0].repo}${RESET} --issue ${colors.cyan}${issues[0].number}${RESET} --execute`);
+  writeLine();
+}
+async function solveWithClaude(issues) {
+  const spinner = ora3("Starting issue solver...").start();
+  try {
+    execSync4("which claude", { stdio: "pipe" });
+  } catch {
+    spinner.fail("Claude CLI not found");
+    writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
+    return;
+  }
+  for (const issue of issues) {
+    spinner.text = `Solving #${issue.number}: ${truncate(issue.title, 40)}`;
+    const prompt = buildSolvePrompt(issue);
+    try {
+      const result = await executeClaudePrompt(prompt);
+      spinner.succeed(`Solved #${issue.number}`);
+      const prMatch = result.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+      if (prMatch) {
+        writeLine(`    ${colors.green}PR: ${prMatch[0]}${RESET}`);
+      }
+    } catch (error) {
+      spinner.fail(`Failed #${issue.number}: ${error}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}View results:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} gh pr list -R ${colors.cyan}${DEFAULT_ORG2}/<repo>${RESET}`);
+  writeLine();
+}
+function buildSolvePrompt(issue) {
+  return `Solve GitHub issue #${issue.number} in ${DEFAULT_ORG2}/${issue.repo}.
+
+Issue: ${issue.title}
+
+## CRITICAL: Work Decisively (No Verification Loops!)
+
+Read each file ONCE, edit ONCE, commit IMMEDIATELY.
+Verify with git diff, NOT by re-reading files.
+If reading the same file twice, STOP and move forward.
+
+## Instructions
+
+1. Read the issue: gh issue view ${issue.number} --repo ${DEFAULT_ORG2}/${issue.repo}
+
+2. Set up worktree:
+   git fetch origin main
+   git worktree add ../.worktrees/issue-${issue.number} -b solve/issue-${issue.number} origin/main
+   cd ../.worktrees/issue-${issue.number}
+
+3. Find and fix the problem (minimal changes)
+
+4. Commit: git add -A && git commit -m "fix: ..."
+
+5. Push and create PR:
+   git push -u origin solve/issue-${issue.number}
+   gh pr create --title "fix: ..." --body "Fixes #${issue.number}" --repo ${DEFAULT_ORG2}/${issue.repo}
+
+6. Clean up: git worktree remove ../.worktrees/issue-${issue.number} --force
+
+Return the PR URL when done.`;
+}
+function executeClaudePrompt(prompt) {
+  return new Promise((resolve, reject) => {
+    const claude = spawn2("claude", ["--print", prompt], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let output = "";
+    let error = "";
+    claude.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.stderr?.on("data", (data) => {
+      error += data.toString();
+    });
+    claude.on("close", (code) => {
+      if (code === 0) {
+        resolve(output);
+      } else {
+        reject(new Error(error || `Exited with code ${code}`));
+      }
+    });
+    claude.on("error", reject);
+    setTimeout(() => {
+      claude.kill();
+      reject(new Error("Timeout after 10 minutes"));
+    }, 10 * 60 * 1e3);
+  });
+}
+
+// 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 ora4 from "ora";
+var ISSUE_FINDER_PATTERNS = [
+  "*-eval.md",
+  "*-critic.md",
+  "*-auditor.md",
+  "site-tester.md"
+];
+async function openIssuesCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}open-issues${RESET}`);
+  writeLine();
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${colors.red}No .agents/squads directory found${RESET}`);
+    return;
+  }
+  const evalAgents = findEvalAgents(squadsDir, options.squad);
+  if (evalAgents.length === 0) {
+    writeLine(`  ${colors.yellow}No evaluator agents found${RESET}`);
+    writeLine(`  ${colors.dim}Evaluators match: *-eval.md, *-critic.md, *-auditor.md${RESET}`);
+    return;
+  }
+  const agents = options.agent ? evalAgents.filter((a) => a.name === options.agent || a.name === `${options.agent}.md`) : evalAgents;
+  if (agents.length === 0) {
+    writeLine(`  ${colors.red}Agent '${options.agent}' not found${RESET}`);
+    writeLine(`  ${colors.dim}Available: ${evalAgents.map((a) => a.name).join(", ")}${RESET}`);
+    return;
+  }
+  const bySquad = agents.reduce((acc, agent) => {
+    if (!acc[agent.squad]) acc[agent.squad] = [];
+    acc[agent.squad].push(agent);
+    return acc;
+  }, {});
+  writeLine(`  ${colors.cyan}${agents.length}${RESET} evaluator${agents.length > 1 ? "s" : ""} ready`);
+  writeLine();
+  for (const [squad, squadAgents] of Object.entries(bySquad)) {
+    writeLine(`  ${bold}${squad}${RESET}`);
+    for (const agent of squadAgents) {
+      writeLine(`    ${icons.empty} ${colors.cyan}${agent.name.replace(".md", "")}${RESET}`);
+    }
+  }
+  writeLine();
+  if (options.dryRun) {
+    writeLine(`  ${colors.yellow}[DRY RUN] Would run ${agents.length} evaluators${RESET}`);
+    return;
+  }
+  if (options.execute) {
+    await runEvaluators(agents);
+  } else {
+    showRunInstructions(agents);
+  }
+}
+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);
+  for (const squad of squads) {
+    const squadPath = join10(squadsDir, squad);
+    const files = readdirSync6(squadPath).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const isEval = ISSUE_FINDER_PATTERNS.some((pattern) => {
+        const regex = new RegExp("^" + pattern.replace("*", ".*") + "$");
+        return regex.test(file);
+      });
+      if (isEval) {
+        agents.push({
+          name: file,
+          squad,
+          path: join10(squadPath, file)
+        });
+      }
+    }
+  }
+  return agents;
+}
+function showRunInstructions(agents) {
+  writeLine(`  ${bold}To run evaluators:${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 1: In Claude Code session${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} /website-eval`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 2: Execute with Claude CLI${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads open-issues --execute`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 3: Run specific evaluator${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads open-issues --squad ${colors.cyan}${agents[0].squad}${RESET} --agent ${colors.cyan}${agents[0].name.replace(".md", "")}${RESET} --execute`);
+  writeLine();
+  writeLine(`  ${colors.dim}Option 4: Via squads run${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${agents[0].squad}/${agents[0].name.replace(".md", "")}${RESET} --execute`);
+  writeLine();
+}
+async function runEvaluators(agents) {
+  const spinner = ora4("Starting evaluators...").start();
+  try {
+    execSync5("which claude", { stdio: "pipe" });
+  } catch {
+    spinner.fail("Claude CLI not found");
+    writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
+    return;
+  }
+  let issuesCreated = 0;
+  for (const agent of agents) {
+    spinner.text = `Running ${agent.squad}/${agent.name.replace(".md", "")}...`;
+    const prompt = buildEvalPrompt(agent);
+    try {
+      const result = await executeClaudePrompt2(prompt);
+      spinner.succeed(`${agent.name.replace(".md", "")}`);
+      const issueMatches = result.match(/Created issue #\d+/g) || [];
+      issuesCreated += issueMatches.length;
+      if (issueMatches.length > 0) {
+        writeLine(`    ${colors.green}Created ${issueMatches.length} issue(s)${RESET}`);
+      } else {
+        writeLine(`    ${colors.dim}No issues found${RESET}`);
+      }
+    } catch (error) {
+      spinner.fail(`${agent.name.replace(".md", "")}: ${error}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${bold}Summary${RESET}`);
+  writeLine(`  ${colors.cyan}${issuesCreated}${RESET} new issues created`);
+  writeLine();
+  writeLine(`  ${colors.dim}View issues:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads issues`);
+  writeLine();
+  writeLine(`  ${colors.dim}Solve them:${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads solve-issues`);
+  writeLine();
+}
+function buildEvalPrompt(agent) {
+  return `Execute the ${agent.name.replace(".md", "")} evaluator from squad ${agent.squad}.
+
+Read the agent definition at ${agent.path} and follow its instructions exactly.
+
+## CRITICAL: Work Decisively
+
+- Evaluate the target (website, code, etc.)
+- For each finding, create a GitHub issue
+- Use: gh issue create --repo agents-squads/{repo} --title "..." --body "..." --label "type:...,priority:P1/P2/P3,squad:${agent.squad}"
+- Report how many issues were created
+
+Do NOT get stuck re-reading files. Evaluate, report findings, create issues, done.`;
+}
+function executeClaudePrompt2(prompt) {
+  return new Promise((resolve, reject) => {
+    const claude = spawn3("claude", ["--print", prompt], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let output = "";
+    let error = "";
+    claude.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    claude.stderr?.on("data", (data) => {
+      error += data.toString();
+    });
+    claude.on("close", (code) => {
+      if (code === 0) {
+        resolve(output);
+      } else {
+        reject(new Error(error || `Exited with code ${code}`));
+      }
+    });
+    claude.on("error", reject);
+    setTimeout(() => {
+      claude.kill();
+      reject(new Error("Timeout after 5 minutes"));
+    }, 5 * 60 * 1e3);
+  });
+}
+
+// src/commands/login.ts
+import chalk2 from "chalk";
+import ora5 from "ora";
+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 http from "http";
+var PERSONAL_DOMAINS = [
+  "gmail.com",
+  "googlemail.com",
+  "yahoo.com",
+  "yahoo.co.uk",
+  "yahoo.fr",
+  "hotmail.com",
+  "outlook.com",
+  "live.com",
+  "msn.com",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "aol.com",
+  "protonmail.com",
+  "proton.me",
+  "zoho.com",
+  "mail.com",
+  "yandex.com",
+  "yandex.ru",
+  "gmx.com",
+  "gmx.de",
+  "fastmail.com",
+  "tutanota.com",
+  "hey.com"
+];
+var AUTH_DIR = join11(homedir3(), ".squads-cli");
+var AUTH_PATH = join11(AUTH_DIR, "auth.json");
+function isPersonalEmail(email) {
+  const domain = email.split("@")[1]?.toLowerCase();
+  return PERSONAL_DOMAINS.includes(domain);
+}
+function getEmailDomain(email) {
+  return email.split("@")[1]?.toLowerCase() || "";
+}
+function saveSession(session) {
+  if (!existsSync11(AUTH_DIR)) {
+    mkdirSync6(AUTH_DIR, { recursive: true });
+  }
+  writeFileSync7(AUTH_PATH, JSON.stringify(session, null, 2));
+}
+function loadSession() {
+  if (!existsSync11(AUTH_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync8(AUTH_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function clearSession() {
+  if (existsSync11(AUTH_PATH)) {
+    writeFileSync7(AUTH_PATH, "");
+  }
+}
+function startAuthCallbackServer(port = 54321) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const email = url.searchParams.get("email");
+        const token = url.searchParams.get("token");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+                <div style="text-align: center;">
+                  <h1 style="color: #ef4444;">\u274C ${error}</h1>
+                  <p>You can close this window.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        if (email && token) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+                <div style="text-align: center;">
+                  <h1 style="color: #10b981;">\u2713 Logged in!</h1>
+                  <p>Welcome, ${email}</p>
+                  <p style="color: #6b7280;">You can close this window and return to your terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve({ email, token });
+        } else {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Missing email or token");
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.listen(port, () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out"));
+    }, 5 * 60 * 1e3);
+  });
+}
+
+// src/commands/login.ts
+var AUTH_URL = process.env.SQUADS_AUTH_URL || "https://app.agents-squads.com/auth";
+var CALLBACK_PORT = 54321;
+async function loginCommand() {
+  const existingSession = loadSession();
+  if (existingSession && existingSession.status === "active") {
+    console.log(chalk2.green(`\u2713 Already logged in as ${existingSession.email}`));
+    console.log(chalk2.dim(`  Domain: ${existingSession.domain}`));
+    console.log(chalk2.dim(`  Run 'squads logout' to sign out.`));
+    return;
+  }
+  console.log(`
+${chalk2.bold.magenta("Squads CLI Login")}
+${chalk2.dim("\u2500".repeat(40))}
+
+Opening browser to authenticate...
+`);
+  const spinner = ora5("Waiting for authentication...").start();
+  try {
+    const callbackPromise = startAuthCallbackServer(CALLBACK_PORT);
+    const authUrl = `${AUTH_URL}?callback=http://localhost:${CALLBACK_PORT}/callback`;
+    await open(authUrl);
+    const { email, token } = await callbackPromise;
+    if (isPersonalEmail(email)) {
+      spinner.fail("Personal emails not supported");
+      console.log(`
+${chalk2.yellow("\u26A0 Squads CLI is for Pro & Enterprise teams only.")}
+
+Personal email domains (Gmail, Yahoo, etc.) are not supported.
+
+${chalk2.dim("Want to stay updated?")}
+  \u2192 Get our free research report: ${chalk2.cyan("https://agents-squads.com/research")}
+  \u2192 Follow us: ${chalk2.cyan("https://x.com/agents_squads")}
+`);
+      await track("cli.login.personal_email", { domain: getEmailDomain(email) });
+      return;
+    }
+    const session = {
+      email,
+      domain: getEmailDomain(email),
+      status: "pending",
+      // Will be 'active' after sales contact
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      accessToken: token
+    };
+    saveSession(session);
+    spinner.succeed(`Logged in as ${chalk2.cyan(email)}`);
+    await track("cli.login.success", { domain: session.domain });
+    console.log(`
+${chalk2.green("\u2713 Thanks for signing up!")}
+
+${chalk2.bold("What happens next:")}
+  1. Our team will reach out within 24 hours
+  2. We'll discuss your AI agent needs
+  3. You'll get access to Pro features
+
+${chalk2.dim("In the meantime:")}
+  \u2192 Explore squads: ${chalk2.cyan("squads status")}
+  \u2192 Set goals: ${chalk2.cyan('squads goal set <squad> "<goal>"')}
+  \u2192 Read our research: ${chalk2.cyan("https://agents-squads.com/research")}
+
+${chalk2.dim("Questions? Email us at")} ${chalk2.cyan("hello@agents-squads.com")}
+`);
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+async function logoutCommand() {
+  const session = loadSession();
+  if (!session) {
+    console.log(chalk2.yellow("Not logged in."));
+    return;
+  }
+  clearSession();
+  console.log(chalk2.green(`\u2713 Logged out from ${session.email}`));
+  await track("cli.logout");
+}
+async function whoamiCommand() {
+  const session = loadSession();
+  if (!session) {
+    console.log(chalk2.yellow("Not logged in."));
+    console.log(chalk2.dim("Run: squads login"));
+    return;
+  }
+  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()}
+`);
+}
+
+// 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";
+function getTasksFilePath() {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) {
+    const cwd = process.cwd();
+    const agentsDir = join12(cwd, ".agents");
+    if (!existsSync12(agentsDir)) {
+      mkdirSync7(agentsDir, { recursive: true });
+    }
+    return join12(agentsDir, "tasks.json");
+  }
+  return join12(memoryDir, "..", "tasks.json");
+}
+function loadTasks() {
+  const tasksPath = getTasksFilePath();
+  if (existsSync12(tasksPath)) {
+    try {
+      return JSON.parse(readFileSync9(tasksPath, "utf-8"));
+    } catch {
+      return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+  }
+  return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function saveTasks(data) {
+  const tasksPath = getTasksFilePath();
+  data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync8(tasksPath, JSON.stringify(data, null, 2));
+}
+function getRecentActivity() {
+  const activity = [];
+  const squadKeywords = {
+    website: ["website", "web", "homepage", "astro", "page"],
+    product: ["cli", "squads-cli", "command"],
+    research: ["research", "report", "analysis"],
+    engineering: ["infra", "engineering", "build"],
+    intelligence: ["intel", "monitor", "competitor"],
+    customer: ["lead", "customer", "outreach"],
+    finance: ["cost", "finance", "budget"],
+    company: ["company", "strategy", "mission"],
+    marketing: ["marketing", "content", "social"]
+  };
+  try {
+    const logOutput = execSync6(
+      'git log --since="24 hours ago" --format="%h|%aI|%s" 2>/dev/null',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!logOutput) return activity;
+    for (const line of logOutput.split("\n")) {
+      const [hash, date, ...msgParts] = line.split("|");
+      const message = msgParts.join("|");
+      if (!hash || !message) continue;
+      const msgLower = message.toLowerCase();
+      let detectedSquad = "unknown";
+      for (const [squad, keywords] of Object.entries(squadKeywords)) {
+        if (keywords.some((k) => msgLower.includes(k))) {
+          detectedSquad = squad;
+          break;
+        }
+      }
+      activity.push({
+        squad: detectedSquad,
+        message,
+        hash,
+        date: date.split("T")[0]
+      });
+    }
+  } catch {
+  }
+  return activity;
+}
+async function progressCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}progress${RESET}`);
+  writeLine();
+  const tasksData = loadTasks();
+  const recentActivity = getRecentActivity();
+  const activeTasks = tasksData.tasks.filter((t) => t.status === "active");
+  const completedToday = tasksData.tasks.filter(
+    (t) => t.status === "completed" && t.completedAt?.startsWith((/* @__PURE__ */ new Date()).toISOString().split("T")[0])
+  );
+  const stats = [
+    `${colors.cyan}${activeTasks.length}${RESET} active`,
+    `${colors.green}${completedToday.length}${RESET} done today`,
+    `${colors.purple}${recentActivity.length}${RESET} commits (24h)`
+  ].join(`  ${colors.dim}\u2502${RESET}  `);
+  writeLine(`  ${stats}`);
+  writeLine();
+  if (activeTasks.length > 0) {
+    writeLine(`  ${bold}Active Tasks${RESET}`);
+    writeLine();
+    for (const task of activeTasks) {
+      const elapsed = getElapsedTime(task.startedAt);
+      writeLine(`  ${icons.progress} ${colors.cyan}${task.squad}${RESET} ${truncate(task.description, 45)}`);
+      writeLine(`    ${colors.dim}started ${elapsed} ago${RESET}`);
+    }
+    writeLine();
+  } else {
+    writeLine(`  ${colors.dim}No active tasks${RESET}`);
+    writeLine();
+  }
+  if (recentActivity.length > 0) {
+    writeLine(`  ${bold}Recent Activity${RESET} ${colors.dim}(last 24h)${RESET}`);
+    writeLine();
+    const w = { squad: 12, message: 50 };
+    const tableWidth = w.squad + w.message + 4;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}COMMIT${RESET}${" ".repeat(w.message - 6)} ${colors.purple}${box.vertical}${RESET}`);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    const maxRows = options.verbose ? 15 : 8;
+    for (const act of recentActivity.slice(0, maxRows)) {
+      const squadColor = act.squad === "unknown" ? colors.dim : colors.cyan;
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${squadColor}${padEnd(act.squad, w.squad)}${RESET}${truncate(act.message, w.message - 2)} ${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+    if (recentActivity.length > maxRows) {
+      writeLine(`  ${colors.dim}+${recentActivity.length - maxRows} more commits${RESET}`);
+    }
+    writeLine();
+  }
+  if (completedToday.length > 0) {
+    writeLine(`  ${bold}Completed Today${RESET}`);
+    writeLine();
+    for (const task of completedToday.slice(0, 5)) {
+      writeLine(`  ${icons.success} ${colors.cyan}${task.squad}${RESET} ${truncate(task.description, 50)}`);
+    }
+    if (completedToday.length > 5) {
+      writeLine(`  ${colors.dim}+${completedToday.length - 5} more${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads results          ${colors.dim}KPI goals vs actuals${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads dash             ${colors.dim}Full dashboard${RESET}`);
+  writeLine();
+}
+async function progressStartCommand(squad, description) {
+  const tasksData = loadTasks();
+  const id = Math.random().toString(36).substring(2, 9);
+  tasksData.tasks.push({
+    id,
+    squad,
+    description,
+    status: "active",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  saveTasks(tasksData);
+  writeLine(`  ${icons.active} Task ${colors.cyan}${id}${RESET} started for ${colors.purple}${squad}${RESET}`);
+}
+async function progressCompleteCommand(taskId, options = {}) {
+  const tasksData = loadTasks();
+  const task = tasksData.tasks.find((t) => t.id === taskId);
+  if (!task) {
+    writeLine(`  ${icons.error} Task ${colors.red}${taskId}${RESET} not found`);
+    return;
+  }
+  task.status = options.failed ? "failed" : "completed";
+  task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveTasks(tasksData);
+  const icon = options.failed ? icons.error : icons.success;
+  const status = options.failed ? "failed" : "completed";
+  writeLine(`  ${icon} Task ${colors.cyan}${taskId}${RESET} ${status}`);
+}
+function getElapsedTime(startTime) {
+  const start = new Date(startTime).getTime();
+  const now = Date.now();
+  const diffMs = now - start;
+  const minutes = Math.floor(diffMs / 6e4);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d`;
+  if (hours > 0) return `${hours}h`;
+  if (minutes > 0) return `${minutes}m`;
+  return "<1m";
+}
+
+// src/commands/results.ts
+import { execSync as execSync7 } from "child_process";
+function getGitStats(days = 7) {
+  const stats = /* @__PURE__ */ new Map();
+  const squadKeywords = {
+    website: ["agents-squads-web", "website", "homepage"],
+    product: ["squads-cli", "cli"],
+    research: ["research"],
+    engineering: ["engineering", ".agents"],
+    intelligence: ["intelligence"],
+    customer: ["customer"],
+    finance: ["finance"],
+    company: ["company"],
+    marketing: ["marketing"]
+  };
+  try {
+    const logOutput = execSync7(
+      `git log --since="${days} days ago" --format="%s" --name-only 2>/dev/null`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!logOutput) return stats;
+    const entries = logOutput.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) continue;
+      const message = lines[0];
+      const files = lines.slice(1);
+      const msgLower = message.toLowerCase();
+      let detectedSquad = "other";
+      for (const [squad, keywords] of Object.entries(squadKeywords)) {
+        const inMessage = keywords.some((k) => msgLower.includes(k));
+        const inFiles = files.some(
+          (f) => keywords.some((k) => f.toLowerCase().includes(k))
+        );
+        if (inMessage || inFiles) {
+          detectedSquad = squad;
+          break;
+        }
+      }
+      if (!stats.has(detectedSquad)) {
+        stats.set(detectedSquad, { commits: 0, files: [] });
+      }
+      const squadStats = stats.get(detectedSquad);
+      squadStats.commits++;
+      squadStats.files.push(...files);
+    }
+  } catch {
+  }
+  return stats;
+}
+function getGitHubStats2(days = 7) {
+  const prsOpened = /* @__PURE__ */ new Map();
+  const prsMerged = /* @__PURE__ */ new Map();
+  const issuesClosed = /* @__PURE__ */ new Map();
+  try {
+    const prsOutput = execSync7(
+      `gh pr list --state all --json title,createdAt,mergedAt --limit 50 2>/dev/null`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const prs = JSON.parse(prsOutput || "[]");
+    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+    for (const pr of prs) {
+      const created = new Date(pr.createdAt);
+      if (created < since) continue;
+      const squad = detectSquadFromTitle(pr.title);
+      prsOpened.set(squad, (prsOpened.get(squad) || 0) + 1);
+      if (pr.mergedAt) {
+        prsMerged.set(squad, (prsMerged.get(squad) || 0) + 1);
+      }
+    }
+    const issuesOutput = execSync7(
+      `gh issue list --state closed --json title,closedAt --limit 50 2>/dev/null`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const issues = JSON.parse(issuesOutput || "[]");
+    for (const issue of issues) {
+      const closed = new Date(issue.closedAt);
+      if (closed < since) continue;
+      const squad = detectSquadFromTitle(issue.title);
+      issuesClosed.set(squad, (issuesClosed.get(squad) || 0) + 1);
+    }
+  } catch {
+  }
+  return { prsOpened, prsMerged, issuesClosed };
+}
+function detectSquadFromTitle(title) {
+  const lower = title.toLowerCase();
+  const mapping = {
+    website: ["website", "web", "homepage", "page"],
+    product: ["cli", "squads", "command"],
+    research: ["research", "report"],
+    engineering: ["infra", "build", "ci"],
+    intelligence: ["intel", "monitor"],
+    customer: ["lead", "customer"],
+    finance: ["cost", "finance"],
+    marketing: ["marketing", "content"]
+  };
+  for (const [squad, keywords] of Object.entries(mapping)) {
+    if (keywords.some((k) => lower.includes(k))) {
+      return squad;
+    }
+  }
+  return "other";
+}
+function parseMetrics(goal2) {
+  const metrics = [];
+  if (goal2.metrics && goal2.metrics.length > 0) {
+    return goal2.metrics;
+  }
+  const desc = goal2.description.toLowerCase();
+  if (desc.includes("revenue")) metrics.push("revenue_usd");
+  if (desc.includes("lead")) metrics.push("leads_count");
+  if (desc.includes("traffic") || desc.includes("visit")) metrics.push("page_views");
+  if (desc.includes("signup") || desc.includes("email")) metrics.push("signups");
+  if (desc.includes("cost")) metrics.push("cost_usd");
+  if (desc.includes("publish") || desc.includes("launch")) metrics.push("shipped");
+  if (desc.includes("demo")) metrics.push("demos_booked");
+  return metrics.length > 0 ? metrics : ["progress"];
+}
+async function resultsCommand(options = {}) {
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    return;
+  }
+  const days = parseInt(options.days || "7", 10);
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}results${RESET} ${colors.dim}(${days}d)${RESET}`);
+  writeLine();
+  const squadNames = options.squad ? [options.squad] : listSquads(squadsDir);
+  const gitStats = getGitStats(days);
+  const ghStats = getGitHubStats2(days);
+  const results = [];
+  for (const name of squadNames) {
+    const squad = loadSquad(name);
+    if (!squad) continue;
+    const git = gitStats.get(name) || { commits: 0, files: [] };
+    const activeGoals = squad.goals.filter((g) => !g.completed);
+    results.push({
+      name,
+      commits: git.commits,
+      prsOpened: ghStats.prsOpened.get(name) || 0,
+      prsMerged: ghStats.prsMerged.get(name) || 0,
+      issuesClosed: ghStats.issuesClosed.get(name) || 0,
+      goals: activeGoals.map((g) => ({
+        description: g.description,
+        metrics: parseMetrics(g),
+        progress: g.progress,
+        completed: g.completed
+      }))
+    });
+  }
+  const totalCommits = results.reduce((sum, r) => sum + r.commits, 0);
+  const totalPRs = results.reduce((sum, r) => sum + r.prsMerged, 0);
+  const totalGoals = results.reduce((sum, r) => sum + r.goals.length, 0);
+  const stats = [
+    `${colors.cyan}${totalCommits}${RESET} commits`,
+    `${colors.green}${totalPRs}${RESET} PRs merged`,
+    `${colors.purple}${totalGoals}${RESET} active goals`
+  ].join(`  ${colors.dim}\u2502${RESET}  `);
+  writeLine(`  ${stats}`);
+  writeLine();
+  const w = { squad: 14, commits: 8, prs: 6, goals: 5, kpi: 20 };
+  const tableWidth = w.squad + w.commits + w.prs + w.goals + w.kpi + 8;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("COMMITS", w.commits)}${RESET}${bold}${padEnd("PRs", w.prs)}${RESET}${bold}${padEnd("GOALS", w.goals)}${RESET}${bold}KEY METRIC${RESET} ${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const result of results) {
+    const keyMetric = result.goals.length > 0 ? result.goals[0].metrics[0] || "\u2014" : "\u2014";
+    const commitColor = result.commits > 0 ? colors.green : colors.dim;
+    const prColor = result.prsMerged > 0 ? colors.green : colors.dim;
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(result.name, w.squad)}${RESET}${commitColor}${padEnd(String(result.commits), w.commits)}${RESET}${prColor}${padEnd(String(result.prsMerged), w.prs)}${RESET}${padEnd(String(result.goals.length), w.goals)}${colors.dim}${truncate(keyMetric, w.kpi)}${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  if (options.verbose || options.squad) {
+    writeLine(`  ${bold}Goals & KPIs${RESET}`);
+    writeLine();
+    for (const result of results) {
+      if (result.goals.length === 0) continue;
+      writeLine(`  ${colors.cyan}${result.name}${RESET}`);
+      for (const goal2 of result.goals) {
+        const statusIcon = goal2.progress ? icons.progress : icons.empty;
+        writeLine(`  ${statusIcon} ${truncate(goal2.description, 55)}`);
+        if (goal2.metrics.length > 0) {
+          const metricsStr = goal2.metrics.map((m) => `${colors.purple}${m}${RESET}`).join(", ");
+          writeLine(`    ${colors.dim}metrics:${RESET} ${metricsStr}`);
+        }
+        if (goal2.progress) {
+          writeLine(`    ${colors.dim}progress:${RESET} ${colors.green}${goal2.progress}${RESET}`);
+        }
+      }
+      writeLine();
+    }
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads results ${colors.cyan}<squad>${RESET} -v  ${colors.dim}Detailed squad KPIs${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads goal progress      ${colors.dim}Update goal progress${RESET}`);
+  writeLine();
+}
+
+// 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";
+function getTasksFilePath2() {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return null;
+  return join13(memoryDir, "..", "tasks.json");
+}
+function loadActiveTasks() {
+  const tasksPath = getTasksFilePath2();
+  if (!tasksPath || !existsSync13(tasksPath)) return [];
+  try {
+    const data = JSON.parse(readFileSync10(tasksPath, "utf-8"));
+    return data.tasks?.filter((t) => t.status === "active") || [];
+  } catch {
+    return [];
+  }
+}
+function getRunningProcesses() {
+  const processes = [];
+  try {
+    const psOutput = execSync8(
+      'ps aux | grep -E "claude|squads|astro|node.*agent" | grep -v grep',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!psOutput) return processes;
+    for (const line of psOutput.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 11) continue;
+      const pid = parts[1];
+      const cpu = parts[2];
+      const mem = parts[3];
+      const time = parts[9];
+      const command = parts.slice(10).join(" ");
+      let type = "agent";
+      if (command.includes("claude")) type = "claude";
+      else if (command.includes("squads")) type = "hook";
+      else if (command.includes("astro")) type = "dev-server";
+      if (command.includes("grep")) continue;
+      processes.push({ pid, cpu, mem, time, command, type });
+    }
+  } catch {
+  }
+  return processes;
+}
+function categorizeProcesses(processes) {
+  return {
+    claude: processes.filter((p) => p.type === "claude"),
+    hooks: processes.filter((p) => p.type === "hook"),
+    devServers: processes.filter((p) => p.type === "dev-server"),
+    agents: processes.filter((p) => p.type === "agent")
+  };
+}
+function formatCommand(cmd, maxLen = 45) {
+  if (cmd.includes("claude")) {
+    return truncate("claude (session)", maxLen);
+  }
+  if (cmd.includes("astro dev")) {
+    return truncate("astro dev server", maxLen);
+  }
+  if (cmd.includes("squads")) {
+    const match = cmd.match(/squads\s+(\S+)/);
+    return truncate(`squads ${match?.[1] || "command"}`, maxLen);
+  }
+  return truncate(cmd, maxLen);
+}
+async function workersCommand(options = {}) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}workers${RESET}`);
+  writeLine();
+  if (options.kill) {
+    try {
+      execSync8(`kill ${options.kill}`, { stdio: "pipe" });
+      writeLine(`  ${icons.success} Killed process ${colors.cyan}${options.kill}${RESET}`);
+      writeLine();
+      return;
+    } catch {
+      writeLine(`  ${icons.error} Failed to kill process ${colors.red}${options.kill}${RESET}`);
+      writeLine();
+      return;
+    }
+  }
+  const activeTasks = loadActiveTasks();
+  const processes = getRunningProcesses();
+  const categorized = categorizeProcesses(processes);
+  const stats = [
+    `${colors.cyan}${categorized.claude.length}${RESET} claude`,
+    `${colors.green}${activeTasks.length}${RESET} tasks`,
+    `${colors.purple}${categorized.devServers.length}${RESET} dev servers`
+  ].join(`  ${colors.dim}\u2502${RESET}  `);
+  writeLine(`  ${stats}`);
+  writeLine();
+  if (categorized.claude.length > 0) {
+    writeLine(`  ${bold}Claude Sessions${RESET} ${colors.dim}(terminal tabs)${RESET}`);
+    writeLine();
+    const w = { pid: 8, cpu: 6, mem: 6, time: 8, cmd: 30 };
+    const tableWidth = w.pid + w.cpu + w.mem + w.time + w.cmd + 8;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("PID", w.pid)}${padEnd("CPU%", w.cpu)}${padEnd("MEM%", w.mem)}${padEnd("TIME", w.time)}${padEnd("STATUS", w.cmd)}${RESET} ${colors.purple}${box.vertical}${RESET}`);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const proc of categorized.claude) {
+      const cpuColor = parseFloat(proc.cpu) > 50 ? colors.yellow : colors.dim;
+      const status = parseFloat(proc.cpu) > 10 ? `${icons.active} active` : `${icons.pending} idle`;
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(proc.pid, w.pid)}${RESET}${cpuColor}${padEnd(proc.cpu, w.cpu)}${RESET}${colors.dim}${padEnd(proc.mem, w.mem)}${RESET}${colors.dim}${padEnd(proc.time, w.time)}${RESET}${padEnd(status, w.cmd)} ${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+    writeLine();
+  }
+  if (activeTasks.length > 0) {
+    writeLine(`  ${bold}Registered Tasks${RESET} ${colors.dim}(squads progress)${RESET}`);
+    writeLine();
+    for (const task of activeTasks) {
+      const elapsed = getElapsedTime2(task.startedAt);
+      writeLine(`  ${icons.progress} ${colors.cyan}${task.squad}${RESET} ${truncate(task.description, 40)}`);
+      writeLine(`    ${colors.dim}id: ${task.id} \xB7 started ${elapsed} ago${RESET}`);
+    }
+    writeLine();
+  }
+  if (categorized.devServers.length > 0) {
+    writeLine(`  ${bold}Dev Servers${RESET}`);
+    writeLine();
+    for (const proc of categorized.devServers) {
+      const name = formatCommand(proc.command);
+      writeLine(`  ${icons.active} ${colors.green}${name}${RESET} ${colors.dim}(pid: ${proc.pid})${RESET}`);
+    }
+    writeLine();
+  }
+  if (categorized.hooks.length > 0) {
+    writeLine(`  ${bold}Hook Processes${RESET}`);
+    writeLine();
+    for (const proc of categorized.hooks) {
+      const name = formatCommand(proc.command);
+      writeLine(`  ${icons.pending} ${colors.yellow}${name}${RESET} ${colors.dim}(pid: ${proc.pid})${RESET}`);
+    }
+    writeLine();
+  }
+  if (categorized.claude.length === 0 && activeTasks.length === 0) {
+    writeLine(`  ${colors.dim}No active workers${RESET}`);
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads workers --kill <pid>  ${colors.dim}Kill a process${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads progress             ${colors.dim}Task history${RESET}`);
+  writeLine();
+}
+function getElapsedTime2(startTime) {
+  const start = new Date(startTime).getTime();
+  const now = Date.now();
+  const diffMs = now - start;
+  const minutes = Math.floor(diffMs / 6e4);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d`;
+  if (hours > 0) return `${hours}h`;
+  if (minutes > 0) return `${minutes}m`;
+  return "<1m";
+}
+
+// src/cli.ts
+var envPaths = [
+  join14(process.cwd(), ".env"),
+  join14(process.cwd(), "..", "hq", ".env"),
+  join14(homedir4(), "agents-squads", "hq", ".env")
+];
+for (const envPath of envPaths) {
+  if (existsSync14(envPath)) {
+    config({ path: envPath, quiet: true });
+    break;
+  }
+}
+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("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("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);
+var progress = program.command("progress").description("Track active and completed agent tasks").option("-v, --verbose", "Show more activity").action(progressCommand);
+progress.command("start <squad> <description>").description("Register a new active task").action(progressStartCommand);
+progress.command("complete <taskId>").description("Mark a task as completed").option("-f, --failed", "Mark as failed instead").action(progressCompleteCommand);
+program.command("results [squad]").description("Show squad results: git activity + KPI goals vs actuals").option("-d, --days <days>", "Days to look back", "7").option("-v, --verbose", "Show detailed KPIs per goal").action((squad, options) => resultsCommand({ ...options, squad }));
+program.command("workers").description("Show active workers: Claude sessions, tasks, dev servers").option("-v, --verbose", "Show more details").option("-k, --kill <pid>", "Kill a process by PID").action(workersCommand);
+var memory = program.command("memory").description("Query and manage squad memory");
+memory.command("query <query>").description("Search across all squad memory").option("-s, --squad <squad>", "Limit search to specific squad").option("-a, --agent <agent>", "Limit search to specific agent").action(memoryQueryCommand);
+memory.command("show <squad>").description("Show memory for a squad").action(memoryShowCommand);
+memory.command("update <squad> <content>").description("Add to squad memory").option("-a, --agent <agent>", "Specific agent (default: squad-lead)").option("-t, --type <type>", "Memory type: state, learnings, feedback", "learnings").action(memoryUpdateCommand);
+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("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
+}));
+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);
+goal.command("complete <squad> <index>").description("Mark a goal as completed").action(goalCompleteCommand);
+goal.command("progress <squad> <index> <progress>").description("Update goal progress").action(goalProgressCommand);
+var feedback = program.command("feedback").description("Record and view execution feedback");
+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);
+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);
+await program.parseAsync();
+if (!process.argv.slice(2).length) {
+  console.log(`
+${chalk3.bold.magenta("squads")} - AI agent squad management
+
+${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
+
+${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
+
+${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
+
+${chalk3.dim("Run")} ${chalk3.cyan("squads --help")} ${chalk3.dim("for all commands.")}
+`);
+}
+//# sourceMappingURL=cli.js.map