squads-cli 0.6.1 → 0.7.0

package/dist/dashboard-L7YKVQEB.js

@@ -0,0 +1,945 @@
+#!/usr/bin/env node
+import {
+  calculateROIMetrics,
+  calculateSquadCostProjections,
+  fetchBridgeStats,
+  fetchClaudeCodeCapacity,
+  fetchCostSummary,
+  fetchInsights,
+  fetchNpmStats,
+  fetchQuotaInfo,
+  getPlanType,
+  isMaxPlan
+} from "./chunk-NA45DFXY.js";
+import "./chunk-LOA3KWYJ.js";
+import {
+  cleanupStaleSessions,
+  getLiveSessionSummaryAsync
+} from "./chunk-BODLDQY7.js";
+import {
+  getActivitySparkline,
+  getGitHubStatsOptimized,
+  getMultiRepoGitStats
+} from "./chunk-3KCWNZWW.js";
+import {
+  Events,
+  track
+} from "./chunk-L6GQCHDF.js";
+import {
+  findSquadsDir,
+  hasLocalInfraConfig,
+  listSquads,
+  loadSquad
+} from "./chunk-LDM62TIX.js";
+import {
+  findMemoryDir
+} from "./chunk-ZTQ7ISUR.js";
+import {
+  checkForUpdate
+} from "./chunk-NQN6JPI7.js";
+import {
+  RESET,
+  barChart,
+  bold,
+  box,
+  colors,
+  gradient,
+  icons,
+  padEnd,
+  progressBar,
+  sparkline,
+  truncate,
+  writeLine
+} from "./chunk-N7KDWU4W.js";
+import "./chunk-7OCVIDC7.js";
+
+// src/commands/dashboard.ts
+import { readdirSync, existsSync, statSync } from "fs";
+import { join } from "path";
+
+// src/lib/db.ts
+async function isDatabaseAvailable() {
+  return false;
+}
+async function saveDashboardSnapshot(_snapshot) {
+  return null;
+}
+async function getDashboardHistory(_limit = 30) {
+  return [];
+}
+async function closeDatabase() {
+}
+async function getLatestBaseline() {
+  return null;
+}
+
+// src/commands/dashboard.ts
+function getLastActivityDate(squadName) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return "unknown";
+  const squadMemory = join(memoryDir, squadName);
+  if (!existsSync(squadMemory)) return "\u2014";
+  let latestTime = 0;
+  try {
+    const agents = readdirSync(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
+    for (const agent of agents) {
+      const agentPath = join(squadMemory, agent.name);
+      const files = readdirSync(agentPath).filter((f) => f.endsWith(".md"));
+      for (const file of files) {
+        const filePath = join(agentPath, file);
+        const stats = statSync(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`;
+}
+function collectSquadMetrics(squadNames, gitStats, ghStats) {
+  const squadData = [];
+  const repoSquadMap = {
+    website: ["agents-squads-web"],
+    product: ["squads-cli"],
+    engineering: ["hq", "squads-cli"],
+    research: ["research"],
+    intelligence: ["intelligence"],
+    customer: ["customer"],
+    finance: ["finance"],
+    company: ["company", "hq"],
+    marketing: ["marketing", "agents-squads-web"],
+    cli: ["squads-cli"]
+  };
+  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 activeGoals = squad.goals.filter((g) => !g.completed);
+    if (activeGoals.length === 0) {
+      status = "needs-goal";
+    } else if (lastActivity.includes("w") || lastActivity === "\u2014") {
+      status = "stale";
+    }
+    const totalGoals = squad.goals.length;
+    const completedGoals = squad.goals.filter((g) => g.completed).length;
+    const hasProgress = squad.goals.filter((g) => g.progress).length;
+    const goalProgress = totalGoals > 0 ? Math.round((completedGoals + hasProgress * 0.3) / totalGoals * 100) : 0;
+    let squadCommits = 0;
+    if (gitStats) {
+      for (const [repo, commits] of gitStats.commitsByRepo) {
+        if (repoSquadMap[name]?.includes(repo)) {
+          squadCommits += commits;
+        }
+      }
+    }
+    const githubStats = github || {
+      prsOpened: 0,
+      prsMerged: 0,
+      issuesClosed: 0,
+      issuesOpen: 0,
+      commits: 0,
+      recentIssues: [],
+      recentPRs: []
+    };
+    githubStats.commits = squadCommits;
+    squadData.push({
+      name,
+      mission: squad.mission,
+      goals: squad.goals,
+      lastActivity,
+      status,
+      github: githubStats,
+      goalProgress
+    });
+  }
+  return squadData;
+}
+function calculateDashboardStats(squadData, ghStats) {
+  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;
+  const overallProgress = squadData.length > 0 ? Math.round(squadData.reduce((sum, s) => sum + s.goalProgress, 0) / squadData.length) : 0;
+  return {
+    activeSquads,
+    totalSquads: squadData.length,
+    totalPRs,
+    totalIssuesClosed,
+    totalIssuesOpen,
+    overallProgress
+  };
+}
+function renderDashboardHeader(stats, sessionSummary, gitStats, ghStats) {
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}dashboard${RESET}`);
+  const updateInfo = checkForUpdate();
+  if (updateInfo.updateAvailable) {
+    writeLine(`  ${colors.cyan}\u2B06${RESET} Update available: ${colors.dim}${updateInfo.currentVersion}${RESET} \u2192 ${colors.green}${updateInfo.latestVersion}${RESET} ${colors.dim}(run \`squads update\`)${RESET}`);
+  }
+  if (sessionSummary.totalSessions > 0) {
+    const sessionText = sessionSummary.totalSessions === 1 ? "session" : "sessions";
+    const squadText = sessionSummary.squadCount === 1 ? "squad" : "squads";
+    let toolInfo = "";
+    if (sessionSummary.byTool && Object.keys(sessionSummary.byTool).length > 0) {
+      const toolParts = Object.entries(sessionSummary.byTool).sort((a, b) => b[1] - a[1]).map(([tool, count]) => `${colors.dim}${tool}${RESET} ${colors.cyan}${count}${RESET}`);
+      toolInfo = ` ${colors.dim}(${RESET}${toolParts.join(` ${colors.dim}\xB7${RESET} `)}${colors.dim})${RESET}`;
+    }
+    writeLine(`  ${colors.green}${icons.active}${RESET} ${colors.white}${sessionSummary.totalSessions}${RESET} active ${sessionText} ${colors.dim}across${RESET} ${colors.cyan}${sessionSummary.squadCount}${RESET} ${squadText}${toolInfo}`);
+  }
+  writeLine();
+  const statsParts = [`${colors.cyan}${stats.activeSquads}${RESET}/${stats.totalSquads} squads`];
+  if (ghStats) {
+    statsParts.push(`${colors.green}${stats.totalPRs}${RESET} PRs merged`);
+    statsParts.push(`${colors.purple}${stats.totalIssuesClosed}${RESET} closed`);
+    statsParts.push(`${colors.yellow}${stats.totalIssuesOpen}${RESET} open`);
+  } else {
+    statsParts.push(`${colors.cyan}${gitStats?.totalCommits || 0}${RESET} commits`);
+    statsParts.push(`${colors.dim}use -f for PRs/issues${RESET}`);
+  }
+  writeLine(`  ${statsParts.join(`  ${colors.dim}\u2502${RESET}  `)}`);
+  writeLine();
+  writeLine(`  ${progressBar(stats.overallProgress, 32)} ${colors.dim}${stats.overallProgress}% goal progress${RESET}`);
+  writeLine();
+}
+function renderSquadsTable(squadData) {
+  const w = { name: 13, commits: 9, prs: 5, issues: 8, goals: 7, bar: 10 };
+  const tableWidth = w.name + w.commits + w.prs + w.issues + w.goals + w.bar + 6;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  writeLine(`  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("COMMITS", w.commits)}${RESET}${bold}${padEnd("PRs", w.prs)}${RESET}${bold}${padEnd("ISSUES", w.issues)}${RESET}${bold}${padEnd("GOALS", w.goals)}${RESET}${bold}PROGRESS${RESET} ${colors.purple}${box.vertical}${RESET}`);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  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 completedCount = 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;
+    writeLine(`  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad.name, w.name)}${RESET}${commitColor}${padEnd(String(commits), w.commits)}${RESET}${prColor}${padEnd(String(prs), w.prs)}${RESET}${issueColor}${padEnd(`${issuesClosed}/${issuesOpen}`, w.issues)}${RESET}${padEnd(`${completedCount}/${totalCount}`, w.goals)}${progressBar(squad.goalProgress, 8)} ${colors.purple}${box.vertical}${RESET}`);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+}
+function renderWorkingOn(gitStats) {
+  if (gitStats && gitStats.recentCommits && gitStats.recentCommits.length > 0) {
+    writeLine(`  ${bold}Working On${RESET}`);
+    writeLine();
+    for (const commit of gitStats.recentCommits.slice(0, 3)) {
+      const shortHash = commit.hash.slice(0, 7);
+      const shortMsg = truncate(commit.message, 45);
+      writeLine(`  ${colors.dim}${shortHash}${RESET} ${shortMsg} ${colors.dim}(${commit.repo})${RESET}`);
+    }
+    writeLine();
+  }
+}
+function renderGoalsSection(squadData) {
+  const allActiveGoals = squadData.flatMap(
+    (s) => s.goals.filter((g) => !g.completed).map((g) => ({
+      squad: s.name,
+      goal: g,
+      scope: inferScope(g.description)
+    }))
+  );
+  if (allActiveGoals.length > 0) {
+    const scopeOrder = { tactical: 0, operational: 1, strategic: 2 };
+    const sortedGoals = [...allActiveGoals].sort((a, b) => {
+      const scopeDiff = scopeOrder[a.scope] - scopeOrder[b.scope];
+      if (scopeDiff !== 0) return scopeDiff;
+      const aHasProgress = a.goal.progress ? 1 : 0;
+      const bHasProgress = b.goal.progress ? 1 : 0;
+      return bHasProgress - aHasProgress;
+    });
+    const scopeLabels = { tactical: "Next", operational: "In Progress", strategic: "Vision" };
+    const scopeIcons = { tactical: icons.active, operational: icons.progress, strategic: icons.empty };
+    writeLine(`  ${bold}Goals${RESET} ${colors.dim}(tactical \u2192 strategic)${RESET}`);
+    writeLine();
+    const maxGoals = 5;
+    let lastScope = "";
+    for (const { squad, goal, scope } of sortedGoals.slice(0, maxGoals)) {
+      if (scope !== lastScope) {
+        const label = scopeLabels[scope];
+        const labelColor = scope === "tactical" ? colors.green : scope === "strategic" ? colors.purple : colors.cyan;
+        writeLine(`  ${labelColor}${label}${RESET}`);
+        lastScope = scope;
+      }
+      const hasProgress = goal.progress && goal.progress.length > 0;
+      const icon = scopeIcons[scope];
+      writeLine(`  ${icon} ${colors.dim}${squad}${RESET} ${truncate(goal.description, 48)}`);
+      if (hasProgress) {
+        writeLine(`    ${colors.dim}\u2514${RESET} ${colors.green}${truncate(goal.progress, 52)}${RESET}`);
+      }
+    }
+    if (allActiveGoals.length > maxGoals) {
+      writeLine(`  ${colors.dim}  +${allActiveGoals.length - maxGoals} more${RESET}`);
+    }
+    writeLine();
+  }
+}
+function renderDashboardFooter() {
+  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();
+}
+async function dashboardCommand(options = {}) {
+  await track(Events.CLI_DASHBOARD, { verbose: options.verbose, ceo: options.ceo, fast: options.fast });
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    return;
+  }
+  if (options.ceo) {
+    await renderCeoReport(squadsDir);
+    return;
+  }
+  const baseDir = findAgentsSquadsDir();
+  const squadNames = listSquads(squadsDir);
+  const skipGitHub = options.fast !== false;
+  const cache = await fetchDashboardData(baseDir, skipGitHub);
+  const squadData = collectSquadMetrics(squadNames, cache.gitStats, cache.ghStats);
+  const stats = calculateDashboardStats(squadData, cache.ghStats);
+  if (options.json) {
+    const goalCount2 = {
+      active: squadData.reduce((sum, s) => sum + s.goals.filter((g) => !g.completed).length, 0),
+      completed: squadData.reduce((sum, s) => sum + s.goals.filter((g) => g.completed).length, 0)
+    };
+    console.log(JSON.stringify({
+      ok: true,
+      command: "dash",
+      data: {
+        squads: squadData.map((s) => ({
+          name: s.name,
+          mission: s.mission,
+          status: s.status,
+          goalProgress: s.goalProgress,
+          lastActivity: s.lastActivity,
+          goals: s.goals
+        })),
+        stats,
+        goals: goalCount2,
+        sessions: cache.sessionSummary,
+        costs: cache.costs,
+        gitStats: cache.gitStats ? {
+          totalCommits: cache.gitStats.totalCommits,
+          repos: cache.gitStats.repos?.map((r) => ({ name: r.name, commits: r.commits }))
+        } : null
+      }
+    }, null, 2));
+    await closeDatabase();
+    return;
+  }
+  renderDashboardHeader(stats, cache.sessionSummary, cache.gitStats, cache.ghStats);
+  renderSquadsTable(squadData);
+  const goalCount = {
+    active: squadData.reduce((sum, s) => sum + s.goals.filter((g) => !g.completed).length, 0),
+    completed: squadData.reduce((sum, s) => sum + s.goals.filter((g) => g.completed).length, 0)
+  };
+  renderGitPerformanceCached(cache);
+  renderTokenEconomicsCached(cache, goalCount);
+  renderROICached(cache, goalCount);
+  renderQuotaCached(cache);
+  renderCapacityCached(cache);
+  renderInfrastructureCached(cache);
+  renderAcquisitionCached(cache);
+  renderHistoricalTrendsCached(cache);
+  renderInsightsCached(cache);
+  renderWorkingOn(cache.gitStats);
+  renderGoalsSection(squadData);
+  renderDashboardFooter();
+  saveSnapshotCached(squadData, cache, baseDir).catch(() => {
+  });
+  await closeDatabase();
+}
+async function fetchDashboardData(baseDir, skipGitHub) {
+  const timeout = (promise, ms, fallback) => Promise.race([promise, new Promise((resolve) => setTimeout(() => resolve(fallback), ms))]);
+  cleanupStaleSessions();
+  const [gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights, sessionSummary, npmStats, quotaInfo, capacity, baseline] = await Promise.all([
+    // Git stats (local, parallel across repos)
+    baseDir ? getMultiRepoGitStats(baseDir, 30) : Promise.resolve(null),
+    // GitHub stats (network, ~20-30s) - skip by default for fast mode
+    skipGitHub ? Promise.resolve(null) : Promise.resolve(baseDir ? getGitHubStatsOptimized(baseDir, 30) : null),
+    // Langfuse costs (network, 2s timeout)
+    timeout(fetchCostSummary(100), 2e3, null),
+    // Bridge stats (local network, 2s timeout)
+    timeout(fetchBridgeStats(), 2e3, null),
+    // Activity sparkline (local, parallel across repos)
+    baseDir ? getActivitySparkline(baseDir, 14) : Promise.resolve([]),
+    // Database availability check (1.5s timeout)
+    timeout(isDatabaseAvailable(), 1500, false),
+    // Dashboard history (1.5s timeout)
+    timeout(getDashboardHistory(14).catch(() => []), 1500, []),
+    // Insights (2s timeout)
+    timeout(fetchInsights("week").catch(() => null), 2e3, null),
+    // Session summary (parallel lsof, ~1s)
+    getLiveSessionSummaryAsync(),
+    // NPM download stats (network, 2s timeout)
+    timeout(fetchNpmStats("squads-cli"), 2e3, null),
+    // Quota/autonomy info (local network, 2s timeout)
+    timeout(fetchQuotaInfo(), 2e3, null),
+    // Claude Code capacity (local file read, fast)
+    fetchClaudeCodeCapacity(),
+    // Latest baseline for ROI comparison (1.5s timeout)
+    timeout(getLatestBaseline().catch(() => null), 1500, null)
+  ]);
+  const roiMetrics = calculateROIMetrics(costs, 0, gitStats?.totalCommits || 0, ghStats?.prsMerged || 0);
+  const squadProjections = calculateSquadCostProjections(bridgeStats, null);
+  return { gitStats, ghStats, costs, bridgeStats, activity, dbAvailable, history, insights, sessionSummary, npmStats, quotaInfo, capacity, baseline, roiMetrics, squadProjections };
+}
+function findAgentsSquadsDir() {
+  const parentDir = join(process.cwd(), "..");
+  if (existsSync(join(parentDir, "hq"))) {
+    return parentDir;
+  }
+  if (existsSync(join(process.cwd(), ".git"))) {
+    return process.cwd();
+  }
+  return null;
+}
+function formatK(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(0) + "k";
+  return String(n);
+}
+function renderGitPerformanceCached(cache) {
+  const { gitStats: stats, activity } = cache;
+  if (!stats || stats.totalCommits === 0) {
+    writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(no commits in 30d)${RESET}`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${bold}Git Activity${RESET} ${colors.dim}(30d)${RESET}`);
+  writeLine();
+  if (activity.length > 0) {
+    const spark = sparkline(activity);
+    writeLine(`  ${colors.dim}Last 14d:${RESET} ${spark}`);
+    writeLine();
+  }
+  const metrics = [
+    `${colors.cyan}${stats.totalCommits}${RESET} commits`,
+    `${colors.green}${stats.avgCommitsPerDay}${RESET}/day`,
+    `${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();
+  }
+}
+function renderTokenEconomicsCached(cache, goalCount) {
+  const costs = cache.costs;
+  const stats = cache.bridgeStats;
+  const hasInfra = hasLocalInfraConfig();
+  const hasData = costs || stats;
+  writeLine(`  ${bold}Token Economics${RESET}`);
+  writeLine();
+  const planType = getPlanType();
+  const tier = parseInt(process.env.ANTHROPIC_TIER || "0", 10);
+  if (planType === "unknown") {
+    writeLine(`  ${colors.dim}\u25CB${RESET} ${bold}Plan${RESET} ${colors.yellow}not configured${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Set your Claude plan:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} export SQUADS_PLAN_TYPE=max   ${colors.dim}# $200/mo flat${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} export SQUADS_PLAN_TYPE=usage ${colors.dim}# pay-per-token${RESET}`);
+    writeLine();
+  } else {
+    const maxPlan = planType === "max";
+    const planIcon = maxPlan ? `${colors.purple}\u25C6${RESET}` : `${colors.dim}\u25CB${RESET}`;
+    const planLabel = maxPlan ? "Claude Max" : "Claude Pro";
+    const planCost = maxPlan ? "$200/mo flat" : "pay-per-token";
+    const tierDisplay = tier > 0 ? `  ${colors.dim}Tier ${tier}${RESET}` : "";
+    writeLine(`  ${planIcon} ${bold}${planLabel}${RESET} ${colors.dim}${planCost}${RESET}${tierDisplay}`);
+    writeLine();
+  }
+  if (!hasInfra || !hasData) {
+    writeLine(`  ${colors.dim}\u25CB${RESET} Track costs, tokens, and API usage`);
+    writeLine(`  ${colors.dim}\u25CB${RESET} Monitor rate limits and budgets`);
+    writeLine();
+    writeLine(`  ${colors.dim}Setup:${RESET} github.com/agents-squads/squads-cli#analytics`);
+    writeLine();
+    return;
+  }
+  const todayTokens = stats ? stats.today.inputTokens + stats.today.outputTokens : 0;
+  const todayCalls = stats?.today.generations || costs?.totalCalls || 0;
+  const todayCost = stats?.today.costUsd || costs?.totalCost || 0;
+  writeLine(`  ${colors.dim}Today${RESET}`);
+  writeLine(`  ${colors.cyan}${formatK(todayTokens)}${RESET} tokens  ${colors.dim}\u2502${RESET}  ${colors.cyan}${todayCalls}${RESET} calls  ${colors.dim}\u2502${RESET}  ${colors.green}$${todayCost.toFixed(2)}${RESET}`);
+  if (stats?.week && stats.week.generations > 0) {
+    const weekTokens = (stats.week.inputTokens || 0) + (stats.week.outputTokens || 0);
+    writeLine(`  ${colors.dim}Week${RESET}   ${colors.purple}${formatK(weekTokens)}${RESET} tokens  ${colors.dim}\u2502${RESET}  ${colors.purple}${stats.week.generations}${RESET} calls  ${colors.dim}\u2502${RESET}  ${colors.purple}$${stats.week.costUsd.toFixed(2)}${RESET}`);
+  }
+  writeLine();
+  if (goalCount && goalCount.completed > 0 && todayTokens > 0) {
+    const tokensPerGoal = Math.round(todayTokens / goalCount.completed);
+    writeLine(`  ${colors.dim}Efficiency${RESET}`);
+    writeLine(`  ${colors.cyan}${formatK(tokensPerGoal)}${RESET} tokens/goal  ${colors.dim}\u2502${RESET}  ${colors.green}${goalCount.completed}${RESET} goals done`);
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}Rate Limits${RESET} ${colors.dim}(check /usage for real limits)${RESET}`);
+  const tierLimits = {
+    1: { rpm: 50, inputTpm: 3e4, outputTpm: 8e3 },
+    2: { rpm: 1e3, inputTpm: 45e4, outputTpm: 9e4 },
+    3: { rpm: 2e3, inputTpm: 8e5, outputTpm: 16e4 },
+    4: { rpm: 4e3, inputTpm: 2e6, outputTpm: 4e5 }
+  };
+  const limits = tierLimits[tier] || tierLimits[4];
+  const now = /* @__PURE__ */ new Date();
+  const minutesElapsed = Math.max(now.getHours() * 60 + now.getMinutes(), 1);
+  const callsPerMinute = todayCalls / minutesElapsed;
+  const tokensPerMinute = todayTokens / minutesElapsed;
+  const rpmPct = callsPerMinute / limits.rpm * 100;
+  const tpmPct = tokensPerMinute / (limits.inputTpm + limits.outputTpm) * 100;
+  const rpmBar = progressBar(Math.min(rpmPct, 100), 10);
+  const tpmBar = progressBar(Math.min(tpmPct, 100), 10);
+  const rpmColor = rpmPct > 75 ? colors.red : rpmPct > 50 ? colors.yellow : colors.green;
+  const tpmColor = tpmPct > 75 ? colors.red : tpmPct > 50 ? colors.yellow : colors.green;
+  writeLine(`  RPM  ${rpmBar} ${rpmColor}${callsPerMinute.toFixed(1)}${RESET}${colors.dim}/${limits.rpm}${RESET}`);
+  writeLine(`  TPM  ${tpmBar} ${tpmColor}${formatK(Math.round(tokensPerMinute))}${RESET}${colors.dim}/${formatK(limits.inputTpm + limits.outputTpm)}${RESET}`);
+  const rpmAvailable = Math.max(0, limits.rpm - callsPerMinute);
+  const tpmAvailable = Math.max(0, limits.inputTpm + limits.outputTpm - tokensPerMinute);
+  if (rpmAvailable > 100 && tpmAvailable > 1e4) {
+    writeLine(`  ${colors.green}\u25CF${RESET} ${colors.dim}Capacity for autonomous triggers${RESET}`);
+  } else if (rpmPct > 75 || tpmPct > 75) {
+    writeLine(`  ${colors.yellow}\u26A0${RESET} ${colors.yellow}Rate limits constrained${RESET}`);
+  }
+  writeLine();
+}
+function renderQuotaCached(cache) {
+  const quota = cache.quotaInfo;
+  if (!quota || !quota.monthlyQuota || quota.monthlyQuota === 0) {
+    return;
+  }
+  const monthlyUsed = quota.monthlyUsed || 0;
+  const monthlyQuota = quota.monthlyQuota;
+  const roiMultiplier = monthlyUsed / monthlyQuota;
+  const roiDisplay = roiMultiplier >= 1 ? `${roiMultiplier.toFixed(1)}x` : `${(roiMultiplier * 100).toFixed(0)}%`;
+  const utilizationColor = roiMultiplier >= 2 ? colors.green : roiMultiplier >= 1 ? colors.cyan : roiMultiplier >= 0.5 ? colors.yellow : colors.dim;
+  const roiIcon = roiMultiplier >= 3 ? "\u{1F680}" : roiMultiplier >= 2 ? "\u{1F389}" : roiMultiplier >= 1 ? "\u2713" : "";
+  writeLine(`  ${bold}Subscription ROI${RESET} ${colors.dim}(autonomy: ${quota.autonomyScore}% ${quota.confidenceLevel})${RESET}`);
+  writeLine();
+  const barWidth = 24;
+  const fillPct = Math.min(roiMultiplier, 1);
+  const filled = Math.round(fillPct * barWidth);
+  const overflowIndicator = roiMultiplier > 1 ? `${utilizationColor}+${RESET}` : "";
+  const bar = `${utilizationColor}${"\u2588".repeat(filled)}${colors.dim}${"\u2591".repeat(barWidth - filled)}${RESET}${overflowIndicator}`;
+  writeLine(`  ${bar} ${utilizationColor}${roiDisplay}${RESET} ${roiIcon}`);
+  writeLine(`  ${colors.green}$${monthlyUsed.toFixed(2)}${RESET} ${colors.dim}consumed${RESET} ${colors.dim}/${RESET} $${monthlyQuota}${colors.dim}/mo subscription${RESET}`);
+  if (roiMultiplier >= 2) {
+    writeLine(`  ${colors.green}Excellent value${RESET} ${colors.dim}- ${roiDisplay} return on $${monthlyQuota} subscription${RESET}`);
+  } else if (roiMultiplier >= 1) {
+    writeLine(`  ${colors.cyan}Good utilization${RESET} ${colors.dim}- maximizing subscription value${RESET}`);
+  } else {
+    const potentialValue = monthlyQuota - monthlyUsed;
+    writeLine(`  ${colors.yellow}Room to grow${RESET} ${colors.dim}- $${potentialValue.toFixed(0)} of unused capacity${RESET}`);
+    writeLine(`  ${colors.dim}Tip: Run more routines with${RESET} ${colors.cyan}squads run <squad>${RESET}`);
+  }
+  if (quota.learningCount > 0) {
+    writeLine(`  ${colors.dim}Learnings:${RESET} ${colors.purple}${quota.learningCount}${RESET} ${colors.dim}captured${RESET}`);
+  }
+  writeLine();
+}
+function renderCapacityCached(cache) {
+  const cap = cache.capacity;
+  if (!cap) {
+    return;
+  }
+  const formatTokens = (n) => {
+    if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+    if (n >= 1e3) return `${(n / 1e3).toFixed(0)}k`;
+    return n.toString();
+  };
+  writeLine(`  ${bold}Subscription Capacity${RESET} ${colors.dim}(from Claude Code)${RESET}`);
+  writeLine();
+  const weeklyPct = cap.weeklyCapacityPct;
+  const weeklyColor = weeklyPct > 80 ? colors.red : weeklyPct > 60 ? colors.yellow : colors.green;
+  const weeklyBarWidth = 20;
+  const weeklyFilled = Math.min(Math.round(weeklyPct / 100 * weeklyBarWidth), weeklyBarWidth);
+  const weeklyBar = `${weeklyColor}${"\u2588".repeat(weeklyFilled)}${colors.dim}${"\u2591".repeat(weeklyBarWidth - weeklyFilled)}${RESET}`;
+  writeLine(`  ${colors.dim}Weekly:${RESET}  ${weeklyBar} ${weeklyColor}${weeklyPct}%${RESET} ${colors.dim}(resets ${cap.weeklyResetDate})${RESET}`);
+  writeLine(`           ${colors.dim}${formatTokens(cap.weeklyTokensUsed)} / ${formatTokens(cap.weeklyTokensLimit)} tokens${RESET}`);
+  const opusPct = cap.weeklyTokensUsed > 0 ? Math.round(cap.opusTokensUsed / cap.weeklyTokensUsed * 100) : 0;
+  const sonnetPct = cap.weeklyTokensUsed > 0 ? Math.round(cap.sonnetTokensUsed / cap.weeklyTokensUsed * 100) : 0;
+  writeLine(`           ${colors.dim}opus${RESET} ${colors.purple}${opusPct}%${RESET}  ${colors.dim}sonnet${RESET} ${colors.cyan}${sonnetPct}%${RESET}`);
+  if (cap.sessionCapacityPct > 10) {
+    const sessionPct = cap.sessionCapacityPct;
+    const sessionColor = sessionPct > 80 ? colors.red : sessionPct > 60 ? colors.yellow : colors.green;
+    writeLine(`  ${colors.dim}Session:${RESET} ${sessionColor}${sessionPct}%${RESET} ${colors.dim}(resets ${cap.sessionResetTime})${RESET}`);
+  }
+  const headroom = 100 - weeklyPct;
+  if (headroom > 50) {
+    writeLine(`  ${colors.green}\u25CF${RESET} ${colors.dim}${headroom}% headroom for autonomous agents${RESET}`);
+  } else if (headroom > 20) {
+    writeLine(`  ${colors.yellow}\u25CF${RESET} ${colors.dim}${headroom}% remaining - monitor usage${RESET}`);
+  } else {
+    writeLine(`  ${colors.red}\u25CF${RESET} ${colors.dim}Low capacity - consider Sonnet for routine tasks${RESET}`);
+  }
+  writeLine();
+}
+function renderInfrastructureCached(cache) {
+  const stats = cache.bridgeStats;
+  const hasInfra = hasLocalInfraConfig();
+  if (!hasInfra || !stats) {
+    writeLine(`  ${bold}Infrastructure${RESET} ${colors.dim}(not connected)${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}\u25CB${RESET} postgres  ${colors.dim}\u25CB${RESET} redis  ${colors.dim}\u25CB${RESET} otel`);
+    writeLine();
+    writeLine(`  ${colors.dim}Setup:${RESET} github.com/agents-squads/squads-cli#infrastructure`);
+    writeLine();
+    return;
+  }
+  writeLine(`  ${bold}Infrastructure${RESET} ${colors.dim}(${stats.source})${RESET}`);
+  writeLine();
+  const pgStatus = stats.health.postgres === "connected" ? `${colors.green}\u25CF${RESET}` : `${colors.red}\u25CF${RESET}`;
+  const redisStatus = stats.health.redis === "connected" ? `${colors.green}\u25CF${RESET}` : stats.health.redis === "disabled" ? `${colors.dim}\u25CB${RESET}` : `${colors.red}\u25CF${RESET}`;
+  const otelWorking = stats.health.postgres === "connected" && stats.today.generations > 0;
+  const otelStatus = otelWorking ? `${colors.green}\u25CF${RESET}` : `${colors.dim}\u25CB${RESET}`;
+  writeLine(`  ${pgStatus} postgres  ${redisStatus} redis  ${otelStatus} otel`);
+  writeLine();
+  if (stats.today.generations > 0 || stats.today.costUsd > 0) {
+    const maxPlan = isMaxPlan();
+    const costColor = maxPlan ? colors.green : stats.budget.usedPct > 80 ? colors.red : stats.budget.usedPct > 50 ? colors.yellow : colors.green;
+    const costDisplay = maxPlan ? `${costColor}$${stats.today.costUsd.toFixed(2)}${RESET}` : `${costColor}$${stats.today.costUsd.toFixed(2)}${RESET}${colors.dim}/$${stats.budget.daily}${RESET}`;
+    writeLine(`  ${colors.dim}Today:${RESET} ${colors.cyan}${stats.today.generations}${RESET}${colors.dim} calls${RESET}  ${costDisplay}  ${colors.dim}${formatK(stats.today.inputTokens)}+${formatK(stats.today.outputTokens)} tokens${RESET}`);
+    if (stats.byModel && stats.byModel.length > 0) {
+      const modelLine = stats.byModel.map((m) => {
+        const shortName = m.model.includes("opus") ? "opus" : m.model.includes("sonnet") ? "sonnet" : m.model.includes("haiku") ? "haiku" : m.model.slice(0, 10);
+        return `${colors.dim}${shortName}${RESET} ${colors.cyan}${m.generations}${RESET}`;
+      }).join("  ");
+      writeLine(`  ${colors.dim}Models:${RESET} ${modelLine}`);
+    }
+  }
+  if (stats.week && stats.week.generations > 0) {
+    const weekModelLine = stats.week.byModel?.map((m) => {
+      const shortName = m.model.includes("opus") ? "opus" : m.model.includes("sonnet") ? "sonnet" : m.model.includes("haiku") ? "haiku" : m.model.slice(0, 10);
+      return `${colors.dim}${shortName}${RESET} ${colors.purple}$${m.costUsd.toFixed(0)}${RESET}`;
+    }).join("  ") || "";
+    writeLine(`  ${colors.dim}Week:${RESET}  ${colors.cyan}${stats.week.generations}${RESET}${colors.dim} calls${RESET}  ${colors.purple}$${stats.week.costUsd.toFixed(2)}${RESET}  ${weekModelLine}`);
+  }
+  writeLine();
+}
+function renderAcquisitionCached(cache) {
+  const npmPackage = process.env.SQUADS_NPM_PACKAGE;
+  if (!npmPackage) {
+    return;
+  }
+  const npm = cache.npmStats;
+  if (!npm) {
+    return;
+  }
+  writeLine(`  ${bold}Acquisition${RESET} ${colors.dim}(npm)${RESET}`);
+  writeLine();
+  const trendIcon = npm.weekOverWeek >= 0 ? `${colors.green}\u2191${RESET}` : `${colors.red}\u2193${RESET}`;
+  const trendColor = npm.weekOverWeek >= 0 ? colors.green : colors.red;
+  writeLine(`  ${colors.cyan}${npm.downloads.lastWeek}${RESET} installs/week  ${trendIcon} ${trendColor}${Math.abs(npm.weekOverWeek)}%${RESET} ${colors.dim}wow${RESET}`);
+  writeLine(`  ${colors.dim}Today${RESET} ${npm.downloads.lastDay}  ${colors.dim}\u2502${RESET}  ${colors.dim}Month${RESET} ${npm.downloads.lastMonth}`);
+  writeLine();
+}
+async function saveSnapshotCached(squadData, cache, _baseDir) {
+  if (!cache.dbAvailable) return;
+  const { gitStats, ghStats, costs } = cache;
+  const squadsData = squadData.map((s) => ({
+    name: s.name,
+    commits: s.github?.commits || 0,
+    prsOpened: s.github?.prsOpened || 0,
+    prsMerged: s.github?.prsMerged || 0,
+    issuesClosed: s.github?.issuesClosed || 0,
+    issuesOpen: s.github?.issuesOpen || 0,
+    goalsActive: s.goals.filter((g) => !g.completed).length,
+    goalsTotal: s.goals.length,
+    progress: s.goalProgress
+  }));
+  const authorsData = gitStats ? Array.from(gitStats.commitsByAuthor.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, commits]) => ({ name, commits })) : [];
+  const reposData = gitStats ? Array.from(gitStats.commitsByRepo.entries()).sort((a, b) => b[1] - a[1]).map(([name, commits]) => ({ name, commits })) : [];
+  const totalInputTokens = costs?.bySquad.reduce((sum, s) => sum + s.inputTokens, 0) || 0;
+  const totalOutputTokens = costs?.bySquad.reduce((sum, s) => sum + s.outputTokens, 0) || 0;
+  const overallProgress = squadData.length > 0 ? Math.round(squadData.reduce((sum, s) => sum + s.goalProgress, 0) / squadData.length) : 0;
+  const snapshot = {
+    totalSquads: squadData.length,
+    totalCommits: gitStats?.totalCommits || 0,
+    totalPrsMerged: ghStats?.prsMerged || 0,
+    totalIssuesClosed: ghStats?.issuesClosed || 0,
+    totalIssuesOpen: ghStats?.issuesOpen || 0,
+    goalProgressPct: overallProgress,
+    costUsd: costs?.totalCost || 0,
+    dailyBudgetUsd: costs?.dailyBudget || 0,
+    // 0 = not configured (no hardcoded defaults)
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+    commits30d: gitStats?.totalCommits || 0,
+    avgCommitsPerDay: gitStats?.avgCommitsPerDay || 0,
+    activeDays: gitStats?.activeDays || 0,
+    peakCommits: gitStats?.peakDay?.count || 0,
+    peakDate: gitStats?.peakDay?.date || null,
+    squadsData,
+    authorsData,
+    reposData
+  };
+  const saveTimeout = new Promise((resolve) => setTimeout(resolve, 2e3));
+  await Promise.race([saveDashboardSnapshot(snapshot), saveTimeout]);
+}
+var TACTICAL_KEYWORDS = ["fix", "add", "update", "implement", "run", "test", "deploy", "merge", "review", "debug"];
+var STRATEGIC_KEYWORDS = ["revenue", "establish", "build", "create", "define", "design", "launch", "ship", "foundation", "strategy"];
+function inferScope(goal) {
+  const lower = goal.toLowerCase();
+  if (TACTICAL_KEYWORDS.some((k) => lower.includes(k))) return "tactical";
+  if (STRATEGIC_KEYWORDS.some((k) => lower.includes(k))) return "strategic";
+  return "operational";
+}
+function inferPriority(goal) {
+  const lower = goal.toLowerCase();
+  if (STRATEGIC_KEYWORDS.slice(0, 3).some((k) => lower.includes(k))) return "P0";
+  if (TACTICAL_KEYWORDS.slice(0, 4).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 goal of activeGoals) {
+      allGoals.push({
+        squad: name,
+        goal,
+        priority: inferPriority(goal.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 } of p0Goals.slice(0, 5)) {
+      writeLine(`  ${icons.error} ${colors.cyan}${squad}${RESET} ${goal.description}`);
+      if (goal.progress) {
+        writeLine(`    ${colors.dim}\u2514 ${goal.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 } of p1Goals.slice(0, 3)) {
+      writeLine(`  ${icons.warning} ${colors.cyan}${squad}${RESET} ${truncate(goal.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();
+}
+function renderHistoricalTrendsCached(cache) {
+  if (!cache.dbAvailable) return;
+  const history = cache.history;
+  if (history.length < 2) return;
+  writeLine(`  ${bold}Usage Trends${RESET} ${colors.dim}(${history.length}d history)${RESET}`);
+  writeLine();
+  const dailyCosts = history.map((h) => h.costUsd).reverse();
+  const costSparkStr = sparkline(dailyCosts);
+  const totalSpend = dailyCosts.reduce((sum, c) => sum + c, 0);
+  const avgDaily = totalSpend / dailyCosts.length;
+  writeLine(`  ${colors.dim}Cost:${RESET} ${costSparkStr}  ${colors.green}$${totalSpend.toFixed(2)}${RESET} total  ${colors.dim}($${avgDaily.toFixed(2)}/day avg)${RESET}`);
+  const inputTokens = history.map((h) => h.inputTokens).reverse();
+  const totalInput = inputTokens.reduce((sum, t) => sum + t, 0);
+  const tokenSparkStr = sparkline(inputTokens);
+  writeLine(`  ${colors.dim}Tokens:${RESET} ${tokenSparkStr}  ${colors.cyan}${formatK(totalInput)}${RESET} input  ${colors.dim}(${formatK(Math.round(totalInput / inputTokens.length))}/day)${RESET}`);
+  const goalProgress = history.map((h) => h.goalProgressPct).reverse();
+  const latestProgress = goalProgress[goalProgress.length - 1] || 0;
+  const earliestProgress = goalProgress[0] || 0;
+  const progressDelta = latestProgress - earliestProgress;
+  const progressColor = progressDelta > 0 ? colors.green : progressDelta < 0 ? colors.red : colors.dim;
+  const progressSign = progressDelta > 0 ? "+" : "";
+  writeLine(`  ${colors.dim}Goals:${RESET} ${sparkline(goalProgress)}  ${colors.purple}${latestProgress}%${RESET}  ${progressColor}${progressSign}${progressDelta.toFixed(0)}%${RESET}${colors.dim} vs start${RESET}`);
+  writeLine();
+}
+function renderInsightsCached(cache) {
+  const insights = cache.insights;
+  if (!insights || insights.source === "none" || insights.taskMetrics.length === 0) {
+    return;
+  }
+  writeLine(`  ${bold}Agent Insights${RESET} ${colors.dim}(${insights.days}d)${RESET}`);
+  writeLine();
+  const totals = insights.taskMetrics.reduce(
+    (acc, t) => ({
+      tasks: acc.tasks + t.tasksTotal,
+      completed: acc.completed + t.tasksCompleted,
+      failed: acc.failed + t.tasksFailed,
+      retries: acc.retries + t.totalRetries,
+      withRetries: acc.withRetries + t.tasksWithRetries
+    }),
+    { tasks: 0, completed: 0, failed: 0, retries: 0, withRetries: 0 }
+  );
+  if (totals.tasks > 0) {
+    const successRate = totals.tasks > 0 ? (totals.completed / totals.tasks * 100).toFixed(0) : "0";
+    const successColor = parseInt(successRate) >= 80 ? colors.green : parseInt(successRate) >= 60 ? colors.yellow : colors.red;
+    writeLine(`  ${colors.dim}Tasks:${RESET} ${colors.green}${totals.completed}${RESET}${colors.dim}/${totals.tasks} completed${RESET}  ${successColor}${successRate}%${RESET}${colors.dim} success${RESET}  ${colors.red}${totals.failed}${RESET}${colors.dim} failed${RESET}`);
+    if (totals.retries > 0) {
+      const retryRate = totals.tasks > 0 ? (totals.withRetries / totals.tasks * 100).toFixed(0) : "0";
+      const retryColor = parseInt(retryRate) > 30 ? colors.red : parseInt(retryRate) > 15 ? colors.yellow : colors.green;
+      writeLine(`  ${colors.dim}Retries:${RESET} ${retryColor}${totals.retries}${RESET}${colors.dim} total${RESET}  ${retryColor}${retryRate}%${RESET}${colors.dim} of tasks needed retry${RESET}`);
+    }
+  }
+  writeLine();
+}
+function renderROICached(cache, goalCount) {
+  const { costs, bridgeStats, baseline, squadProjections } = cache;
+  if (!costs && !bridgeStats) {
+    return;
+  }
+  const roiMetrics = calculateROIMetrics(
+    costs,
+    goalCount.completed,
+    cache.gitStats?.totalCommits || 0,
+    cache.ghStats?.prsMerged || 0
+  );
+  writeLine(`  ${bold}ROI & Projections${RESET}`);
+  writeLine();
+  if (roiMetrics.totalCostUsd > 0) {
+    const metricsLine = [];
+    if (roiMetrics.costPerGoal > 0) {
+      metricsLine.push(`${colors.cyan}$${roiMetrics.costPerGoal.toFixed(2)}${RESET}${colors.dim}/goal${RESET}`);
+    }
+    if (roiMetrics.costPerPR > 0) {
+      metricsLine.push(`${colors.cyan}$${roiMetrics.costPerPR.toFixed(2)}${RESET}${colors.dim}/PR${RESET}`);
+    }
+    if (roiMetrics.costPerCommit > 0) {
+      metricsLine.push(`${colors.cyan}$${roiMetrics.costPerCommit.toFixed(2)}${RESET}${colors.dim}/commit${RESET}`);
+    }
+    if (metricsLine.length > 0) {
+      writeLine(`  ${colors.dim}Cost/Output:${RESET} ${metricsLine.join(`  ${colors.dim}|${RESET}  `)}`);
+    }
+  }
+  if (roiMetrics.roiMultiplier > 0) {
+    const roiColor = roiMetrics.roiMultiplier >= 3 ? colors.green : roiMetrics.roiMultiplier >= 1 ? colors.cyan : colors.yellow;
+    writeLine(`  ${colors.dim}Est. ROI:${RESET}    ${roiColor}${roiMetrics.roiMultiplier.toFixed(1)}x${RESET} ${colors.dim}($${roiMetrics.estimatedValueUsd.toFixed(0)} value / $${roiMetrics.totalCostUsd.toFixed(2)} cost)${RESET}`);
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}Projections${RESET}`);
+  const dailyBudget = costs?.dailyBudget || 200;
+  const projColor = roiMetrics.dailyProjectedCost > dailyBudget ? colors.red : roiMetrics.dailyProjectedCost > dailyBudget * 0.8 ? colors.yellow : colors.green;
+  writeLine(`  ${colors.dim}Daily:${RESET}   ${projColor}~$${roiMetrics.dailyProjectedCost.toFixed(2)}${RESET}  ${colors.dim}Weekly:${RESET} ${colors.cyan}~$${roiMetrics.weeklyProjectedCost.toFixed(0)}${RESET}  ${colors.dim}Monthly:${RESET} ${colors.purple}~$${roiMetrics.monthlyProjectedCost.toFixed(0)}${RESET}`);
+  if (squadProjections.length > 0) {
+    writeLine();
+    writeLine(`  ${colors.dim}By Squad (projected monthly)${RESET}`);
+    const topSquads = squadProjections.sort((a, b) => b.projectedMonthlyCost - a.projectedMonthlyCost).slice(0, 4);
+    for (const sq of topSquads) {
+      const trendIcon = sq.costTrend === "increasing" ? `${colors.red}\u2191${RESET}` : sq.costTrend === "decreasing" ? `${colors.green}\u2193${RESET}` : `${colors.dim}-${RESET}`;
+      writeLine(`  ${colors.cyan}${padEnd(sq.squad, 14)}${RESET}${colors.dim}~$${sq.projectedMonthlyCost.toFixed(0)}/mo${RESET} ${trendIcon}`);
+    }
+  }
+  if (baseline) {
+    writeLine();
+    writeLine(`  ${colors.dim}vs Baseline${RESET} ${colors.dim}(${baseline.name})${RESET}`);
+    const costDelta = roiMetrics.totalCostUsd - baseline.costUsd;
+    const goalsDelta = goalCount.completed - baseline.goalsCompleted;
+    const costPerGoalBefore = baseline.goalsCompleted > 0 ? baseline.costUsd / baseline.goalsCompleted : 0;
+    const costPerGoalAfter = goalCount.completed > 0 ? roiMetrics.totalCostUsd / goalCount.completed : 0;
+    const efficiencyChange = costPerGoalBefore > 0 ? (costPerGoalBefore - costPerGoalAfter) / costPerGoalBefore * 100 : 0;
+    const costColor = costDelta > 0 ? colors.red : colors.green;
+    const goalsColor = goalsDelta >= 0 ? colors.green : colors.red;
+    const effColor = efficiencyChange > 0 ? colors.green : efficiencyChange < 0 ? colors.red : colors.dim;
+    writeLine(`  ${colors.dim}Cost:${RESET}  ${costColor}${costDelta >= 0 ? "+" : ""}$${costDelta.toFixed(2)}${RESET}  ${colors.dim}Goals:${RESET} ${goalsColor}${goalsDelta >= 0 ? "+" : ""}${goalsDelta}${RESET}  ${colors.dim}Efficiency:${RESET} ${effColor}${efficiencyChange >= 0 ? "+" : ""}${efficiencyChange.toFixed(0)}%${RESET}`);
+  } else {
+    writeLine();
+    writeLine(`  ${colors.dim}No baseline set. Capture one with:${RESET} squads baseline`);
+  }
+  writeLine();
+}
+export {
+  dashboardCommand
+};
+//# sourceMappingURL=dashboard-L7YKVQEB.js.map