squads-cli 0.4.8 → 0.4.9

package/dist/cli.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+import {
+  autoUpdateOnStartup,
+  checkForUpdate,
+  performUpdate,
+  refreshVersionCache
+} from "./chunk-HKWCBCEK.js";
 import {
   appendToMemory,
   findMemoryDir,
@@ -6,38 +12,40 @@ import {
   listMemoryEntries,
   searchMemory
 } from "./chunk-FUHBEL3L.js";
+import {
+  cleanupStaleSessions,
+  detectSquad,
+  getLiveSessionSummaryAsync,
+  sessionsCommand,
+  sessionsHistoryCommand,
+  sessionsSummaryCommand,
+  startSession,
+  stopSession,
+  updateHeartbeat
+} from "./chunk-HIQ2APYR.js";
 import {
   RESET,
   barChart,
   bold,
   box,
-  cleanupStaleSessions,
   colors,
-  detectSquad,
-  getLiveSessionSummaryAsync,
   gradient,
   icons,
   padEnd,
   progressBar,
-  sessionsCommand,
-  sessionsHistoryCommand,
-  sessionsSummaryCommand,
   sparkline,
-  startSession,
-  stopSession,
   truncate,
-  updateHeartbeat,
   writeLine
-} from "./chunk-IDZYXBZY.js";
+} from "./chunk-NA3IECJA.js";
 import {
   __require
 } from "./chunk-7OCVIDC7.js";
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync19 } from "fs";
-import { join as join21 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync18 } from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir4 } from "os";
 import { Command } from "commander";
 import chalk4 from "chalk";
 
@@ -47,227 +55,18 @@ var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var version = pkg.version;
 
