squads-cli 0.2.0 → 0.4.0

package/dist/chunk-G63RBKDH.js

@@ -0,0 +1,980 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-7OCVIDC7.js";
+
+// src/lib/sessions.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, appendFileSync, createReadStream } from "fs";
+import { join, dirname } from "path";
+import { randomBytes } from "crypto";
+import { createInterface } from "readline";
+import { execSync } from "child_process";
+var AI_TOOL_PATTERNS = [
+  { pattern: /^claude$/, name: "claude" },
+  { pattern: /^cursor$/i, name: "cursor" },
+  { pattern: /^aider$/, name: "aider" },
+  { pattern: /^gemini$/i, name: "gemini" },
+  { pattern: /^copilot$/i, name: "copilot" },
+  { pattern: /^cody$/i, name: "cody" },
+  { pattern: /^continue$/i, name: "continue" }
+];
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var HISTORY_FILE = "history.jsonl";
+var ACTIVE_DIR = "active";
+var SQUAD_DIR_MAP = {
+  "hq": "company",
+  "agents-squads-web": "website",
+  "company": "company",
+  "product": "product",
+  "engineering": "engineering",
+  "research": "research",
+  "intelligence": "intelligence",
+  "customer": "customer",
+  "finance": "finance",
+  "marketing": "marketing"
+};
+function findAgentsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const agentsPath = join(dir, ".agents");
+    if (existsSync(agentsPath)) {
+      return agentsPath;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getSessionsBaseDir() {
+  const agentsDir = findAgentsDir();
+  if (!agentsDir) return null;
+  const sessionsDir = join(agentsDir, "sessions");
+  if (!existsSync(sessionsDir)) {
+    mkdirSync(sessionsDir, { recursive: true });
+  }
+  return sessionsDir;
+}
+function getSessionsDir() {
+  const baseDir = getSessionsBaseDir();
+  if (!baseDir) return null;
+  const activeDir = join(baseDir, ACTIVE_DIR);
+  if (!existsSync(activeDir)) {
+    mkdirSync(activeDir, { recursive: true });
+  }
+  return activeDir;
+}
+function getHistoryFilePath() {
+  const baseDir = getSessionsBaseDir();
+  if (!baseDir) return null;
+  return join(baseDir, HISTORY_FILE);
+}
+function appendEvent(event) {
+  const historyPath = getHistoryFilePath();
+  if (!historyPath) return;
+  try {
+    const line = JSON.stringify(event) + "\n";
+    appendFileSync(historyPath, line);
+  } catch {
+  }
+}
+function detectSquad(cwd = process.cwd()) {
+  const match = cwd.match(/agents-squads\/([^/]+)/);
+  if (match) {
+    const dir = match[1];
+    return SQUAD_DIR_MAP[dir] || dir;
+  }
+  return null;
+}
+function detectAIProcessesFast() {
+  const processes = [];
+  try {
+    const psOutput = execSync("ps -eo pid,tty,comm 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 2e3
+      // Reduced from 5s for faster CLI response
+    }).trim();
+    if (!psOutput) return [];
+    const lines = psOutput.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 3) continue;
+      const pid = parseInt(parts[0], 10);
+      const tty = parts[1];
+      const comm = parts.slice(2).join(" ");
+      if (isNaN(pid)) continue;
+      let toolName = null;
+      for (const { pattern, name } of AI_TOOL_PATTERNS) {
+        if (pattern.test(comm)) {
+          toolName = name;
+          break;
+        }
+      }
+      if (!toolName) continue;
+      processes.push({
+        pid,
+        tty,
+        cwd: "",
+        // No cwd in fast mode
+        squad: null,
+        // No squad detection in fast mode
+        tool: toolName
+      });
+    }
+  } catch {
+  }
+  return processes;
+}
+async function getProcessCwd(pid) {
+  return new Promise((resolve) => {
+    try {
+      const { exec } = __require("child_process");
+      exec(`lsof -p ${pid} 2>/dev/null | grep cwd | awk '{print $NF}'`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      }, (error, stdout) => {
+        resolve(error ? "" : stdout.trim());
+      });
+    } catch {
+      resolve("");
+    }
+  });
+}
+async function enrichProcessesWithSquad(processes) {
+  if (processes.length === 0) return processes;
+  const cwdPromises = processes.map((p) => getProcessCwd(p.pid));
+  const cwds = await Promise.all(cwdPromises);
+  return processes.map((proc, i) => ({
+    ...proc,
+    cwd: cwds[i],
+    squad: detectSquad(cwds[i])
+  }));
+}
+async function getLiveSessionSummaryAsync() {
+  const processes = detectAIProcessesFast();
+  const enrichedProcesses = await enrichProcessesWithSquad(processes);
+  const bySquad = {};
+  const byTool = {};
+  for (const proc of enrichedProcesses) {
+    const squad = proc.squad || "unknown";
+    bySquad[squad] = (bySquad[squad] || 0) + 1;
+    byTool[proc.tool] = (byTool[proc.tool] || 0) + 1;
+  }
+  return {
+    totalSessions: enrichedProcesses.length,
+    bySquad,
+    squadCount: Object.keys(bySquad).length,
+    byTool
+  };
+}
+function generateSessionId() {
+  return randomBytes(8).toString("hex");
+}
+var currentSessionId = null;
+function getSessionId() {
+  if (currentSessionId) return currentSessionId;
+  const sessionsDir = getSessionsDir();
+  if (sessionsDir) {
+    const pid = process.pid;
+    const files = readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(sessionsDir, file), "utf-8");
+        const session = JSON.parse(content);
+        if (session.pid === pid) {
+          currentSessionId = session.sessionId;
+          return currentSessionId;
+        }
+      } catch {
+      }
+    }
+  }
+  currentSessionId = generateSessionId();
+  return currentSessionId;
+}
+function startSession(squad) {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return null;
+  const sessionId = getSessionId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cwd = process.cwd();
+  const detectedSquad = squad || detectSquad(cwd);
+  const session = {
+    sessionId,
+    squad: detectedSquad,
+    startedAt: now,
+    lastHeartbeat: now,
+    cwd,
+    pid: process.pid
+  };
+  const sessionPath = join(sessionsDir, `${sessionId}.json`);
+  writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+  appendEvent({
+    type: "start",
+    sessionId,
+    squad: detectedSquad,
+    ts: now,
+    cwd,
+    pid: process.pid
+  });
+  return session;
+}
+function updateHeartbeat() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return false;
+  const sessionId = getSessionId();
+  const sessionPath = join(sessionsDir, `${sessionId}.json`);
+  if (!existsSync(sessionPath)) {
+    startSession();
+    return true;
+  }
+  try {
+    const content = readFileSync(sessionPath, "utf-8");
+    const session = JSON.parse(content);
+    session.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+    writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stopSession() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return false;
+  const sessionId = getSessionId();
+  const sessionPath = join(sessionsDir, `${sessionId}.json`);
+  if (existsSync(sessionPath)) {
+    let squad = null;
+    let durationMs;
+    try {
+      const content = readFileSync(sessionPath, "utf-8");
+      const session = JSON.parse(content);
+      squad = session.squad;
+      durationMs = Date.now() - new Date(session.startedAt).getTime();
+    } catch {
+    }
+    unlinkSync(sessionPath);
+    currentSessionId = null;
+    appendEvent({
+      type: "stop",
+      sessionId,
+      squad,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs
+    });
+    return true;
+  }
+  return false;
+}
+function getActiveSessions() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return [];
+  const now = Date.now();
+  const sessions = [];
+  try {
+    const files = readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join(sessionsDir, file);
+        const content = readFileSync(filePath, "utf-8");
+        const session = JSON.parse(content);
+        const lastHeartbeat = new Date(session.lastHeartbeat).getTime();
+        if (now - lastHeartbeat < STALE_THRESHOLD_MS) {
+          sessions.push(session);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return sessions;
+}
+function getSessionSummary() {
+  const sessions = getActiveSessions();
+  const bySquad = {};
+  for (const session of sessions) {
+    const squad = session.squad || "unknown";
+    bySquad[squad] = (bySquad[squad] || 0) + 1;
+  }
+  return {
+    totalSessions: sessions.length,
+    bySquad,
+    squadCount: Object.keys(bySquad).length
+  };
+}
+function cleanupStaleSessions() {
+  const sessionsDir = getSessionsDir();
+  if (!sessionsDir) return 0;
+  const now = Date.now();
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  let cleaned = 0;
+  try {
+    const files = readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join(sessionsDir, file);
+        const content = readFileSync(filePath, "utf-8");
+        const session = JSON.parse(content);
+        const lastHeartbeat = new Date(session.lastHeartbeat).getTime();
+        if (now - lastHeartbeat >= STALE_THRESHOLD_MS) {
+          const durationMs = now - new Date(session.startedAt).getTime();
+          unlinkSync(filePath);
+          cleaned++;
+          appendEvent({
+            type: "stale_cleanup",
+            sessionId: session.sessionId,
+            squad: session.squad,
+            ts: nowIso,
+            durationMs
+          });
+        }
+      } catch {
+        try {
+          unlinkSync(join(sessionsDir, file));
+          cleaned++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return cleaned;
+}
+async function readSessionHistory(options = {}) {
+  const historyPath = getHistoryFilePath();
+  if (!historyPath || !existsSync(historyPath)) return [];
+  const events = [];
+  const sinceMs = options.since?.getTime() || 0;
+  const untilMs = options.until?.getTime() || Date.now();
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: createReadStream(historyPath),
+      crlfDelay: Infinity
+    });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      try {
+        const event = JSON.parse(line);
+        const eventMs = new Date(event.ts).getTime();
+        if (eventMs < sinceMs || eventMs > untilMs) return;
+        if (options.squad && event.squad !== options.squad) return;
+        if (options.type && event.type !== options.type) return;
+        events.push(event);
+      } catch {
+      }
+    });
+    rl.on("close", () => {
+      if (options.limit && events.length > options.limit) {
+        resolve(events.slice(-options.limit));
+      } else {
+        resolve(events);
+      }
+    });
+    rl.on("error", () => {
+      resolve([]);
+    });
+  });
+}
+async function getSessionHistoryStats(options = {}) {
+  const events = await readSessionHistory(options);
+  const stats = {
+    totalSessions: 0,
+    totalDurationMs: 0,
+    avgDurationMs: 0,
+    bySquad: {},
+    byDate: {},
+    peakConcurrent: 0
+  };
+  const activeSessions = /* @__PURE__ */ new Map();
+  let currentConcurrent = 0;
+  for (const event of events) {
+    const squad = event.squad || "unknown";
+    const date = event.ts.split("T")[0];
+    if (event.type === "start") {
+      stats.totalSessions++;
+      stats.byDate[date] = (stats.byDate[date] || 0) + 1;
+      if (!stats.bySquad[squad]) {
+        stats.bySquad[squad] = { count: 0, durationMs: 0 };
+      }
+      stats.bySquad[squad].count++;
+      activeSessions.set(event.sessionId, {
+        squad: event.squad,
+        startTs: new Date(event.ts).getTime()
+      });
+      currentConcurrent++;
+      stats.peakConcurrent = Math.max(stats.peakConcurrent, currentConcurrent);
+    }
+    if (event.type === "stop" || event.type === "stale_cleanup") {
+      const duration = event.durationMs || 0;
+      stats.totalDurationMs += duration;
+      if (stats.bySquad[squad]) {
+        stats.bySquad[squad].durationMs += duration;
+      }
+      if (activeSessions.has(event.sessionId)) {
+        activeSessions.delete(event.sessionId);
+        currentConcurrent = Math.max(0, currentConcurrent - 1);
+      }
+    }
+  }
+  const completedSessions = events.filter((e) => e.type === "stop" || e.type === "stale_cleanup").length;
+  if (completedSessions > 0) {
+    stats.avgDurationMs = Math.round(stats.totalDurationMs / completedSessions);
+  }
+  return stats;
+}
+async function getRecentSessions(limit = 20) {
+  const events = await readSessionHistory({ limit: limit * 3 });
+  const sessionEvents = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!sessionEvents.has(event.sessionId)) {
+      sessionEvents.set(event.sessionId, []);
+    }
+    sessionEvents.get(event.sessionId).push(event);
+  }
+  const startEvents = events.filter((e) => e.type === "start").slice(-limit);
+  return startEvents.reverse();
+}
+
+// src/lib/terminal.ts
+var ESC = "\x1B[";
+var RESET = `${ESC}0m`;
+function supportsTrueColor() {
+  const colorterm = process.env.COLORTERM;
+  if (colorterm === "truecolor" || colorterm === "24bit") return true;
+  const term = process.env.TERM || "";
+  if (term.includes("256color") || term.includes("truecolor")) return true;
+  if (process.env.TERM_PROGRAM === "iTerm.app") return true;
+  if (process.env.TERM_PROGRAM === "vscode") return true;
+  if (process.env.WT_SESSION) return true;
+  return false;
+}
+var USE_TRUE_COLOR = supportsTrueColor();
+var rgb = (r, g, b) => `${ESC}38;2;${r};${g};${b}m`;
+var ansi = {
+  purple: `${ESC}35m`,
+  // magenta
+  pink: `${ESC}95m`,
+  // bright magenta
+  cyan: `${ESC}36m`,
+  // cyan
+  green: `${ESC}32m`,
+  // green
+  yellow: `${ESC}33m`,
+  // yellow
+  red: `${ESC}31m`,
+  // red
+  gray: `${ESC}90m`,
+  // bright black (gray)
+  dim: `${ESC}90m`,
+  // bright black (gray)
+  white: `${ESC}97m`
+  // bright white
+};
+var colors = USE_TRUE_COLOR ? {
+  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)
+} : ansi;
+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 clampedPercent = Math.max(0, Math.min(100, percent || 0));
+  const filled = Math.round(clampedPercent / 100 * width);
+  const empty = Math.max(0, 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 stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function isColorEnabled() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.FORCE_COLOR !== void 0) return true;
+  if (process.env.CLAUDECODE !== void 0) return true;
+  return process.stdout.isTTY ?? false;
+}
+function writeLine(str = "") {
+  const output = isColorEnabled() ? str : stripAnsi(str);
+  process.stdout.write(output + "\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);
+    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 safeValue = Math.max(0, value || 0);
+  const safeMax = Math.max(1, max || 1);
+  const ratio = Math.min(1, safeValue / safeMax);
+  const filled = Math.round(ratio * 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/sessions.ts
+async function sessionsCommand(options = {}) {
+  cleanupStaleSessions();
+  const sessions = getActiveSessions();
+  const summary = getSessionSummary();
+  if (options.json) {
+    console.log(JSON.stringify({ sessions, summary }, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sessions${RESET}`);
+  writeLine();
+  if (sessions.length === 0) {
+    writeLine(`  ${colors.dim}No active sessions${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Sessions are tracked automatically when Claude Code runs.${RESET}`);
+    writeLine(`  ${colors.dim}Each session updates its heartbeat via squads CLI commands.${RESET}`);
+    writeLine();
+    return;
+  }
+  const squadText = summary.squadCount === 1 ? "squad" : "squads";
+  const sessionText = summary.totalSessions === 1 ? "session" : "sessions";
+  writeLine(`  ${colors.green}${summary.totalSessions}${RESET} active ${sessionText} ${colors.dim}across${RESET} ${colors.cyan}${summary.squadCount}${RESET} ${squadText}`);
+  writeLine();
+  const bySquad = {};
+  for (const session of sessions) {
+    const squad = session.squad || "unknown";
+    if (!bySquad[squad]) bySquad[squad] = [];
+    bySquad[squad].push(session);
+  }
+  const w = { squad: 16, sessions: 10, activity: 14 };
+  const tableWidth = w.squad + w.sessions + w.activity + 4;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("SESSIONS", w.sessions)}${RESET}${bold}LAST ACTIVITY${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const [squad, squadSessions] of Object.entries(bySquad).sort()) {
+    let mostRecent = 0;
+    for (const session of squadSessions) {
+      const ts = new Date(session.lastHeartbeat).getTime();
+      if (ts > mostRecent) mostRecent = ts;
+    }
+    const lastActivity = formatTimeAgo(mostRecent);
+    const activityColor = getActivityColor(mostRecent);
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(String(squadSessions.length), w.sessions)}${padEnd(`${activityColor}${lastActivity}${RESET}`, w.activity)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  if (options.verbose) {
+    writeLine();
+    writeLine(`  ${bold}Session Details${RESET}`);
+    writeLine();
+    for (const session of sessions) {
+      const squad = session.squad || "unknown";
+      const ago = formatTimeAgo(new Date(session.lastHeartbeat).getTime());
+      writeLine(`  ${icons.active} ${colors.white}${session.sessionId}${RESET}`);
+      writeLine(`    ${colors.dim}squad: ${squad} | pid: ${session.pid} | heartbeat: ${ago}${RESET}`);
+      writeLine(`    ${colors.dim}cwd: ${session.cwd}${RESET}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads sessions -v    ${colors.dim}Show session details${RESET}`);
+  writeLine();
+}
+function formatTimeAgo(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  if (minutes >= 1) {
+    return `${minutes}m ago`;
+  }
+  return `${seconds}s ago`;
+}
+function getActivityColor(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minutes = Math.floor(diff / (1e3 * 60));
+  if (minutes < 1) return colors.green;
+  if (minutes < 3) return colors.yellow;
+  return colors.dim;
+}
+async function sessionsSummaryCommand(data, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}session summary${RESET}`);
+  writeLine();
+  if (data.squads.length > 0) {
+    const w = { squad: 14, actions: 26, outputs: 36 };
+    const tableWidth = w.squad + w.actions + w.outputs + 6;
+    const truncate2 = (text, max) => text.length > max ? text.substring(0, max - 1) + "\u2026" : text;
+    writeLine(`  ${colors.green}${icons.active}${RESET} ${bold}${data.squads.length} Squads Active${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("ACTIONS", w.actions)}${RESET}${bold}${padEnd("KEY OUTPUTS", w.outputs)}${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 data.squads) {
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(truncate2(squad.name, w.squad - 1), w.squad)}${RESET}${padEnd(truncate2(squad.actions, w.actions - 1), w.actions)}${padEnd(truncate2(squad.outputs, w.outputs - 1), w.outputs)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  }
+  if (data.decisions && data.decisions.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Strategic Decisions${RESET}`);
+    writeLine();
+    const w = { question: 16, answer: 50 };
+    const tableWidth = w.question + w.answer + 4;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    for (const decision of data.decisions) {
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.yellow}${padEnd(decision.question, w.question)}${RESET}${padEnd(decision.answer, w.answer)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  }
+  if (data.customer) {
+    writeLine();
+    writeLine(`  ${bold}Target Customer${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Vertical:${RESET} ${colors.cyan}${data.customer.vertical}${RESET}`);
+    writeLine(`  ${colors.dim}Persona:${RESET}  ${colors.white}${data.customer.persona}${RESET}`);
+    writeLine(`  ${colors.dim}Pain:${RESET}     ${data.customer.painPoints.join(", ")}`);
+  }
+  if (data.nextActions && data.nextActions.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Next Actions${RESET}`);
+    writeLine();
+    for (const action of data.nextActions) {
+      writeLine(`  ${colors.cyan}${padEnd(action.squad, 14)}${RESET}${colors.dim}\u2192${RESET} ${action.action}`);
+    }
+  }
+  if (data.targets && data.targets.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Q1 Targets${RESET}`);
+    writeLine();
+    for (const target of data.targets) {
+      writeLine(`  ${colors.dim}\u2022${RESET} ${target.metric}: ${colors.green}${target.value}${RESET}`);
+    }
+  }
+  if (data.filesUpdated && data.filesUpdated.length > 0) {
+    writeLine();
+    writeLine(`  ${colors.dim}Files updated:${RESET}`);
+    for (const file of data.filesUpdated) {
+      writeLine(`  ${colors.dim}  \u2022${RESET} ${colors.cyan}${file}${RESET}`);
+    }
+  }
+  writeLine();
+  const modelText = data.model ? data.model : "Claude";
+  const durationText = data.duration ? ` ${colors.dim}(${data.duration})${RESET}` : "";
+  writeLine(`  ${colors.dim}Generated by${RESET} ${colors.purple}${modelText}${RESET}${durationText}`);
+  writeLine();
+}
+async function buildCurrentSessionSummary() {
+  const { existsSync: existsSync2, readdirSync: readdirSync2, statSync, readFileSync: readFileSync2 } = await import("fs");
+  const { join: join2 } = await import("path");
+  const { findMemoryDir } = await import("./memory-4PVUKIDK.js");
+  const memoryDir = findMemoryDir();
+  const squads = [];
+  const filesUpdated = [];
+  const sessionWindow = 2 * 60 * 60 * 1e3;
+  const now = Date.now();
+  if (memoryDir && existsSync2(memoryDir)) {
+    const squadDirs = readdirSync2(memoryDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const squadDir of squadDirs) {
+      const squadPath = join2(memoryDir, squadDir.name);
+      let squadModified = false;
+      let stateContent = "";
+      let executionContent = "";
+      try {
+        const agentDirs = readdirSync2(squadPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+        for (const agentDir of agentDirs) {
+          const agentPath = join2(squadPath, agentDir.name);
+          const files = readdirSync2(agentPath).filter((f) => f.endsWith(".md"));
+          for (const file of files) {
+            const filePath = join2(agentPath, file);
+            const stats = statSync(filePath);
+            if (now - stats.mtimeMs < sessionWindow) {
+              squadModified = true;
+              const relativePath = `${squadDir.name}/${agentDir.name}/${file}`;
+              filesUpdated.push(relativePath);
+              if (file === "state.md") {
+                stateContent = readFileSync2(filePath, "utf-8");
+              } else if (file === "executions.md") {
+                executionContent = readFileSync2(filePath, "utf-8");
+              }
+            }
+          }
+        }
+        if (squadModified) {
+          let actions = "State updated";
+          let outputs = "Memory refreshed";
+          if (executionContent) {
+            const lines = executionContent.split("\n").filter((l) => l.trim());
+            const recentEntry = lines.slice(-10).join(" ");
+            if (recentEntry.includes("completed")) {
+              actions = "Execution completed";
+            }
+            const keyMatch = recentEntry.match(/Key (?:findings|decisions|outputs)?:?\s*([^.]+)/i);
+            if (keyMatch) {
+              outputs = keyMatch[1].substring(0, 50);
+            }
+          }
+          if (stateContent) {
+            const updatedMatch = stateContent.match(/Updated:\s*([^\n]+)/);
+            if (updatedMatch) {
+              actions = `Updated ${updatedMatch[1]}`;
+            }
+          }
+          squads.push({
+            name: squadDir.name.charAt(0).toUpperCase() + squadDir.name.slice(1),
+            actions,
+            outputs: outputs.length > 44 ? outputs.substring(0, 41) + "..." : outputs
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  if (squads.length === 0) {
+    squads.push({
+      name: "No recent activity",
+      actions: "\u2014",
+      outputs: "Run squads to see activity here"
+    });
+  }
+  return {
+    squads,
+    filesUpdated: filesUpdated.length > 0 ? filesUpdated : void 0,
+    model: process.env.ANTHROPIC_MODEL || "Claude"
+  };
+}
+async function sessionsHistoryCommand(options = {}) {
+  const days = options.days || 7;
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+  const stats = await getSessionHistoryStats({
+    since,
+    squad: options.squad
+  });
+  const recentSessions = await getRecentSessions(10);
+  if (options.json) {
+    console.log(JSON.stringify({ stats, recentSessions }, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}sessions history${RESET} ${colors.dim}(${days}d)${RESET}`);
+  writeLine();
+  if (stats.totalSessions === 0) {
+    writeLine(`  ${colors.dim}No session history found${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Session events are logged to .agents/sessions/history.jsonl${RESET}`);
+    writeLine();
+    return;
+  }
+  const avgMinutes = Math.round(stats.avgDurationMs / 6e4);
+  const totalHours = Math.round(stats.totalDurationMs / 36e5 * 10) / 10;
+  writeLine(`  ${bold}Summary${RESET}`);
+  writeLine(`  ${colors.cyan}${stats.totalSessions}${RESET} sessions  ${colors.dim}\u2502${RESET}  ${colors.green}${totalHours}h${RESET} total  ${colors.dim}\u2502${RESET}  ${colors.yellow}${avgMinutes}m${RESET} avg  ${colors.dim}\u2502${RESET}  ${colors.purple}${stats.peakConcurrent}${RESET} peak`);
+  writeLine();
+  const squads = Object.entries(stats.bySquad).sort((a, b) => b[1].count - a[1].count);
+  if (squads.length > 0) {
+    const w = { squad: 16, sessions: 10, duration: 12 };
+    const tableWidth = w.squad + w.sessions + w.duration + 4;
+    writeLine(`  ${bold}By Squad${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.squad)}${RESET}${bold}${padEnd("SESSIONS", w.sessions)}${RESET}${bold}DURATION${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(header);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const [squad, data] of squads) {
+      const hours = Math.round(data.durationMs / 36e5 * 10) / 10;
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(squad, w.squad)}${RESET}${padEnd(String(data.count), w.sessions)}${padEnd(`${hours}h`, w.duration)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  }
+  if (recentSessions.length > 0) {
+    writeLine();
+    writeLine(`  ${bold}Recent Sessions${RESET}`);
+    writeLine();
+    for (const event of recentSessions.slice(0, 5)) {
+      const squad = event.squad || "unknown";
+      const date = new Date(event.ts);
+      const timeStr = date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+      const dateStr = date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+      writeLine(`  ${colors.dim}${dateStr} ${timeStr}${RESET}  ${colors.cyan}${squad}${RESET}  ${colors.dim}${event.sessionId.slice(0, 8)}${RESET}`);
+    }
+  }
+  const dates = Object.entries(stats.byDate).sort((a, b) => b[0].localeCompare(a[0])).slice(0, 7);
+  if (dates.length > 1) {
+    writeLine();
+    writeLine(`  ${bold}Daily Activity${RESET}`);
+    writeLine();
+    for (const [date, count] of dates) {
+      const bar = "\u2588".repeat(Math.min(count, 20));
+      writeLine(`  ${colors.dim}${date}${RESET}  ${colors.green}${bar}${RESET} ${count}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads sessions history --days 30   ${colors.dim}Longer history${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads sessions history -s website  ${colors.dim}Filter by squad${RESET}`);
+  writeLine();
+}
+
+export {
+  RESET,
+  colors,
+  bold,
+  gradient,
+  progressBar,
+  box,
+  padEnd,
+  truncate,
+  icons,
+  writeLine,
+  sparkline,
+  barChart,
+  detectSquad,
+  getLiveSessionSummaryAsync,
+  startSession,
+  updateHeartbeat,
+  stopSession,
+  cleanupStaleSessions,
+  sessionsCommand,
+  sessionsSummaryCommand,
+  buildCurrentSessionSummary,
+  sessionsHistoryCommand
+};
+//# sourceMappingURL=chunk-G63RBKDH.js.map