-// src/lib/update.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { execSync } from "child_process";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const __filename3 = fileURLToPath(import.meta.url);
-    const __dirname3 = dirname(__filename3);
-    const possiblePaths = [
-      join(__dirname3, "..", "..", "package.json"),
-      // From dist/lib/
-      join(__dirname3, "..", "package.json"),
-      // From dist/
-      join(__dirname3, "package.json")
-      // Same dir
-    ];
-    for (const pkgPath of possiblePaths) {
-      if (existsSync(pkgPath)) {
-        const pkg2 = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        return pkg2.version || "0.0.0";
-      }
-    }
-  } catch {
-  }
-  return "0.0.0";
-}
-var CURRENT_VERSION = getPackageVersion();
-var CACHE_DIR = join(homedir(), ".squads");
-var CACHE_FILE = join(CACHE_DIR, "update-check.json");
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-function isNewerVersion(v1, v2) {
-  const parts1 = v1.replace(/^v/, "").split(".").map(Number);
-  const parts2 = v2.replace(/^v/, "").split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const p1 = parts1[i] || 0;
-    const p2 = parts2[i] || 0;
-    if (p2 > p1) return true;
-    if (p2 < p1) return false;
-  }
-  return false;
-}
-function readCache() {
-  try {
-    if (!existsSync(CACHE_FILE)) return null;
-    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
-    return data;
-  } catch {
-    return null;
-  }
-}
-function writeCache(latestVersion) {
-  try {
-    if (!existsSync(CACHE_DIR)) {
-      mkdirSync(CACHE_DIR, { recursive: true });
-    }
-    const cache = {
-      latestVersion,
-      checkedAt: Date.now()
-    };
-    writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-function fetchLatestVersion() {
-  try {
-    const result = execSync("npm view squads-cli version 2>/dev/null", {
-      encoding: "utf-8",
-      timeout: 5e3
-    }).trim();
-    return result || null;
-  } catch {
-    return null;
-  }
-}
-function checkForUpdate() {
-  const result = {
-    currentVersion: CURRENT_VERSION,
-    latestVersion: CURRENT_VERSION,
-    updateAvailable: false
-  };
-  const cache = readCache();
-  const now = Date.now();
-  if (cache) {
-    result.latestVersion = cache.latestVersion;
-    result.updateAvailable = isNewerVersion(CURRENT_VERSION, cache.latestVersion);
-    if (now - cache.checkedAt >= CACHE_TTL_MS) {
-      triggerBackgroundRefresh();
-    }
-    return result;
-  }
-  triggerBackgroundRefresh();
-  return result;
-}
-function triggerBackgroundRefresh() {
-  try {
-    const { spawn: spawn8 } = __require("child_process");
-    const child = spawn8("npm", ["view", "squads-cli", "version"], {
-      detached: true,
-      stdio: ["ignore", "pipe", "ignore"],
-      shell: true
-    });
-    let output = "";
-    child.stdout?.on("data", (data) => {
-      output += data.toString();
-    });
-    child.on("close", () => {
-      const version2 = output.trim();
-      if (version2 && /^\d+\.\d+\.\d+/.test(version2)) {
-        writeCache(version2);
-      }
-    });
-    child.unref();
-  } catch {
-  }
-}
-function performUpdate() {
-  try {
-    execSync("npm update -g squads-cli", {
-      encoding: "utf-8",
-      stdio: "inherit",
-      timeout: 12e4
-      // 2 minutes
-    });
-    try {
-      unlinkSync(CACHE_FILE);
-    } catch {
-    }
-    return { success: true };
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : "Unknown error"
-    };
-  }
-}
-function refreshVersionCache() {
-  const latestVersion = fetchLatestVersion();
-  if (latestVersion) {
-    writeCache(latestVersion);
-    return {
-      currentVersion: CURRENT_VERSION,
-      latestVersion,
-      updateAvailable: isNewerVersion(CURRENT_VERSION, latestVersion)
-    };
-  }
-  return checkForUpdate();
-}
-var AUTO_UPDATE_CACHE_FILE = join(CACHE_DIR, "auto-update.json");
-var AUTO_UPDATE_COOLDOWN_MS = 60 * 60 * 1e3;
-function readAutoUpdateCache() {
-  try {
-    if (!existsSync(AUTO_UPDATE_CACHE_FILE)) return null;
-    return JSON.parse(readFileSync(AUTO_UPDATE_CACHE_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeAutoUpdateCache(cache) {
-  try {
-    if (!existsSync(CACHE_DIR)) {
-      mkdirSync(CACHE_DIR, { recursive: true });
-    }
-    writeFileSync(AUTO_UPDATE_CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-async function autoUpdateOnStartup(silent = false) {
-  if (process.env.CI || process.env.SQUADS_NO_AUTO_UPDATE) return;
-  const autoCache = readAutoUpdateCache();
-  const now = Date.now();
-  if (autoCache && now - autoCache.lastAttempt < AUTO_UPDATE_COOLDOWN_MS) {
-    return;
-  }
-  const info = checkForUpdate();
-  if (!info.updateAvailable) return;
-  writeAutoUpdateCache({ lastAttempt: now, lastSuccess: autoCache?.lastSuccess });
-  try {
-    const { spawn: spawn8 } = await import("child_process");
-    const child = spawn8("npm", ["update", "-g", "squads-cli"], {
-      detached: true,
-      stdio: silent ? "ignore" : ["ignore", "pipe", "pipe"],
-      shell: true
-    });
-    if (!silent && child.stdout) {
-      await new Promise((resolve) => {
-        child.on("close", (code) => {
-          if (code === 0) {
-            console.log(`
-  \x1B[32m\u2713\x1B[0m Update successful! v${info.latestVersion} will be used on your next run.
-`);
-            writeAutoUpdateCache({ lastAttempt: now, lastSuccess: now });
-            try {
-              unlinkSync(CACHE_FILE);
-            } catch {
-            }
-          }
-          resolve();
-        });
-        setTimeout(() => resolve(), 3e4);
-      });
-    } else {
-      child.unref();
-    }
-  } catch {
-  }
-}
-
 // src/commands/init.ts
 import chalk from "chalk";
 import ora from "ora";
 import fs from "fs/promises";
 import path from "path";
-import { execSync as execSync3, spawn } from "child_process";
+import { execSync as execSync2, spawn } from "child_process";
 import { createInterface } from "readline";
 
 // src/lib/git.ts
-import { execSync as execSync2, exec } from "child_process";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { execSync, exec } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 function checkGitStatus(cwd = process.cwd()) {
@@ -277,12 +76,12 @@ function checkGitStatus(cwd = process.cwd()) {
     isDirty: false,
     uncommittedCount: 0
   };
-  if (!existsSync2(join2(cwd, ".git"))) {
+  if (!existsSync(join(cwd, ".git"))) {
     return status;
   }
   status.isGitRepo = true;
   try {
-    const combined = execSync2(
+    const combined = execSync(
       'echo "BRANCH:" && git rev-parse --abbrev-ref HEAD && echo "REMOTES:" && git remote -v && echo "STATUS:" && git status --porcelain',
       { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
     );
@@ -366,10 +165,10 @@ function getGitHubStatsOptimized(basePath, days = 30) {
   const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
   const results = [];
   for (const repo of repos) {
-    const repoPath = join2(basePath, repo);
-    if (!existsSync2(repoPath)) continue;
+    const repoPath = join(basePath, repo);
+    if (!existsSync(repoPath)) continue;
     try {
-      const output = execSync2(
+      const output = execSync(
         `echo '{"prs":' && gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 50 2>/dev/null && echo ',"issues":' && gh issue list --state all --json number,title,state,closedAt,labels --limit 50 2>/dev/null && echo '}'`,
         { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 1e4 }
       );
@@ -380,11 +179,11 @@ function getGitHubStatsOptimized(basePath, days = 30) {
       results.push({ repo, prs, issues });
     } catch {
       try {
-        const prsOutput = execSync2(
+        const prsOutput = execSync(
           `gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 50 2>/dev/null`,
           { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
         );
-        const issuesOutput = execSync2(
+        const issuesOutput = execSync(
           `gh issue list --state all --json number,title,state,closedAt,labels --limit 50 2>/dev/null`,
           { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
         );
@@ -500,12 +299,12 @@ function getMultiRepoGitStats(basePath, days = 30) {
   };
   const allCommits = [];
   for (const repo of SQUAD_REPOS) {
-    const repoPath = join2(basePath, repo);
-    if (!existsSync2(repoPath) || !existsSync2(join2(repoPath, ".git"))) {
+    const repoPath = join(basePath, repo);
+    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
       continue;
     }
     try {
-      const logOutput = execSync2(
+      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();
@@ -562,12 +361,12 @@ function getActivitySparkline(basePath, days = 7) {
     activity.push(0);
   }
   for (const repo of SQUAD_REPOS) {
-    const repoPath = join2(basePath, repo);
-    if (!existsSync2(repoPath) || !existsSync2(join2(repoPath, ".git"))) {
+    const repoPath = join(basePath, repo);
+    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
       continue;
     }
     try {
-      const logOutput = execSync2(
+      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();
@@ -587,13 +386,13 @@ function getActivitySparkline(basePath, days = 7) {
 }
 
 // src/lib/telemetry.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+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 = join3(homedir2(), ".squads-cli");
-var CONFIG_PATH = join3(TELEMETRY_DIR, "telemetry.json");
-var EVENTS_PATH = join3(TELEMETRY_DIR, "events.json");
+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 = Buffer.from(
   "aHR0cHM6Ly9zcXVhZHMtdGVsZW1ldHJ5LTk3ODg3MTgxNzYxMC51cy1jZW50cmFsMS5ydW4uYXBwL3Bpbmc=",
   "base64"
@@ -602,24 +401,24 @@ var TELEMETRY_KEY = Buffer.from("c3FfdGVsX3YxXzdmOGE5YjJjM2Q0ZTVmNmE=", "base64"
 var eventQueue = [];
 var flushScheduled = false;
 function ensureDir() {
-  if (!existsSync3(TELEMETRY_DIR)) {
-    mkdirSync2(TELEMETRY_DIR, { recursive: true });
+  if (!existsSync2(TELEMETRY_DIR)) {
+    mkdirSync(TELEMETRY_DIR, { recursive: true });
   }
 }
 function getConfig() {
   ensureDir();
-  if (!existsSync3(CONFIG_PATH)) {
+  if (!existsSync2(CONFIG_PATH)) {
     const config2 = {
       enabled: true,
       // Opt-out by default (common for CLIs)
       anonymousId: randomUUID(),
       firstRun: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync2(CONFIG_PATH, JSON.stringify(config2, null, 2));
+    writeFileSync(CONFIG_PATH, JSON.stringify(config2, null, 2));
     return config2;
   }
   try {
-    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return { enabled: false, anonymousId: "", firstRun: "" };
   }
@@ -679,9 +478,9 @@ async function flushEvents() {
 function storeEventLocally(event) {
   ensureDir();
   let events = [];
-  if (existsSync3(EVENTS_PATH)) {
+  if (existsSync2(EVENTS_PATH)) {
     try {
-      events = JSON.parse(readFileSync2(EVENTS_PATH, "utf-8"));
+      events = JSON.parse(readFileSync(EVENTS_PATH, "utf-8"));
     } catch {
       events = [];
     }
@@ -690,7 +489,7 @@ function storeEventLocally(event) {
   if (events.length > 1e3) {
     events = events.slice(-1e3);
   }
-  writeFileSync2(EVENTS_PATH, JSON.stringify(events, null, 2));
+  writeFileSync(EVENTS_PATH, JSON.stringify(events, null, 2));
 }
 var Events = {
   // Lifecycle
@@ -787,7 +586,7 @@ async function promptEmail() {
 }
 function commandExists(cmd) {
   try {
-    execSync3(`which ${cmd}`, { stdio: "ignore" });
+    execSync2(`which ${cmd}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -795,7 +594,7 @@ function commandExists(cmd) {
 }
 function dockerRunning() {
   try {
-    execSync3("docker info", { stdio: "ignore" });
+    execSync2("docker info", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -803,12 +602,12 @@ function dockerRunning() {
 }
 function checkClaudeAuth() {
   try {
-    execSync3("which claude", { stdio: "ignore" });
+    execSync2("which claude", { stdio: "ignore" });
   } catch {
     return { installed: false, loggedIn: false };
   }
   try {
-    const result = execSync3("claude --version", { stdio: "pipe" }).toString();
+    const result = execSync2("claude --version", { stdio: "pipe" }).toString();
     return { installed: true, loggedIn: result.includes("claude") };
   } catch {
     return { installed: true, loggedIn: false };
@@ -816,7 +615,7 @@ function checkClaudeAuth() {
 }
 function checkGhAuth() {
   try {
-    execSync3("gh auth status", { stdio: "ignore" });
+    execSync2("gh auth status", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -953,7 +752,7 @@ async function setupInfrastructure(cwd) {
     let allRunning = true;
     for (const service of services) {
       try {
-        execSync3(`docker ps --filter "name=${service}" --filter "status=running" -q`, { stdio: "pipe" });
+        execSync2(`docker ps --filter "name=${service}" --filter "status=running" -q`, { stdio: "pipe" });
       } catch {
         allRunning = false;
       }
@@ -1365,21 +1164,21 @@ squads goal list       # View goals
 // src/commands/run.ts
 import ora2 from "ora";
 import { spawn as spawn2 } from "child_process";
-import { join as join5, dirname as dirname2 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4, dirname } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 
 // src/lib/squad-parser.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4, basename } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, basename } from "path";
 import matter from "gray-matter";
 function findSquadsDir() {
   let dir = process.cwd();
   for (let i = 0; i < 5; i++) {
-    const squadsPath = join4(dir, ".agents", "squads");
-    if (existsSync4(squadsPath)) {
+    const squadsPath = join3(dir, ".agents", "squads");
+    if (existsSync3(squadsPath)) {
       return squadsPath;
     }
-    const parent = join4(dir, "..");
+    const parent = join3(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -1388,14 +1187,14 @@ function findSquadsDir() {
 function findProjectRoot() {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  return join4(squadsDir, "..", "..");
+  return join3(squadsDir, "..", "..");
 }
 function hasLocalInfraConfig() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) return false;
-  const envPath = join4(projectRoot, ".env");
-  if (!existsSync4(envPath)) return false;
-  const content = readFileSync3(envPath, "utf-8");
+  const envPath = join3(projectRoot, ".env");
+  if (!existsSync3(envPath)) return false;
+  const content = readFileSync2(envPath, "utf-8");
   const infraKeys = ["LANGFUSE_", "SQUADS_BRIDGE", "SQUADS_POSTGRES", "SQUADS_REDIS"];
   return infraKeys.some((key) => content.includes(key));
 }
@@ -1404,8 +1203,8 @@ function listSquads(squadsDir) {
   const entries = readdirSync(squadsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && !entry.name.startsWith("_")) {
-      const squadFile = join4(squadsDir, entry.name, "SQUAD.md");
-      if (existsSync4(squadFile)) {
+      const squadFile = join3(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync3(squadFile)) {
         squads.push(entry.name);
       }
     }
@@ -1416,8 +1215,8 @@ 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 = join4(squadsDir, dir);
-    if (!existsSync4(squadPath)) continue;
+    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") {
@@ -1426,7 +1225,7 @@ function listAgents(squadsDir, squadName) {
           name: agentName,
           role: `Agent in ${dir}`,
           trigger: "manual",
-          filePath: join4(squadPath, file)
+          filePath: join3(squadPath, file)
         });
       }
     }
@@ -1434,7 +1233,7 @@ function listAgents(squadsDir, squadName) {
   return agents;
 }
 function parseSquadFile(filePath) {
-  const rawContent = readFileSync3(filePath, "utf-8");
+  const rawContent = readFileSync2(filePath, "utf-8");
   const { data: frontmatter, content: bodyContent } = matter(rawContent);
   const fm = frontmatter;
   const lines = bodyContent.split("\n");
@@ -1555,20 +1354,20 @@ function parseSquadFile(filePath) {
 function loadSquad(squadName) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync4(squadFile)) return null;
+  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync3(squadFile)) return null;
   return parseSquadFile(squadFile);
 }
 function loadAgentDefinition(agentPath) {
-  if (!existsSync4(agentPath)) return "";
-  return readFileSync3(agentPath, "utf-8");
+  if (!existsSync3(agentPath)) return "";
+  return readFileSync2(agentPath, "utf-8");
 }
 function addGoalToSquad(squadName, goal2) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync4(squadFile)) return false;
-  let content = readFileSync3(squadFile, "utf-8");
+  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) {
@@ -1603,15 +1402,15 @@ function addGoalToSquad(squadName, goal2) {
 - [ ] ${goal2}` + content.slice(headerEnd);
     }
   }
-  writeFileSync3(squadFile, content);
+  writeFileSync2(squadFile, content);
   return true;
 }
 function updateGoalInSquad(squadName, goalIndex, updates) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync4(squadFile)) return false;
-  const content = readFileSync3(squadFile, "utf-8");
+  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;
@@ -1633,7 +1432,7 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
             }
           }
           lines[i] = newLine;
-          writeFileSync3(squadFile, lines.join("\n"));
+          writeFileSync2(squadFile, lines.join("\n"));
           return true;
         }
         goalCount++;
@@ -1882,7 +1681,7 @@ function generateExecutionId() {
 }
 function selectMcpConfig(squadName) {
   const home = process.env.HOME || "";
-  const configsDir = join5(home, ".claude", "mcp-configs");
+  const configsDir = join4(home, ".claude", "mcp-configs");
   const squadConfigs = {
     website: "website.json",
     // chrome-devtools, nano-banana
@@ -1897,12 +1696,12 @@ function selectMcpConfig(squadName) {
   };
   const configFile = squadConfigs[squadName.toLowerCase()];
   if (configFile) {
-    const configPath = join5(configsDir, configFile);
-    if (existsSync5(configPath)) {
+    const configPath = join4(configsDir, configFile);
+    if (existsSync4(configPath)) {
       return configPath;
     }
   }
-  return join5(home, ".claude.json");
+  return join4(home, ".claude.json");
 }
 function detectTaskType(agentName) {
   const name = agentName.toLowerCase();
@@ -1918,12 +1717,12 @@ function detectTaskType(agentName) {
   return "execution";
 }
 function ensureProjectTrusted(projectPath) {
-  const configPath = join5(process.env.HOME || "", ".claude.json");
-  if (!existsSync5(configPath)) {
+  const configPath = join4(process.env.HOME || "", ".claude.json");
+  if (!existsSync4(configPath)) {
     return;
   }
   try {
-    const config2 = JSON.parse(readFileSync4(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
     if (!config2.projects) {
       config2.projects = {};
     }
@@ -1932,7 +1731,7 @@ function ensureProjectTrusted(projectPath) {
     }
     if (!config2.projects[projectPath].hasTrustDialogAccepted) {
       config2.projects[projectPath].hasTrustDialogAccepted = true;
-      writeFileSync4(configPath, JSON.stringify(config2, null, 2));
+      writeFileSync3(configPath, JSON.stringify(config2, null, 2));
     }
   } catch {
   }
@@ -1940,25 +1739,25 @@ function ensureProjectTrusted(projectPath) {
 function getProjectRoot() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname2(dirname2(squadsDir));
+    return dirname(dirname(squadsDir));
   }
   return process.cwd();
 }
 function getExecutionLogPath(squadName, agentName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join5(memoryDir, squadName, agentName, "executions.md");
+  return join4(memoryDir, squadName, agentName, "executions.md");
 }
 function logExecution(record) {
   const logPath = getExecutionLogPath(record.squadName, record.agentName);
   if (!logPath) return;
-  const dir = dirname2(logPath);
-  if (!existsSync5(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  const dir = dirname(logPath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
   let content = "";
-  if (existsSync5(logPath)) {
-    content = readFileSync4(logPath, "utf-8").trimEnd();
+  if (existsSync4(logPath)) {
+    content = readFileSync3(logPath, "utf-8").trimEnd();
   } else {
     content = `# ${record.squadName}/${record.agentName} - Execution Log`;
   }
@@ -1971,12 +1770,12 @@ function logExecution(record) {
 - Trigger: ${record.trigger || "manual"}
 - Task Type: ${record.taskType || "execution"}
 `;
-  writeFileSync4(logPath, content + entry);
+  writeFileSync3(logPath, content + entry);
 }
 function updateExecutionStatus(squadName, agentName, executionId, status, details) {
   const logPath = getExecutionLogPath(squadName, agentName);
-  if (!logPath || !existsSync5(logPath)) return;
-  let content = readFileSync4(logPath, "utf-8");
+  if (!logPath || !existsSync4(logPath)) return;
+  let content = readFileSync3(logPath, "utf-8");
   const endTime = (/* @__PURE__ */ new Date()).toISOString();
   const execMarker = `<!-- exec:${executionId} -->`;
   const markerIndex = content.indexOf(execMarker);
@@ -1997,7 +1796,7 @@ function updateExecutionStatus(squadName, agentName, executionId, status, detail
 - Error: ${details.error}`;
   }
   content = content.slice(0, entryStart) + updatedEntry + content.slice(entryEnd);
-  writeFileSync4(logPath, content);
+  writeFileSync3(logPath, content);
 }
 function extractMcpServersFromDefinition(definition) {
   const servers = /* @__PURE__ */ new Set();
@@ -2076,8 +1875,8 @@ async function runSquad(squad, squadsDir, options) {
   if (options.parallel) {
     const agentFiles = squad.agents.map((a) => ({
       name: a.name,
-      path: join5(squadsDir, squad.name, `${a.name}.md`)
-    })).filter((a) => existsSync5(a.path));
+      path: join4(squadsDir, squad.name, `${a.name}.md`)
+    })).filter((a) => existsSync4(a.path));
     if (agentFiles.length === 0) {
       writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
       return;
@@ -2113,8 +1912,8 @@ async function runSquad(squad, squadsDir, options) {
     writeLine();
     for (let i = 0; i < pipeline.agents.length; i++) {
       const agentName = pipeline.agents[i];
-      const agentPath = join5(squadsDir, squad.name, `${agentName}.md`);
-      if (existsSync5(agentPath)) {
+      const agentPath = join4(squadsDir, squad.name, `${agentName}.md`);
+      if (existsSync4(agentPath)) {
         writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
         await runAgent(agentName, agentPath, squad.name, options);
         writeLine();
@@ -2124,8 +1923,8 @@ async function runSquad(squad, squadsDir, options) {
     }
   } else {
     if (options.agent) {
-      const agentPath = join5(squadsDir, squad.name, `${options.agent}.md`);
-      if (existsSync5(agentPath)) {
+      const agentPath = join4(squadsDir, squad.name, `${options.agent}.md`);
+      if (existsSync4(agentPath)) {
         await runAgent(options.agent, agentPath, squad.name, options);
       } else {
         writeLine(`  ${icons.error} ${colors.red}Agent ${options.agent} not found${RESET}`);
@@ -2136,8 +1935,8 @@ async function runSquad(squad, squadsDir, options) {
         (a) => a.name.includes("lead") || a.trigger === "Manual"
       );
       if (orchestrator) {
-        const agentPath = join5(squadsDir, squad.name, `${orchestrator.name}.md`);
-        if (existsSync5(agentPath)) {
+        const agentPath = join4(squadsDir, squad.name, `${orchestrator.name}.md`);
+        if (existsSync4(agentPath)) {
           await runAgent(orchestrator.name, agentPath, squad.name, options);
         }
       } else {
@@ -2163,9 +1962,9 @@ async function runLeadMode(squad, squadsDir, options) {
   if (!squad) return;
   const agentFiles = squad.agents.map((a) => ({
     name: a.name,
-    path: join5(squadsDir, squad.name, `${a.name}.md`),
+    path: join4(squadsDir, squad.name, `${a.name}.md`),
     role: a.role || ""
-  })).filter((a) => existsSync5(a.path));
+  })).filter((a) => existsSync4(a.path));
   if (agentFiles.length === 0) {
     writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
     return;
@@ -2284,9 +2083,9 @@ async function runAgent(agentName, agentPath, squadName, options) {
   }
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    const squadFilePath = join5(squadsDir, squadName, "SQUAD.md");
-    if (existsSync5(squadFilePath)) {
-      const squadContent = readFileSync4(squadFilePath, "utf-8");
+    const squadFilePath = join4(squadsDir, squadName, "SQUAD.md");
+    if (existsSync4(squadFilePath)) {
+      const squadContent = readFileSync3(squadFilePath, "utf-8");
       const permContext = buildContextFromSquad(squadName, squadContent, agentName);
       const mcpServers = extractMcpServersFromDefinition(definition);
       const execRequest = {
@@ -2566,8 +2365,8 @@ async function listCommand(options) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync6, statSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, statSync } from "fs";
+import { join as join5 } from "path";
 async function statusCommand(squadName, options = {}) {
   await track(Events.CLI_STATUS, { squad: squadName || "all", verbose: options.verbose });
   const squadsDir = findSquadsDir();
@@ -2620,8 +2419,8 @@ async function showOverallStatus(squadsDir, _options) {
     let lastActivity = `${colors.dim}\u2014${RESET}`;
     let activityColor = colors.dim;
     if (memoryDir) {
-      const squadMemoryPath = join6(memoryDir, squadName);
-      if (existsSync6(squadMemoryPath)) {
+      const squadMemoryPath = join5(memoryDir, squadName);
+      if (existsSync5(squadMemoryPath)) {
         const states = getSquadState(squadName);
         memoryStatus = `${colors.green}${states.length} ${states.length === 1 ? "entry" : "entries"}${RESET}`;
         let mostRecent = 0;
@@ -2723,14 +2522,14 @@ async function showSquadStatus(squadName, squadsDir, options) {
 }
 
 // src/commands/stack.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, copyFileSync } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
-import { homedir as homedir3 } from "os";
-import { execSync as execSync4, spawn as spawn3 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, copyFileSync } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync as execSync3, spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname3(__filename2);
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
 var DEFAULT_CONFIG = {
   SQUADS_DATABASE_URL: "postgresql://squads:squads@localhost:5433/squads",
   SQUADS_BRIDGE_URL: "http://localhost:8088",
@@ -2739,8 +2538,8 @@ var DEFAULT_CONFIG = {
   LANGFUSE_SECRET_KEY: "",
   REDIS_URL: "redis://localhost:6379"
 };
-var CONFIG_PATH2 = join7(homedir3(), ".squadsrc");
-var SQUADS_DATA_DIR = join7(homedir3(), ".squads");
+var CONFIG_PATH2 = join6(homedir2(), ".squadsrc");
+var SQUADS_DATA_DIR = join6(homedir2(), ".squads");
 var SERVICES = {
   bridge: {
     name: "Bridge API",
@@ -2874,25 +2673,25 @@ async function confirm2(question, defaultYes = true) {
 function findPackageDockerDir() {
   const candidates = [
     // From npm package (relative to dist/commands/stack.js)
-    join7(__dirname2, "..", "..", "docker"),
+    join6(__dirname2, "..", "..", "docker"),
     // Local development
-    join7(process.cwd(), "docker"),
-    join7(process.cwd(), "..", "squads-cli", "docker"),
-    join7(homedir3(), "agents-squads", "squads-cli", "docker")
+    join6(process.cwd(), "docker"),
+    join6(process.cwd(), "..", "squads-cli", "docker"),
+    join6(homedir2(), "agents-squads", "squads-cli", "docker")
   ];
   for (const dir of candidates) {
-    if (existsSync7(join7(dir, "docker-compose.yml"))) {
+    if (existsSync6(join6(dir, "docker-compose.yml"))) {
       return dir;
     }
   }
   return null;
 }
 function loadStackConfig() {
-  if (!existsSync7(CONFIG_PATH2)) {
+  if (!existsSync6(CONFIG_PATH2)) {
     return null;
   }
   try {
-    const content = readFileSync5(CONFIG_PATH2, "utf-8");
+    const content = readFileSync4(CONFIG_PATH2, "utf-8");
     const config2 = {};
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -2933,7 +2732,7 @@ function saveStackConfig(config2) {
     "# To activate: source ~/.squadsrc",
     ""
   ];
-  writeFileSync5(CONFIG_PATH2, lines.join("\n"));
+  writeFileSync4(CONFIG_PATH2, lines.join("\n"));
 }
 function applyStackConfig() {
   const config2 = loadStackConfig();
@@ -2946,7 +2745,7 @@ function applyStackConfig() {
 }
 function isDockerRunning() {
   try {
-    execSync4("docker info", { stdio: "ignore" });
+    execSync3("docker info", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -2954,7 +2753,7 @@ function isDockerRunning() {
 }
 function getContainerStatus(name) {
   try {
-    const runningOutput = execSync4(
+    const runningOutput = execSync3(
       `docker inspect ${name} --format '{{.State.Running}}'`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
     ).trim();
@@ -2964,7 +2763,7 @@ function getContainerStatus(name) {
     }
     let port;
     try {
-      const portOutput = execSync4(
+      const portOutput = execSync3(
         `docker inspect ${name} --format '{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}'`,
         { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
       ).trim();
@@ -2973,7 +2772,7 @@ function getContainerStatus(name) {
     }
     let healthy = true;
     try {
-      const healthOutput = execSync4(
+      const healthOutput = execSync3(
         `docker inspect ${name} --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}'`,
         { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
       ).trim();
@@ -3005,13 +2804,13 @@ async function checkService(url, timeout = 2e3) {
 }
 function getLangfuseKeysFromDockerEnv() {
   const envPaths2 = [
-    join7(process.cwd(), "docker", ".env"),
-    join7(process.cwd(), "..", "squads-cli", "docker", ".env"),
-    join7(homedir3(), "agents-squads", "squads-cli", "docker", ".env")
+    join6(process.cwd(), "docker", ".env"),
+    join6(process.cwd(), "..", "squads-cli", "docker", ".env"),
+    join6(homedir2(), "agents-squads", "squads-cli", "docker", ".env")
   ];
   for (const envPath of envPaths2) {
-    if (existsSync7(envPath)) {
-      const content = readFileSync5(envPath, "utf-8");
+    if (existsSync6(envPath)) {
+      const content = readFileSync4(envPath, "utf-8");
       const publicMatch = content.match(/LANGFUSE_PUBLIC_KEY=(\S+)/);
       const secretMatch = content.match(/LANGFUSE_SECRET_KEY=(\S+)/);
       if (publicMatch && secretMatch) {
@@ -3026,12 +2825,12 @@ function getLangfuseKeysFromDockerEnv() {
 }
 function findDockerComposeDir() {
   const candidates = [
-    join7(process.cwd(), "docker"),
-    join7(process.cwd(), "..", "squads-cli", "docker"),
-    join7(homedir3(), "agents-squads", "squads-cli", "docker")
+    join6(process.cwd(), "docker"),
+    join6(process.cwd(), "..", "squads-cli", "docker"),
+    join6(homedir2(), "agents-squads", "squads-cli", "docker")
   ];
   for (const dir of candidates) {
-    if (existsSync7(join7(dir, "docker-compose.yml"))) {
+    if (existsSync6(join6(dir, "docker-compose.yml"))) {
       return dir;
     }
   }
@@ -3057,7 +2856,7 @@ async function stackInitCommand() {
   writeLine();
   writeLine(`  ${bold}Step 2: Docker Compose Files${RESET}`);
   let composeDir = findPackageDockerDir();
-  const targetDir = join7(SQUADS_DATA_DIR, "docker");
+  const targetDir = join6(SQUADS_DATA_DIR, "docker");
   if (!composeDir) {
     writeLine(`  ${colors.red}${icons.error}${RESET} Docker compose files not found`);
     writeLine(`  ${colors.dim}This shouldn't happen if you installed via npm.${RESET}`);
@@ -3065,20 +2864,20 @@ async function stackInitCommand() {
     writeLine();
     return;
   }
-  if (composeDir !== targetDir && !existsSync7(targetDir)) {
+  if (composeDir !== targetDir && !existsSync6(targetDir)) {
     writeLine(`  ${colors.cyan}${icons.progress}${RESET} Copying docker files to ${colors.dim}~/.squads/docker${RESET}`);
     try {
-      mkdirSync4(SQUADS_DATA_DIR, { recursive: true });
-      mkdirSync4(targetDir, { recursive: true });
+      mkdirSync3(SQUADS_DATA_DIR, { recursive: true });
+      mkdirSync3(targetDir, { recursive: true });
       const filesToCopy = [
         "docker-compose.yml",
         "docker-compose.engram.yml",
         ".env.example"
       ];
       for (const file of filesToCopy) {
-        const src = join7(composeDir, file);
-        const dst = join7(targetDir, file);
-        if (existsSync7(src)) {
+        const src = join6(composeDir, file);
+        const dst = join6(targetDir, file);
+        if (existsSync6(src)) {
           copyFileSync(src, dst);
         }
       }
@@ -3087,7 +2886,7 @@ async function stackInitCommand() {
     } catch {
       writeLine(`  ${colors.yellow}${icons.warning}${RESET} Could not copy files, using source location`);
     }
-  } else if (existsSync7(targetDir)) {
+  } else if (existsSync6(targetDir)) {
     composeDir = targetDir;
     writeLine(`  ${colors.green}${icons.success}${RESET} Using ${colors.dim}~/.squads/docker${RESET}`);
   } else {
@@ -3095,10 +2894,10 @@ async function stackInitCommand() {
   }
   writeLine();
   writeLine(`  ${bold}Step 3: Environment Configuration${RESET}`);
-  const envPath = join7(composeDir, ".env");
-  const envExamplePath = join7(composeDir, ".env.example");
-  if (!existsSync7(envPath)) {
-    if (existsSync7(envExamplePath)) {
+  const envPath = join6(composeDir, ".env");
+  const envExamplePath = join6(composeDir, ".env.example");
+  if (!existsSync6(envPath)) {
+    if (existsSync6(envExamplePath)) {
       copyFileSync(envExamplePath, envPath);
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created .env from template`);
     } else {
@@ -3127,13 +2926,13 @@ LANGFUSE_PORT=3100
 OTEL_PORT=4318
 BRIDGE_PORT=8088
 `;
-      writeFileSync5(envPath, minimalEnv);
+      writeFileSync4(envPath, minimalEnv);
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Created default .env`);
     }
   } else {
     writeLine(`  ${colors.green}${icons.success}${RESET} .env exists`);
   }
-  const envContent = readFileSync5(envPath, "utf-8");
+  const envContent = readFileSync4(envPath, "utf-8");
   const missingSecrets = [];
   const llmProvider = envContent.match(/LLM_PROVIDER=(\w+)/)?.[1] || "ollama";
   if (llmProvider === "openai") {
@@ -3174,7 +2973,7 @@ BRIDGE_PORT=8088
       writeLine();
       writeLine(`  ${colors.cyan}${icons.progress}${RESET} Starting containers...`);
       try {
-        execSync4("docker compose up -d", {
+        execSync3("docker compose up -d", {
           cwd: composeDir,
           stdio: "inherit"
         });
@@ -3374,7 +3173,7 @@ async function stackHealthCommand(verbose = false) {
     let logs;
     if (!ok && verbose) {
       try {
-        logs = execSync4(`docker logs ${container.name} --tail 10 2>&1`, {
+        logs = execSync3(`docker logs ${container.name} --tail 10 2>&1`, {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
@@ -3425,7 +3224,7 @@ function stackLogsCommand(service, tail = 50) {
   };
   const container = containerMap[service] || `squads-${service}`;
   try {
-    execSync4(`docker logs ${container} --tail ${tail}`, { stdio: "inherit" });
+    execSync3(`docker logs ${container} --tail ${tail}`, { stdio: "inherit" });
   } catch {
     writeLine(`  ${colors.red}${icons.error}${RESET} Container ${container} not found`);
   }
@@ -3812,9 +3611,9 @@ async function memoryExtractCommand(options = {}) {
 }
 
 // src/commands/sync.ts
-import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync2 } from "fs";
-import { join as join8 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
 var PATH_TO_SQUAD = {
   "squads-cli": "product",
   "agents-squads-web": "website",
@@ -3842,21 +3641,21 @@ var MESSAGE_TO_SQUAD = {
   "infra": "engineering"
 };
 function getLastSyncTime(memoryDir) {
-  const syncFile = join8(memoryDir, ".last-sync");
-  if (existsSync8(syncFile)) {
-    return readFileSync6(syncFile, "utf-8").trim();
+  const syncFile = join7(memoryDir, ".last-sync");
+  if (existsSync7(syncFile)) {
+    return readFileSync5(syncFile, "utf-8").trim();
   }
   return null;
 }
 function updateLastSyncTime(memoryDir) {
-  const syncFile = join8(memoryDir, ".last-sync");
-  writeFileSync6(syncFile, (/* @__PURE__ */ new Date()).toISOString());
+  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 = execSync5(
+    const logOutput = execSync4(
       `git log ${sinceArg} --format="%H|%aI|%s" --name-only`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -3922,22 +3721,22 @@ ${messages}
 `;
 }
 function appendToSquadMemory(memoryDir, squad, summary) {
-  const squadMemoryDir = join8(memoryDir, squad);
-  if (!existsSync8(squadMemoryDir)) {
-    mkdirSync5(squadMemoryDir, { recursive: true });
+  const squadMemoryDir = join7(memoryDir, squad);
+  if (!existsSync7(squadMemoryDir)) {
+    mkdirSync4(squadMemoryDir, { recursive: true });
   }
   let agentDir;
-  const existingDirs = existsSync8(squadMemoryDir) ? readdirSync2(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+  const existingDirs = existsSync7(squadMemoryDir) ? readdirSync2(squadMemoryDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
   if (existingDirs.length > 0) {
-    agentDir = join8(squadMemoryDir, existingDirs[0]);
+    agentDir = join7(squadMemoryDir, existingDirs[0]);
   } else {
-    agentDir = join8(squadMemoryDir, `${squad}-lead`);
-    mkdirSync5(agentDir, { recursive: true });
+    agentDir = join7(squadMemoryDir, `${squad}-lead`);
+    mkdirSync4(agentDir, { recursive: true });
   }
-  const statePath = join8(agentDir, "state.md");
+  const statePath = join7(agentDir, "state.md");
   let content = "";
-  if (existsSync8(statePath)) {
-    content = readFileSync6(statePath, "utf-8");
+  if (existsSync7(statePath)) {
+    content = readFileSync5(statePath, "utf-8");
   } else {
     content = `# ${squad} Squad - State
 
@@ -3949,13 +3748,13 @@ Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
     `Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`
   );
   content += summary;
-  writeFileSync6(statePath, content);
+  writeFileSync5(statePath, content);
   return true;
 }
 function gitPullMemory() {
   try {
-    execSync5("git fetch origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-    const status = execSync5("git status -sb", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    execSync4("git fetch origin", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const status = execSync4("git status -sb", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     const behindMatch = status.match(/behind (\d+)/);
     const aheadMatch = status.match(/ahead (\d+)/);
     const behind = behindMatch ? parseInt(behindMatch[1]) : 0;
@@ -3963,7 +3762,7 @@ function gitPullMemory() {
     if (behind === 0) {
       return { success: true, output: "Already up to date", behind: 0, ahead };
     }
-    const output = execSync5("git pull --rebase origin main", {
+    const output = execSync4("git pull --rebase origin main", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3975,18 +3774,18 @@ function gitPullMemory() {
 }
 function gitPushMemory() {
   try {
-    const status = execSync5("git status --porcelain .agents/memory/", {
+    const status = execSync4("git status --porcelain .agents/memory/", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (status) {
-      execSync5("git add .agents/memory/", { stdio: ["pipe", "pipe", "pipe"] });
-      execSync5('git commit -m "chore: sync squad memory"', {
+      execSync4("git add .agents/memory/", { stdio: ["pipe", "pipe", "pipe"] });
+      execSync4('git commit -m "chore: sync squad memory"', {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     }
-    const output = execSync5("git push origin main", {
+    const output = execSync4("git push origin main", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -4226,28 +4025,28 @@ async function goalProgressCommand(squadName, goalIndex, progress2) {
 }
 
 // src/commands/feedback.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join8, dirname as dirname3 } 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 join9(memoryDir, squadName, agentName, "feedback.md");
+  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 join9(memoryDir, squadName, agentName, "output.md");
+  return join8(memoryDir, squadName, agentName, "output.md");
 }
 function getLastExecution(squadName) {
   const outputPath = getOutputPath(squadName);
-  if (!outputPath || !existsSync9(outputPath)) {
+  if (!outputPath || !existsSync8(outputPath)) {
     return null;
   }
-  const content = readFileSync7(outputPath, "utf-8");
+  const content = readFileSync6(outputPath, "utf-8");
   const lines = content.split("\n");
   let date = "unknown";
   let summary = lines.slice(0, 5).join("\n");
@@ -4299,9 +4098,9 @@ async function feedbackAddCommand(squadName, rating, feedback2, options) {
     return;
   }
   const lastExec = getLastExecution(squadName);
-  const dir = dirname4(feedbackPath);
-  if (!existsSync9(dir)) {
-    mkdirSync6(dir, { recursive: true });
+  const dir = dirname3(feedbackPath);
+  if (!existsSync8(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   let entry = `
@@ -4329,15 +4128,15 @@ _Date: ${date}_
     }
   }
   let existing = "";
-  if (existsSync9(feedbackPath)) {
-    existing = readFileSync7(feedbackPath, "utf-8");
+  if (existsSync8(feedbackPath)) {
+    existing = readFileSync6(feedbackPath, "utf-8");
   } else {
     existing = `# ${squadName} - Feedback Log
 
 > Execution feedback and learnings
 `;
   }
-  writeFileSync7(feedbackPath, existing + entry);
+  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}`);
@@ -4351,11 +4150,11 @@ _Date: ${date}_
 async function feedbackShowCommand(squadName, options) {
   await track(Events.CLI_FEEDBACK_SHOW, { squad: squadName });
   const feedbackPath = getFeedbackPath(squadName);
-  if (!feedbackPath || !existsSync9(feedbackPath)) {
+  if (!feedbackPath || !existsSync8(feedbackPath)) {
     writeLine(`  ${colors.yellow}No feedback recorded for ${squadName}${RESET}`);
     return;
   }
-  const content = readFileSync7(feedbackPath, "utf-8");
+  const content = readFileSync6(feedbackPath, "utf-8");
   const entries = parseFeedbackHistory(content);
   const limit = options.limit ? parseInt(options.limit) : 5;
   const recent = entries.slice(-limit).reverse();
@@ -4400,10 +4199,10 @@ async function feedbackStatsCommand() {
   writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
   for (const squad of squads) {
     const feedbackPath = getFeedbackPath(squad);
-    if (!feedbackPath || !existsSync9(feedbackPath)) {
+    if (!feedbackPath || !existsSync8(feedbackPath)) {
       continue;
     }
-    const content = readFileSync7(feedbackPath, "utf-8");
+    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;
@@ -4426,8 +4225,8 @@ async function feedbackStatsCommand() {
 }
 
 // src/commands/dashboard.ts
-import { readdirSync as readdirSync4, existsSync as existsSync10, statSync as statSync2 } from "fs";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync4, existsSync as existsSync9, statSync as statSync2 } from "fs";
+import { join as join9 } from "path";
 
 // src/lib/providers.ts
 var PROVIDERS = {
@@ -5286,16 +5085,16 @@ async function closeDatabase() {
 function getLastActivityDate(squadName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return "unknown";
-  const squadMemory = join10(memoryDir, squadName);
-  if (!existsSync10(squadMemory)) return "\u2014";
+  const squadMemory = join9(memoryDir, squadName);
+  if (!existsSync9(squadMemory)) return "\u2014";
   let latestTime = 0;
   try {
     const agents = readdirSync4(squadMemory, { withFileTypes: true }).filter((e) => e.isDirectory());
     for (const agent of agents) {
-      const agentPath = join10(squadMemory, agent.name);
+      const agentPath = join9(squadMemory, agent.name);
       const files = readdirSync4(agentPath).filter((f) => f.endsWith(".md"));
       for (const file of files) {
-        const filePath = join10(agentPath, file);
+        const filePath = join9(agentPath, file);
         const stats = statSync2(filePath);
         if (stats.mtimeMs > latestTime) {
           latestTime = stats.mtimeMs;
@@ -5542,11 +5341,11 @@ async function dashboardCommand(options = {}) {
   await closeDatabase();
 }
 function findAgentsSquadsDir() {
-  const parentDir = join10(process.cwd(), "..");
-  if (existsSync10(join10(parentDir, "hq"))) {
+  const parentDir = join9(process.cwd(), "..");
+  if (existsSync9(join9(parentDir, "hq"))) {
     return parentDir;
   }
-  if (existsSync10(join10(process.cwd(), ".git"))) {
+  if (existsSync9(join9(process.cwd(), ".git"))) {
     return process.cwd();
   }
   return null;
@@ -5935,7 +5734,7 @@ function renderInsightsCached(cache) {
 }
 
 // src/commands/issues.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function getLabelName(label) {
   return typeof label === "string" ? label : label.name;
 }
@@ -5948,7 +5747,7 @@ async function issuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}issues${RESET}`);
   writeLine();
   try {
-    execSync6("gh --version", { stdio: "pipe" });
+    execSync5("gh --version", { stdio: "pipe" });
   } catch {
     writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
     writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
@@ -5959,7 +5758,7 @@ async function issuesCommand(options = {}) {
   let totalOpen = 0;
   for (const repo of repos) {
     try {
-      const result = execSync6(
+      const result = execSync5(
         `gh issue list -R ${org}/${repo} --state open --json number,title,state,labels,createdAt --limit 50`,
         { stdio: "pipe", encoding: "utf-8" }
       );
@@ -6010,7 +5809,7 @@ async function issuesCommand(options = {}) {
 }
 
 // src/commands/solve-issues.ts
-import { execSync as execSync7, spawn as spawn4 } from "child_process";
+import { execSync as execSync6, spawn as spawn4 } from "child_process";
 import ora3 from "ora";
 var DEFAULT_ORG2 = "agents-squads";
 var DEFAULT_REPOS2 = ["hq", "agents-squads-web", "squads-cli", "agents-squads"];
@@ -6020,7 +5819,7 @@ async function solveIssuesCommand(options = {}) {
   writeLine(`  ${gradient("squads")} ${colors.dim}solve-issues${RESET}`);
   writeLine();
   try {
-    execSync7("gh --version", { stdio: "pipe" });
+    execSync6("gh --version", { stdio: "pipe" });
   } catch {
     writeLine(`  ${colors.red}GitHub CLI (gh) not found${RESET}`);
     writeLine(`  ${colors.dim}Install: brew install gh${RESET}`);
@@ -6030,7 +5829,7 @@ async function solveIssuesCommand(options = {}) {
   if (options.issue) {
     const repo = options.repo || "hq";
     try {
-      const result = execSync7(
+      const result = execSync6(
         `gh issue view ${options.issue} -R ${DEFAULT_ORG2}/${repo} --json number,title,labels,body`,
         { stdio: "pipe", encoding: "utf-8" }
       );
@@ -6043,7 +5842,7 @@ async function solveIssuesCommand(options = {}) {
   } else {
     for (const repo of repos) {
       try {
-        const result = execSync7(
+        const result = execSync6(
           `gh issue list -R ${DEFAULT_ORG2}/${repo} --label "ready-to-fix" --state open --json number,title,labels --limit 20`,
           { stdio: "pipe", encoding: "utf-8" }
         );
@@ -6097,7 +5896,7 @@ function showSolveInstructions(issues) {
 async function solveWithClaude(issues) {
   const spinner = ora3("Starting issue solver...").start();
   try {
-    execSync7("which claude", { stdio: "pipe" });
+    execSync6("which claude", { stdio: "pipe" });
   } catch {
     spinner.fail("Claude CLI not found");
     writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
@@ -6183,9 +5982,9 @@ function executeClaudePrompt(prompt2) {
 }
 
 // src/commands/open-issues.ts
-import { execSync as execSync8, spawn as spawn5 } from "child_process";
+import { execSync as execSync7, spawn as spawn5 } from "child_process";
 import { readdirSync as readdirSync5 } from "fs";
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 import ora4 from "ora";
 var ISSUE_FINDER_PATTERNS = [
   "*-eval.md",
@@ -6243,7 +6042,7 @@ function findEvalAgents(squadsDir, filterSquad) {
   const agents = [];
   const squads = readdirSync5(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => !filterSquad || d.name === filterSquad).map((d) => d.name);
   for (const squad of squads) {
-    const squadPath = join11(squadsDir, squad);
+    const squadPath = join10(squadsDir, squad);
     const files = readdirSync5(squadPath).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const isEval = ISSUE_FINDER_PATTERNS.some((pattern) => {
@@ -6254,7 +6053,7 @@ function findEvalAgents(squadsDir, filterSquad) {
         agents.push({
           name: file,
           squad,
-          path: join11(squadPath, file)
+          path: join10(squadPath, file)
         });
       }
     }
@@ -6280,7 +6079,7 @@ function showRunInstructions(agents) {
 async function runEvaluators(agents) {
   const spinner = ora4("Starting evaluators...").start();
   try {
-    execSync8("which claude", { stdio: "pipe" });
+    execSync7("which claude", { stdio: "pipe" });
   } catch {
     spinner.fail("Claude CLI not found");
     writeLine(`  ${colors.dim}Install: npm install -g @anthropic-ai/claude-code${RESET}`);
@@ -6364,9 +6163,9 @@ import open from "open";
 
 // src/lib/auth.ts
 import { createClient } from "@supabase/supabase-js";
-import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir3 } from "os";
 import "open";
 import http from "http";
 var PERSONAL_DOMAINS = [
@@ -6395,8 +6194,8 @@ var PERSONAL_DOMAINS = [
   "tutanota.com",
   "hey.com"
 ];
-var AUTH_DIR = join12(homedir4(), ".squads-cli");
-var AUTH_PATH = join12(AUTH_DIR, "auth.json");
+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);
@@ -6405,22 +6204,22 @@ function getEmailDomain(email) {
   return email.split("@")[1]?.toLowerCase() || "";
 }
 function saveSession(session2) {
-  if (!existsSync11(AUTH_DIR)) {
-    mkdirSync7(AUTH_DIR, { recursive: true });
+  if (!existsSync10(AUTH_DIR)) {
+    mkdirSync6(AUTH_DIR, { recursive: true });
   }
-  writeFileSync8(AUTH_PATH, JSON.stringify(session2, null, 2));
+  writeFileSync7(AUTH_PATH, JSON.stringify(session2, null, 2));
 }
 function loadSession() {
-  if (!existsSync11(AUTH_PATH)) return null;
+  if (!existsSync10(AUTH_PATH)) return null;
   try {
-    return JSON.parse(readFileSync8(AUTH_PATH, "utf-8"));
+    return JSON.parse(readFileSync7(AUTH_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearSession() {
-  if (existsSync11(AUTH_PATH)) {
-    writeFileSync8(AUTH_PATH, "");
+  if (existsSync10(AUTH_PATH)) {
+    writeFileSync7(AUTH_PATH, "");
   }
 }
 function startAuthCallbackServer(port = 54321) {
@@ -6642,26 +6441,26 @@ async function updateCommand(options = {}) {
 }
 
 // src/commands/progress.ts
-import { execSync as execSync9 } from "child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
-import { join as join13 } from "path";
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync8, 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 = join13(cwd, ".agents");
-    if (!existsSync12(agentsDir)) {
-      mkdirSync8(agentsDir, { recursive: true });
+    const agentsDir = join12(cwd, ".agents");
+    if (!existsSync11(agentsDir)) {
+      mkdirSync7(agentsDir, { recursive: true });
     }
-    return join13(agentsDir, "tasks.json");
+    return join12(agentsDir, "tasks.json");
   }
-  return join13(memoryDir, "..", "tasks.json");
+  return join12(memoryDir, "..", "tasks.json");
 }
 function loadTasks() {
   const tasksPath = getTasksFilePath();
-  if (existsSync12(tasksPath)) {
+  if (existsSync11(tasksPath)) {
     try {
-      return JSON.parse(readFileSync9(tasksPath, "utf-8"));
+      return JSON.parse(readFileSync8(tasksPath, "utf-8"));
     } catch {
       return { tasks: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
     }
@@ -6671,7 +6470,7 @@ function loadTasks() {
 function saveTasks(data) {
   const tasksPath = getTasksFilePath();
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync9(tasksPath, JSON.stringify(data, null, 2));
+  writeFileSync8(tasksPath, JSON.stringify(data, null, 2));
 }
 function getRecentActivity() {
   const activity = [];
@@ -6687,7 +6486,7 @@ function getRecentActivity() {
     marketing: ["marketing", "content", "social"]
   };
   try {
-    const logOutput = execSync9(
+    const logOutput = execSync8(
       'git log --since="24 hours ago" --format="%h|%aI|%s" 2>/dev/null',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -6821,7 +6620,7 @@ function getElapsedTime(startTime) {
 }
 
 // src/commands/results.ts
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 function getGitStats(days = 7) {
   const stats = /* @__PURE__ */ new Map();
   const squadKeywords = {
@@ -6836,7 +6635,7 @@ function getGitStats(days = 7) {
     marketing: ["marketing"]
   };
   try {
-    const logOutput = execSync10(
+    const logOutput = execSync9(
       `git log --since="${days} days ago" --format="%s" --name-only 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -6875,7 +6674,7 @@ function getGitHubStats(days = 7) {
   const prsMerged = /* @__PURE__ */ new Map();
   const issuesClosed = /* @__PURE__ */ new Map();
   try {
-    const prsOutput = execSync10(
+    const prsOutput = execSync9(
       `gh pr list --state all --json title,createdAt,mergedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -6890,7 +6689,7 @@ function getGitHubStats(days = 7) {
         prsMerged.set(squad, (prsMerged.get(squad) || 0) + 1);
       }
     }
-    const issuesOutput = execSync10(
+    const issuesOutput = execSync9(
       `gh issue list --state closed --json title,closedAt --limit 50 2>/dev/null`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -7023,8 +6822,8 @@ async function resultsCommand(options = {}) {
 }
 
 // src/commands/history.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
 var BRIDGE_URL2 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 var FETCH_TIMEOUT_MS2 = 3e3;
 async function fetchWithTimeout2(url, timeoutMs = FETCH_TIMEOUT_MS2) {
@@ -7069,12 +6868,12 @@ async function fetchFromBridge2(days, squad) {
 function fetchFromLocal(days, squad) {
   const executions = [];
   const historyPaths = [
-    join14(process.cwd(), ".agents/sessions/history.jsonl"),
-    join14(process.env.HOME || "", "agents-squads/hq/.agents/sessions/history.jsonl")
+    join13(process.cwd(), ".agents/sessions/history.jsonl"),
+    join13(process.env.HOME || "", "agents-squads/hq/.agents/sessions/history.jsonl")
   ];
   let historyPath;
   for (const path3 of historyPaths) {
-    if (existsSync13(path3)) {
+    if (existsSync12(path3)) {
       historyPath = path3;
       break;
     }
@@ -7083,7 +6882,7 @@ function fetchFromLocal(days, squad) {
     return [];
   }
   try {
-    const content = readFileSync10(historyPath, "utf-8");
+    const content = readFileSync9(historyPath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
     for (const line of lines) {
@@ -7419,19 +7218,19 @@ async function healthCommand(options = {}) {
 }
 
 // src/commands/workers.ts
-import { execSync as execSync11 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { execSync as execSync10 } from "child_process";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join14 } from "path";
 function getTasksFilePath2() {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join15(memoryDir, "..", "tasks.json");
+  return join14(memoryDir, "..", "tasks.json");
 }
 function loadActiveTasks() {
   const tasksPath = getTasksFilePath2();
-  if (!tasksPath || !existsSync14(tasksPath)) return [];
+  if (!tasksPath || !existsSync13(tasksPath)) return [];
   try {
-    const data = JSON.parse(readFileSync11(tasksPath, "utf-8"));
+    const data = JSON.parse(readFileSync10(tasksPath, "utf-8"));
     return data.tasks?.filter((t) => t.status === "active") || [];
   } catch {
     return [];
@@ -7440,7 +7239,7 @@ function loadActiveTasks() {
 function getRunningProcesses() {
   const processes = [];
   try {
-    const psOutput = execSync11(
+    const psOutput = execSync10(
       'ps aux | grep -E "claude|squads|astro|node.*agent" | grep -v grep',
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -7491,7 +7290,7 @@ async function workersCommand(options = {}) {
   writeLine();
   if (options.kill) {
     try {
-      execSync11(`kill ${options.kill}`, { stdio: "pipe" });
+      execSync10(`kill ${options.kill}`, { stdio: "pipe" });
       writeLine(`  ${icons.success} Killed process ${colors.cyan}${options.kill}${RESET}`);
       writeLine();
       return;
@@ -7578,8 +7377,8 @@ function getElapsedTime2(startTime) {
 }
 
 // src/commands/context-feed.ts
-import { existsSync as existsSync15, statSync as statSync3, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, statSync as statSync3, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 var BRIDGE_URL3 = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
 async function syncBriefToBridge(brief, sourcePath) {
   try {
@@ -7608,10 +7407,10 @@ async function syncBriefToBridge(brief, sourcePath) {
 }
 function readBusinessBrief(squadsDir) {
   if (!squadsDir) return void 0;
-  const briefPath = join16(squadsDir, "..", "BUSINESS_BRIEF.md");
-  if (!existsSync15(briefPath)) return void 0;
+  const briefPath = join15(squadsDir, "..", "BUSINESS_BRIEF.md");
+  if (!existsSync14(briefPath)) return void 0;
   try {
-    const content = readFileSync12(briefPath, "utf-8");
+    const content = readFileSync11(briefPath, "utf-8");
     const brief = { raw: content };
     const priorityMatch = content.match(/##\s*#1 Priority\s*\n+\*\*([^*]+)\*\*/);
     if (priorityMatch) {
@@ -7661,7 +7460,7 @@ function readBusinessBrief(squadsDir) {
 async function collectBriefingData(options) {
   const squadsDir = findSquadsDir();
   const memoryDir = findMemoryDir();
-  const baseDir = squadsDir ? join16(squadsDir, "..", "..", "..") : null;
+  const baseDir = squadsDir ? join15(squadsDir, "..", "..", "..") : null;
   const allSquads = squadsDir ? listSquads(squadsDir) : [];
   if (options.squad && !allSquads.includes(options.squad)) {
     return {
@@ -7701,14 +7500,14 @@ async function collectBriefingData(options) {
     }
     let lastActivity;
     if (memoryDir) {
-      const squadMemoryPath = join16(memoryDir, squadName);
-      if (existsSync15(squadMemoryPath)) {
+      const squadMemoryPath = join15(memoryDir, squadName);
+      if (existsSync14(squadMemoryPath)) {
         let mostRecent = 0;
         try {
           const walkDir = (dir) => {
             const entries = readdirSync6(dir, { withFileTypes: true });
             for (const entry of entries) {
-              const fullPath = join16(dir, entry.name);
+              const fullPath = join15(dir, entry.name);
               if (entry.isDirectory()) {
                 walkDir(fullPath);
               } else if (entry.name.endsWith(".md")) {
@@ -7788,7 +7587,7 @@ async function collectBriefingData(options) {
   }
   const brief = readBusinessBrief(squadsDir);
   if (brief && squadsDir) {
-    const briefPath = join16(squadsDir, "..", "BUSINESS_BRIEF.md");
+    const briefPath = join15(squadsDir, "..", "BUSINESS_BRIEF.md");
     syncBriefToBridge(brief, briefPath).catch(() => {
     });
   }
@@ -7996,7 +7795,7 @@ async function runCommand2(command, args, clear) {
 // src/commands/live.ts
 import blessed from "blessed";
 import contrib from "blessed-contrib";
-import { execSync as execSync12 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 async function liveCommand(_options) {
   const screen = blessed.screen({
     smartCSR: true,
@@ -8039,7 +7838,7 @@ async function liveCommand(_options) {
   });
   function getAgents() {
     try {
-      const output = execSync12('ps aux | grep -E "claude|node.*squads" | grep -v grep', {
+      const output = execSync11('ps aux | grep -E "claude|node.*squads" | grep -v grep', {
         encoding: "utf-8",
         timeout: 5e3
       });
@@ -8088,7 +7887,7 @@ async function liveCommand(_options) {
   }
   function getRecentActivity2() {
     try {
-      const output = execSync12(
+      const output = execSync11(
         "gh issue list --repo agents-squads/squads-cli --state open --limit 5 --json number,title,createdAt 2>/dev/null",
         { encoding: "utf-8", timeout: 1e4 }
       );
@@ -8102,7 +7901,7 @@ async function liveCommand(_options) {
   }
   function getMemoryUpdates() {
     try {
-      const output = execSync12(
+      const output = execSync11(
         'find .agents/memory -name "state.md" -mmin -60 2>/dev/null | head -5',
         { encoding: "utf-8", timeout: 5e3 }
       );
@@ -8178,7 +7977,7 @@ async function liveCommand(_options) {
 }
 
 // src/commands/top.ts
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync12 } from "child_process";
 var ESC = "\x1B";
 var CLEAR_SCREEN = `${ESC}[2J`;
 var CURSOR_HOME = `${ESC}[H`;
@@ -8212,7 +8011,7 @@ function getProcessData() {
   let claudeCount = 0;
   let agentCount = 0;
   try {
-    const psOutput = execSync13(
+    const psOutput = execSync12(
       'ps aux | grep -E "[c]laude" | head -15',
       { encoding: "utf-8", timeout: 5e3 }
     );
@@ -8237,7 +8036,7 @@ function getProcessData() {
   } catch {
   }
   try {
-    const tmuxOutput = execSync13("tmux ls 2>/dev/null | grep squads- | wc -l", { encoding: "utf-8" });
+    const tmuxOutput = execSync12("tmux ls 2>/dev/null | grep squads- | wc -l", { encoding: "utf-8" });
     agentCount = parseInt(tmuxOutput.trim()) || 0;
   } catch {
   }
@@ -8340,7 +8139,7 @@ async function detectSquadCommand() {
 
 // src/commands/trigger.ts
 import chalk3 from "chalk";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 var SCHEDULER_URL = process.env.SCHEDULER_URL || "http://localhost:8090";
 async function fetchScheduler(path3, options) {
   const res = await fetch(`${SCHEDULER_URL}${path3}`, {
@@ -8386,12 +8185,12 @@ async function listTriggers(squad) {
 }
 async function syncTriggers() {
   console.log(chalk3.gray("Syncing triggers from SQUAD.md files...\n"));
-  const { execSync: execSync15 } = await import("child_process");
+  const { execSync: execSync14 } = await import("child_process");
   const hqPath = process.env.HQ_PATH || `${process.env.HOME}/agents-squads/hq`;
   try {
     const venvPython = `${hqPath}/squads-scheduler/.venv/bin/python`;
-    const pythonCmd = existsSync16(venvPython) ? venvPython : "python3";
-    const output = execSync15(
+    const pythonCmd = existsSync15(venvPython) ? venvPython : "python3";
+    const output = execSync14(
       `${pythonCmd} ${hqPath}/squads-scheduler/sync_triggers.py`,
       { encoding: "utf-8", cwd: hqPath }
     );
@@ -8474,13 +8273,13 @@ function registerTriggerCommand(program2) {
 
 // src/commands/skill.ts
 import ora6 from "ora";
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync14 } from "fs";
-import { join as join18, basename as basename2, dirname as dirname5 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, readFileSync as readFileSync13 } from "fs";
+import { join as join17, basename as basename2, dirname as dirname4 } from "path";
 
 // src/lib/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { readFileSync as readFileSync13, readdirSync as readdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync7 } from "fs";
+import { join as join16 } from "path";
 var client = null;
 function getClient() {
   if (!client) {
@@ -8509,12 +8308,12 @@ function loadSkillFiles(skillPath) {
   function walkDir(dir, prefix = "") {
     const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join17(dir, entry.name);
+      const fullPath = join16(dir, entry.name);
       const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         walkDir(fullPath, relativePath);
       } else if (entry.isFile()) {
-        const content = readFileSync13(fullPath, "utf-8");
+        const content = readFileSync12(fullPath, "utf-8");
         files.push({
           name: relativePath,
           content
@@ -8678,14 +8477,14 @@ async function skillUploadCommand(skillPath) {
     writeLine();
     return;
   }
-  const fullPath = skillPath.startsWith("/") ? skillPath : join18(process.cwd(), skillPath);
-  if (!existsSync17(fullPath)) {
+  const fullPath = skillPath.startsWith("/") ? skillPath : join17(process.cwd(), skillPath);
+  if (!existsSync16(fullPath)) {
     writeLine(`  ${icons.error} ${colors.red}Directory not found: ${skillPath}${RESET}`);
     writeLine();
     return;
   }
-  const skillMdPath = join18(fullPath, "SKILL.md");
-  if (!existsSync17(skillMdPath)) {
+  const skillMdPath = join17(fullPath, "SKILL.md");
+  if (!existsSync16(skillMdPath)) {
     writeLine(`  ${icons.error} ${colors.red}SKILL.md not found in ${skillPath}${RESET}`);
     writeLine();
     writeLine(`  ${colors.dim}Create a SKILL.md file or use:${RESET}`);
@@ -8796,7 +8595,7 @@ async function skillConvertCommand(agentPath, options) {
     const [squad, agent] = agentPath.split("/");
     squadName = squad;
     agentName = agent.replace(".md", "");
-    agentFilePath = join18(squadsDir, squad, `${agentName}.md`);
+    agentFilePath = join17(squadsDir, squad, `${agentName}.md`);
   } else {
     agentName = agentPath.replace(".md", "");
     const foundPath = findAgentFile(squadsDir, agentName);
@@ -8807,22 +8606,22 @@ async function skillConvertCommand(agentPath, options) {
       return;
     }
     agentFilePath = foundPath;
-    squadName = basename2(dirname5(agentFilePath));
+    squadName = basename2(dirname4(agentFilePath));
   }
-  if (!existsSync17(agentFilePath)) {
+  if (!existsSync16(agentFilePath)) {
     writeLine(`  ${icons.error} ${colors.red}Agent file not found: ${agentFilePath}${RESET}`);
     writeLine();
     return;
   }
-  const agentContent = readFileSync14(agentFilePath, "utf-8");
+  const agentContent = readFileSync13(agentFilePath, "utf-8");
   const skillName = `${squadName}-${agentName}`;
-  const outputDir = options.output || join18(dirname5(squadsDir), "skills", skillName);
-  if (!existsSync17(outputDir)) {
-    mkdirSync9(outputDir, { recursive: true });
+  const outputDir = options.output || join17(dirname4(squadsDir), "skills", skillName);
+  if (!existsSync16(outputDir)) {
+    mkdirSync8(outputDir, { recursive: true });
   }
   const skillMd = convertAgentToSkill(agentContent, squadName, agentName);
-  const skillMdPath = join18(outputDir, "SKILL.md");
-  writeFileSync10(skillMdPath, skillMd);
+  const skillMdPath = join17(outputDir, "SKILL.md");
+  writeFileSync9(skillMdPath, skillMd);
   writeLine(`  ${icons.success} ${colors.green}Converted:${RESET} ${agentPath}`);
   writeLine();
   writeLine(`  ${colors.dim}Output:${RESET} ${outputDir}`);
@@ -8839,8 +8638,8 @@ function findAgentFile(squadsDir, agentName) {
   const { readdirSync: readdirSync9 } = __require("fs");
   const squads = readdirSync9(squadsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("_")).map((d) => d.name);
   for (const squad of squads) {
-    const agentPath = join18(squadsDir, squad, `${agentName}.md`);
-    if (existsSync17(agentPath)) {
+    const agentPath = join17(squadsDir, squad, `${agentName}.md`);
+    if (existsSync16(agentPath)) {
       return agentPath;
     }
   }
@@ -8881,8 +8680,8 @@ function formatBytes(bytes) {
 }
 
 // src/commands/permissions.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { join as join18 } from "path";
 function registerPermissionsCommand(program2) {
   const permissions = program2.command("permissions").alias("perms").description("Manage and validate squad permissions");
   permissions.command("show <squad>").description("Show permission context for a squad").action(permissionsShowCommand);
@@ -8904,8 +8703,8 @@ async function permissionsShowCommand(squadName) {
     writeLine();
     return;
   }
-  const squadFilePath = join19(squadsDir, squadName, "SQUAD.md");
-  const squadContent = readFileSync15(squadFilePath, "utf-8");
+  const squadFilePath = join18(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync14(squadFilePath, "utf-8");
   const context2 = buildContextFromSquad(squadName, squadContent);
   const defaults = getDefaultContext(squadName);
   const isDefault = JSON.stringify(context2.permissions) === JSON.stringify(defaults.permissions);
@@ -8999,8 +8798,8 @@ async function permissionsCheckCommand(squadName, options) {
     writeLine();
     return;
   }
-  const squadFilePath = join19(squadsDir, squadName, "SQUAD.md");
-  const squadContent = readFileSync15(squadFilePath, "utf-8");
+  const squadFilePath = join18(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync14(squadFilePath, "utf-8");
   const context2 = buildContextFromSquad(squadName, squadContent, options.agent);
   const request = {
     mcpServers: options.mcp,
@@ -9433,8 +9232,8 @@ function createBudgetBar(percent, width = 10) {
 }
 
 // src/lib/executions.ts
-import { readFileSync as readFileSync16, existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync17, readdirSync as readdirSync8 } from "fs";
+import { join as join19 } from "path";
 function parseExecutionEntry(content, squad, agent) {
   const idMatch = content.match(/<!-- exec:(\S+) -->/);
   if (!idMatch) return null;
@@ -9472,8 +9271,8 @@ function parseExecutionEntry(content, squad, agent) {
   };
 }
 function parseExecutionLog(filePath, squad, agent) {
-  if (!existsSync18(filePath)) return [];
-  const content = readFileSync16(filePath, "utf-8");
+  if (!existsSync17(filePath)) return [];
+  const content = readFileSync15(filePath, "utf-8");
   const executions = [];
   const entries = content.split(/\n---\n/);
   for (const entry of entries) {
@@ -9511,11 +9310,11 @@ function listExecutions(options = {}) {
   const squads = readdirSync8(memoryDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   for (const squad of squads) {
     if (filterSquad && squad !== filterSquad) continue;
-    const squadPath = join20(memoryDir, squad);
+    const squadPath = join19(memoryDir, squad);
     const agents = readdirSync8(squadPath, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const agent of agents) {
       if (filterAgent && agent !== filterAgent) continue;
-      const logPath = join20(squadPath, agent, "executions.md");
+      const logPath = join19(squadPath, agent, "executions.md");
       const agentExecutions = parseExecutionLog(logPath, squad, agent);
       executions.push(...agentExecutions);
     }
@@ -9765,12 +9564,12 @@ async function execStatsCommand(options = {}) {
 // src/commands/tonight.ts
 import ora7 from "ora";
 import fs2 from "fs/promises";
-import path2, { dirname as dirname6 } from "path";
-import { execSync as execSync14, spawn as spawn7 } from "child_process";
+import path2, { dirname as dirname5 } from "path";
+import { execSync as execSync13, spawn as spawn7 } from "child_process";
 function getProjectRoot2() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname6(dirname6(squadsDir));
+    return dirname5(dirname5(squadsDir));
   }
   return process.cwd();
 }
@@ -9789,10 +9588,10 @@ async function getCurrentCost() {
 }
 function killAllSessions() {
   try {
-    const sessions2 = execSync14('tmux ls 2>/dev/null | grep "squads-tonight-" | cut -d: -f1', { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    const sessions2 = execSync13('tmux ls 2>/dev/null | grep "squads-tonight-" | cut -d: -f1', { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
     for (const session2 of sessions2) {
       try {
-        execSync14(`tmux kill-session -t "${session2}"`, { stdio: "ignore" });
+        execSync13(`tmux kill-session -t "${session2}"`, { stdio: "ignore" });
       } catch {
       }
     }
@@ -9803,7 +9602,7 @@ function killAllSessions() {
 }
 function getRunningSessionCount() {
   try {
-    const output = execSync14('tmux ls 2>/dev/null | grep "squads-tonight-" | wc -l', { encoding: "utf-8" });
+    const output = execSync13('tmux ls 2>/dev/null | grep "squads-tonight-" | wc -l', { encoding: "utf-8" });
     return parseInt(output.trim()) || 0;
   } catch {
     return 0;
@@ -10018,7 +9817,7 @@ async function tonightStatusCommand() {
   }
   writeLine();
   try {
-    const sessions2 = execSync14("tmux ls 2>/dev/null | grep squads-tonight", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
+    const sessions2 = execSync13("tmux ls 2>/dev/null | grep squads-tonight", { encoding: "utf-8" }).trim().split("\n").filter(Boolean);
     if (sessions2.length > 0) {
       writeLine(`  ${colors.dim}Sessions:${RESET}`);
       for (const session2 of sessions2) {
@@ -10098,12 +9897,12 @@ process.stderr.on("error", (err) => {
   throw err;
 });
 var envPaths = [
-  join21(process.cwd(), ".env"),
-  join21(process.cwd(), "..", "hq", ".env"),
-  join21(homedir5(), "agents-squads", "hq", ".env")
+  join20(process.cwd(), ".env"),
+  join20(process.cwd(), "..", "hq", ".env"),
+  join20(homedir4(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync19(envPath)) {
+  if (existsSync18(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
@@ -10122,6 +9921,19 @@ program.name("squads").description("A CLI for humans and agents").version(versio
     process.exit(err.exitCode);
   }
   throw err;
+}).action(async () => {
+  const { gradient: gradient2, colors: colors2, RESET: RESET3 } = await import("./terminal-JZSAQSN7.js");
+  const { checkForUpdate: checkForUpdate2 } = await import("./update-MAY6EXFQ.js");
+  console.log();
+  console.log(`  ${gradient2("squads")} ${colors2.dim}v${version}${RESET3}`);
+  console.log();
+  const updateInfo = checkForUpdate2();
+  if (updateInfo.updateAvailable) {
+    console.log(`  ${colors2.cyan}\u2B06${RESET3} Update available: ${colors2.dim}${updateInfo.currentVersion}${RESET3} \u2192 ${colors2.green}${updateInfo.latestVersion}${RESET3}`);
+    console.log(`  ${colors2.dim}Run \`squads update\` to install${RESET3}`);
+    console.log();
+  }
+  await statusCommand(void 0, {});
 });
 program.command("init").description("Initialize a new squad project").option("-t, --template <template>", "Project template", "default").option("--skip-infra", "Skip infrastructure setup prompt").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").option("-t, --timeout <minutes>", "Execution timeout in minutes (default: 30)", "30").option("-p, --parallel", "Run all agents in parallel (N tmux sessions)").option("-l, --lead", "Lead mode: single orchestrator using Task tool for parallelization").option("-f, --foreground", "Run in foreground (no tmux, blocks terminal)").option("--use-api", "Use API credits instead of subscription").option("--effort <level>", "Effort level: high, medium, low (default: from SQUAD.md or high)").option("--skills <skills...>", "Skills to load (skill IDs or local paths)").action((target, options) => runCommand(target, { ...options, timeout: parseInt(options.timeout, 10) }));
@@ -10191,11 +10003,11 @@ sessions.command("history").description("Show session history and statistics").o
   json: options.json
 }));
 sessions.command("summary").description("Show pretty session summary (auto-detects current session or pass JSON)").option("-d, --data <json>", "JSON data for summary (overrides auto-detection)").option("-f, --file <path>", "Path to JSON file with summary data").option("-j, --json", "Output as JSON instead of pretty format").action(async (options) => {
-  const { buildCurrentSessionSummary } = await import("./sessions-B6GVXJ2H.js");
+  const { buildCurrentSessionSummary } = await import("./sessions-R4VWIGFR.js");
   let data;
   if (options.file) {
-    const { readFileSync: readFileSync17 } = await import("fs");
-    data = JSON.parse(readFileSync17(options.file, "utf-8"));
+    const { readFileSync: readFileSync16 } = await import("fs");
+    data = JSON.parse(readFileSync16(options.file, "utf-8"));
   } else if (options.data) {
     data = JSON.parse(options.data);
   } else if (!process.stdin.isTTY) {
@@ -10291,31 +10103,4 @@ try {
 } catch (error) {
   handleError(error);
 }
-if (!process.argv.slice(2).length) {
-  console.log(`
-${chalk4.bold.magenta("squads")} - AI agent squad management
-
-${chalk4.dim("Quick start:")}
-  ${chalk4.cyan("squads status")}                  View all squads status
-  ${chalk4.cyan("squads run <squad>")}             Run a squad
-  ${chalk4.cyan('squads memory query "<term>"')}   Search squad memory
-
-${chalk4.dim("Goals & Feedback:")}
-  ${chalk4.cyan('squads goal set <squad> "<goal>"')}    Set a goal
-  ${chalk4.cyan("squads goal list")}                    View active goals
-  ${chalk4.cyan('squads feedback add <squad> 4 "msg"')} Rate last execution
-
-${chalk4.dim("Smart Triggers:")}
-  ${chalk4.cyan("squads trigger list")}                 View all triggers
-  ${chalk4.cyan("squads trigger sync")}                 Sync from SQUAD.md
-  ${chalk4.cyan("squads trigger fire <name>")}          Manually fire trigger
-
-${chalk4.dim("Examples:")}
-  ${chalk4.cyan("squads run website")}                  Run website squad
-  ${chalk4.cyan('squads goal set finance "Track costs"')} Set finance goal
-  ${chalk4.cyan("squads trigger status")}               Scheduler health
-
-${chalk4.dim("Run")} ${chalk4.cyan("squads --help")} ${chalk4.dim("for all commands.")}
-`);
-}
 //# sourceMappingURL=cli.js.map