squads-cli 0.4.7 → 0.4.8

package/dist/cli.js

@@ -28,7 +28,7 @@ import {
   truncate,
   updateHeartbeat,
   writeLine
-} from "./chunk-EGOVJOZJ.js";
+} from "./chunk-IDZYXBZY.js";
 import {
   __require
 } from "./chunk-7OCVIDC7.js";
@@ -47,18 +47,227 @@ 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 execSync2, spawn } from "child_process";
+import { execSync as execSync3, spawn } from "child_process";
 import { createInterface } from "readline";
 
 // src/lib/git.ts
-import { execSync, exec } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
+import { execSync as execSync2, exec } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 function checkGitStatus(cwd = process.cwd()) {
@@ -68,12 +277,12 @@ function checkGitStatus(cwd = process.cwd()) {
     isDirty: false,
     uncommittedCount: 0
   };
-  if (!existsSync(join(cwd, ".git"))) {
+  if (!existsSync2(join2(cwd, ".git"))) {
     return status;
   }
   status.isGitRepo = true;
   try {
-    const combined = execSync(
+    const combined = execSync2(
       '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 }
     );
@@ -157,10 +366,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 = join(basePath, repo);
-    if (!existsSync(repoPath)) continue;
+    const repoPath = join2(basePath, repo);
+    if (!existsSync2(repoPath)) continue;
     try {
-      const output = execSync(
+      const output = execSync2(
         `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 }
       );
@@ -171,11 +380,11 @@ function getGitHubStatsOptimized(basePath, days = 30) {
       results.push({ repo, prs, issues });
     } catch {
       try {
-        const prsOutput = execSync(
+        const prsOutput = execSync2(
           `gh pr list --state all --json number,title,createdAt,mergedAt,labels --limit 50 2>/dev/null`,
           { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
         );
-        const issuesOutput = execSync(
+        const issuesOutput = execSync2(
           `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 }
         );
@@ -291,12 +500,12 @@ function getMultiRepoGitStats(basePath, days = 30) {
   };
   const allCommits = [];
   for (const repo of SQUAD_REPOS) {
-    const repoPath = join(basePath, repo);
-    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
+    const repoPath = join2(basePath, repo);
+    if (!existsSync2(repoPath) || !existsSync2(join2(repoPath, ".git"))) {
       continue;
     }
     try {
-      const logOutput = execSync(
+      const logOutput = execSync2(
         `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();
@@ -353,12 +562,12 @@ function getActivitySparkline(basePath, days = 7) {
     activity.push(0);
   }
   for (const repo of SQUAD_REPOS) {
-    const repoPath = join(basePath, repo);
-    if (!existsSync(repoPath) || !existsSync(join(repoPath, ".git"))) {
+    const repoPath = join2(basePath, repo);
+    if (!existsSync2(repoPath) || !existsSync2(join2(repoPath, ".git"))) {
       continue;
     }
     try {
-      const logOutput = execSync(
+      const logOutput = execSync2(
         `git log --since="${days} days ago" --format="%ad" --date=short 2>/dev/null`,
         { cwd: repoPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -378,13 +587,13 @@ function getActivitySparkline(basePath, days = 7) {
 }
 
 // src/lib/telemetry.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
+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 { randomUUID } from "crypto";
-var TELEMETRY_DIR = join2(homedir(), ".squads-cli");
-var CONFIG_PATH = join2(TELEMETRY_DIR, "telemetry.json");
-var EVENTS_PATH = join2(TELEMETRY_DIR, "events.json");
+var TELEMETRY_DIR = join3(homedir2(), ".squads-cli");
+var CONFIG_PATH = join3(TELEMETRY_DIR, "telemetry.json");
+var EVENTS_PATH = join3(TELEMETRY_DIR, "events.json");
 var TELEMETRY_ENDPOINT = Buffer.from(
   "aHR0cHM6Ly9zcXVhZHMtdGVsZW1ldHJ5LTk3ODg3MTgxNzYxMC51cy1jZW50cmFsMS5ydW4uYXBwL3Bpbmc=",
   "base64"
@@ -393,24 +602,24 @@ var TELEMETRY_KEY = Buffer.from("c3FfdGVsX3YxXzdmOGE5YjJjM2Q0ZTVmNmE=", "base64"
 var eventQueue = [];
 var flushScheduled = false;
 function ensureDir() {
-  if (!existsSync2(TELEMETRY_DIR)) {
-    mkdirSync(TELEMETRY_DIR, { recursive: true });
+  if (!existsSync3(TELEMETRY_DIR)) {
+    mkdirSync2(TELEMETRY_DIR, { recursive: true });
   }
 }
 function getConfig() {
   ensureDir();
-  if (!existsSync2(CONFIG_PATH)) {
+  if (!existsSync3(CONFIG_PATH)) {
     const config2 = {
       enabled: true,
       // Opt-out by default (common for CLIs)
       anonymousId: randomUUID(),
       firstRun: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync(CONFIG_PATH, JSON.stringify(config2, null, 2));
+    writeFileSync2(CONFIG_PATH, JSON.stringify(config2, null, 2));
     return config2;
   }
   try {
-    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
   } catch {
     return { enabled: false, anonymousId: "", firstRun: "" };
   }
@@ -470,9 +679,9 @@ async function flushEvents() {
 function storeEventLocally(event) {
   ensureDir();
   let events = [];
-  if (existsSync2(EVENTS_PATH)) {
+  if (existsSync3(EVENTS_PATH)) {
     try {
-      events = JSON.parse(readFileSync(EVENTS_PATH, "utf-8"));
+      events = JSON.parse(readFileSync2(EVENTS_PATH, "utf-8"));
     } catch {
       events = [];
     }
@@ -481,7 +690,7 @@ function storeEventLocally(event) {
   if (events.length > 1e3) {
     events = events.slice(-1e3);
   }
-  writeFileSync(EVENTS_PATH, JSON.stringify(events, null, 2));
+  writeFileSync2(EVENTS_PATH, JSON.stringify(events, null, 2));
 }
 var Events = {
   // Lifecycle
@@ -578,7 +787,7 @@ async function promptEmail() {
 }
 function commandExists(cmd) {
   try {
-    execSync2(`which ${cmd}`, { stdio: "ignore" });
+    execSync3(`which ${cmd}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -586,7 +795,7 @@ function commandExists(cmd) {
 }
 function dockerRunning() {
   try {
-    execSync2("docker info", { stdio: "ignore" });
+    execSync3("docker info", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -594,12 +803,12 @@ function dockerRunning() {
 }
 function checkClaudeAuth() {
   try {
-    execSync2("which claude", { stdio: "ignore" });
+    execSync3("which claude", { stdio: "ignore" });
   } catch {
     return { installed: false, loggedIn: false };
   }
   try {
-    const result = execSync2("claude --version", { stdio: "pipe" }).toString();
+    const result = execSync3("claude --version", { stdio: "pipe" }).toString();
     return { installed: true, loggedIn: result.includes("claude") };
   } catch {
     return { installed: true, loggedIn: false };
@@ -607,7 +816,7 @@ function checkClaudeAuth() {
 }
 function checkGhAuth() {
   try {
-    execSync2("gh auth status", { stdio: "ignore" });
+    execSync3("gh auth status", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -744,7 +953,7 @@ async function setupInfrastructure(cwd) {
     let allRunning = true;
     for (const service of services) {
       try {
-        execSync2(`docker ps --filter "name=${service}" --filter "status=running" -q`, { stdio: "pipe" });
+        execSync3(`docker ps --filter "name=${service}" --filter "status=running" -q`, { stdio: "pipe" });
       } catch {
         allRunning = false;
       }
@@ -1156,21 +1365,21 @@ squads goal list       # View goals
 // src/commands/run.ts
 import ora2 from "ora";
 import { spawn as spawn2 } from "child_process";
-import { join as join4, dirname } from "path";
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
 
 // src/lib/squad-parser.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, basename } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4, basename } from "path";
 import matter from "gray-matter";
 function findSquadsDir() {
   let dir = process.cwd();
   for (let i = 0; i < 5; i++) {
-    const squadsPath = join3(dir, ".agents", "squads");
-    if (existsSync3(squadsPath)) {
+    const squadsPath = join4(dir, ".agents", "squads");
+    if (existsSync4(squadsPath)) {
       return squadsPath;
     }
-    const parent = join3(dir, "..");
+    const parent = join4(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -1179,14 +1388,14 @@ function findSquadsDir() {
 function findProjectRoot() {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  return join3(squadsDir, "..", "..");
+  return join4(squadsDir, "..", "..");
 }
 function hasLocalInfraConfig() {
   const projectRoot = findProjectRoot();
   if (!projectRoot) return false;
-  const envPath = join3(projectRoot, ".env");
-  if (!existsSync3(envPath)) return false;
-  const content = readFileSync2(envPath, "utf-8");
+  const envPath = join4(projectRoot, ".env");
+  if (!existsSync4(envPath)) return false;
+  const content = readFileSync3(envPath, "utf-8");
   const infraKeys = ["LANGFUSE_", "SQUADS_BRIDGE", "SQUADS_POSTGRES", "SQUADS_REDIS"];
   return infraKeys.some((key) => content.includes(key));
 }
@@ -1195,8 +1404,8 @@ function listSquads(squadsDir) {
   const entries = readdirSync(squadsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && !entry.name.startsWith("_")) {
-      const squadFile = join3(squadsDir, entry.name, "SQUAD.md");
-      if (existsSync3(squadFile)) {
+      const squadFile = join4(squadsDir, entry.name, "SQUAD.md");
+      if (existsSync4(squadFile)) {
         squads.push(entry.name);
       }
     }
@@ -1207,8 +1416,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 = join3(squadsDir, dir);
-    if (!existsSync3(squadPath)) continue;
+    const squadPath = join4(squadsDir, dir);
+    if (!existsSync4(squadPath)) continue;
     const files = readdirSync(squadPath);
     for (const file of files) {
       if (file.endsWith(".md") && file !== "SQUAD.md") {
@@ -1217,7 +1426,7 @@ function listAgents(squadsDir, squadName) {
           name: agentName,
           role: `Agent in ${dir}`,
           trigger: "manual",
-          filePath: join3(squadPath, file)
+          filePath: join4(squadPath, file)
         });
       }
     }
@@ -1225,7 +1434,7 @@ function listAgents(squadsDir, squadName) {
   return agents;
 }
 function parseSquadFile(filePath) {
-  const rawContent = readFileSync2(filePath, "utf-8");
+  const rawContent = readFileSync3(filePath, "utf-8");
   const { data: frontmatter, content: bodyContent } = matter(rawContent);
   const fm = frontmatter;
   const lines = bodyContent.split("\n");
@@ -1346,20 +1555,20 @@ function parseSquadFile(filePath) {
 function loadSquad(squadName) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return null;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return null;
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return null;
   return parseSquadFile(squadFile);
 }
 function loadAgentDefinition(agentPath) {
-  if (!existsSync3(agentPath)) return "";
-  return readFileSync2(agentPath, "utf-8");
+  if (!existsSync4(agentPath)) return "";
+  return readFileSync3(agentPath, "utf-8");
 }
 function addGoalToSquad(squadName, goal2) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return false;
-  let content = readFileSync2(squadFile, "utf-8");
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return false;
+  let content = readFileSync3(squadFile, "utf-8");
   if (!content.includes("## Goals")) {
     const insertPoint = content.indexOf("## Dependencies");
     if (insertPoint > 0) {
@@ -1394,15 +1603,15 @@ function addGoalToSquad(squadName, goal2) {
 - [ ] ${goal2}` + content.slice(headerEnd);
     }
   }
-  writeFileSync2(squadFile, content);
+  writeFileSync3(squadFile, content);
   return true;
 }
 function updateGoalInSquad(squadName, goalIndex, updates) {
   const squadsDir = findSquadsDir();
   if (!squadsDir) return false;
-  const squadFile = join3(squadsDir, squadName, "SQUAD.md");
-  if (!existsSync3(squadFile)) return false;
-  const content = readFileSync2(squadFile, "utf-8");
+  const squadFile = join4(squadsDir, squadName, "SQUAD.md");
+  if (!existsSync4(squadFile)) return false;
+  const content = readFileSync3(squadFile, "utf-8");
   const lines = content.split("\n");
   let currentSection = "";
   let goalCount = 0;
@@ -1424,7 +1633,7 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
             }
           }
           lines[i] = newLine;
-          writeFileSync2(squadFile, lines.join("\n"));
+          writeFileSync3(squadFile, lines.join("\n"));
           return true;
         }
         goalCount++;
@@ -1673,7 +1882,7 @@ function generateExecutionId() {
 }
 function selectMcpConfig(squadName) {
   const home = process.env.HOME || "";
-  const configsDir = join4(home, ".claude", "mcp-configs");
+  const configsDir = join5(home, ".claude", "mcp-configs");
   const squadConfigs = {
     website: "website.json",
     // chrome-devtools, nano-banana
@@ -1688,12 +1897,12 @@ function selectMcpConfig(squadName) {
   };
   const configFile = squadConfigs[squadName.toLowerCase()];
   if (configFile) {
-    const configPath = join4(configsDir, configFile);
-    if (existsSync4(configPath)) {
+    const configPath = join5(configsDir, configFile);
+    if (existsSync5(configPath)) {
       return configPath;
     }
   }
-  return join4(home, ".claude.json");
+  return join5(home, ".claude.json");
 }
 function detectTaskType(agentName) {
   const name = agentName.toLowerCase();
@@ -1709,12 +1918,12 @@ function detectTaskType(agentName) {
   return "execution";
 }
 function ensureProjectTrusted(projectPath) {
-  const configPath = join4(process.env.HOME || "", ".claude.json");
-  if (!existsSync4(configPath)) {
+  const configPath = join5(process.env.HOME || "", ".claude.json");
+  if (!existsSync5(configPath)) {
     return;
   }
   try {
-    const config2 = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync4(configPath, "utf-8"));
     if (!config2.projects) {
       config2.projects = {};
     }
@@ -1723,7 +1932,7 @@ function ensureProjectTrusted(projectPath) {
     }
     if (!config2.projects[projectPath].hasTrustDialogAccepted) {
       config2.projects[projectPath].hasTrustDialogAccepted = true;
-      writeFileSync3(configPath, JSON.stringify(config2, null, 2));
+      writeFileSync4(configPath, JSON.stringify(config2, null, 2));
     }
   } catch {
   }
@@ -1731,25 +1940,25 @@ function ensureProjectTrusted(projectPath) {
 function getProjectRoot() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname(dirname(squadsDir));
+    return dirname2(dirname2(squadsDir));
   }
   return process.cwd();
 }
 function getExecutionLogPath(squadName, agentName) {
   const memoryDir = findMemoryDir();
   if (!memoryDir) return null;
-  return join4(memoryDir, squadName, agentName, "executions.md");
+  return join5(memoryDir, squadName, agentName, "executions.md");
 }
 function logExecution(record) {
   const logPath = getExecutionLogPath(record.squadName, record.agentName);
   if (!logPath) return;
-  const dir = dirname(logPath);
-  if (!existsSync4(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname2(logPath);
+  if (!existsSync5(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
   let content = "";
-  if (existsSync4(logPath)) {
-    content = readFileSync3(logPath, "utf-8").trimEnd();
+  if (existsSync5(logPath)) {
+    content = readFileSync4(logPath, "utf-8").trimEnd();
   } else {
     content = `# ${record.squadName}/${record.agentName} - Execution Log`;
   }
@@ -1762,12 +1971,12 @@ function logExecution(record) {
 - Trigger: ${record.trigger || "manual"}
 - Task Type: ${record.taskType || "execution"}
 `;
-  writeFileSync3(logPath, content + entry);
+  writeFileSync4(logPath, content + entry);
 }
 function updateExecutionStatus(squadName, agentName, executionId, status, details) {
   const logPath = getExecutionLogPath(squadName, agentName);
-  if (!logPath || !existsSync4(logPath)) return;
-  let content = readFileSync3(logPath, "utf-8");
+  if (!logPath || !existsSync5(logPath)) return;
+  let content = readFileSync4(logPath, "utf-8");
   const endTime = (/* @__PURE__ */ new Date()).toISOString();
   const execMarker = `<!-- exec:${executionId} -->`;
   const markerIndex = content.indexOf(execMarker);
@@ -1788,7 +1997,7 @@ function updateExecutionStatus(squadName, agentName, executionId, status, detail
 - Error: ${details.error}`;
   }
   content = content.slice(0, entryStart) + updatedEntry + content.slice(entryEnd);
-  writeFileSync3(logPath, content);
+  writeFileSync4(logPath, content);
 }
 function extractMcpServersFromDefinition(definition) {
   const servers = /* @__PURE__ */ new Set();
@@ -1867,8 +2076,8 @@ async function runSquad(squad, squadsDir, options) {
   if (options.parallel) {
     const agentFiles = squad.agents.map((a) => ({
       name: a.name,
-      path: join4(squadsDir, squad.name, `${a.name}.md`)
-    })).filter((a) => existsSync4(a.path));
+      path: join5(squadsDir, squad.name, `${a.name}.md`)
+    })).filter((a) => existsSync5(a.path));
     if (agentFiles.length === 0) {
       writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
       return;
@@ -1904,8 +2113,8 @@ async function runSquad(squad, squadsDir, options) {
     writeLine();
     for (let i = 0; i < pipeline.agents.length; i++) {
       const agentName = pipeline.agents[i];
-      const agentPath = join4(squadsDir, squad.name, `${agentName}.md`);
-      if (existsSync4(agentPath)) {
+      const agentPath = join5(squadsDir, squad.name, `${agentName}.md`);
+      if (existsSync5(agentPath)) {
         writeLine(`  ${colors.dim}[${i + 1}/${pipeline.agents.length}]${RESET}`);
         await runAgent(agentName, agentPath, squad.name, options);
         writeLine();
@@ -1915,8 +2124,8 @@ async function runSquad(squad, squadsDir, options) {
     }
   } else {
     if (options.agent) {
-      const agentPath = join4(squadsDir, squad.name, `${options.agent}.md`);
-      if (existsSync4(agentPath)) {
+      const agentPath = join5(squadsDir, squad.name, `${options.agent}.md`);
+      if (existsSync5(agentPath)) {
         await runAgent(options.agent, agentPath, squad.name, options);
       } else {
         writeLine(`  ${icons.error} ${colors.red}Agent ${options.agent} not found${RESET}`);
@@ -1927,8 +2136,8 @@ async function runSquad(squad, squadsDir, options) {
         (a) => a.name.includes("lead") || a.trigger === "Manual"
       );
       if (orchestrator) {
-        const agentPath = join4(squadsDir, squad.name, `${orchestrator.name}.md`);
-        if (existsSync4(agentPath)) {
+        const agentPath = join5(squadsDir, squad.name, `${orchestrator.name}.md`);
+        if (existsSync5(agentPath)) {
           await runAgent(orchestrator.name, agentPath, squad.name, options);
         }
       } else {
@@ -1954,9 +2163,9 @@ async function runLeadMode(squad, squadsDir, options) {
   if (!squad) return;
   const agentFiles = squad.agents.map((a) => ({
     name: a.name,
-    path: join4(squadsDir, squad.name, `${a.name}.md`),
+    path: join5(squadsDir, squad.name, `${a.name}.md`),
     role: a.role || ""
-  })).filter((a) => existsSync4(a.path));
+  })).filter((a) => existsSync5(a.path));
   if (agentFiles.length === 0) {
     writeLine(`  ${icons.error} ${colors.red}No agent files found${RESET}`);
     return;
@@ -2075,9 +2284,9 @@ async function runAgent(agentName, agentPath, squadName, options) {
   }
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    const squadFilePath = join4(squadsDir, squadName, "SQUAD.md");
-    if (existsSync4(squadFilePath)) {
-      const squadContent = readFileSync3(squadFilePath, "utf-8");
+    const squadFilePath = join5(squadsDir, squadName, "SQUAD.md");
+    if (existsSync5(squadFilePath)) {
+      const squadContent = readFileSync4(squadFilePath, "utf-8");
       const permContext = buildContextFromSquad(squadName, squadContent, agentName);
       const mcpServers = extractMcpServersFromDefinition(definition);
       const execRequest = {
@@ -2359,158 +2568,6 @@ async function listCommand(options) {
 // src/commands/status.ts
 import { existsSync as existsSync6, statSync } from "fs";
 import { join as join6 } from "path";
-
-// src/lib/update.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, unlinkSync } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
-import { execSync as execSync3 } from "child_process";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const __filename3 = fileURLToPath(import.meta.url);
-    const __dirname3 = dirname2(__filename3);
-    const possiblePaths = [
-      join5(__dirname3, "..", "..", "package.json"),
-      // From dist/lib/
-      join5(__dirname3, "..", "package.json"),
-      // From dist/
-      join5(__dirname3, "package.json")
-      // Same dir
-    ];
-    for (const pkgPath of possiblePaths) {
-      if (existsSync5(pkgPath)) {
-        const pkg2 = JSON.parse(readFileSync4(pkgPath, "utf-8"));
-        return pkg2.version || "0.0.0";
-      }
-    }
-  } catch {
-  }
-  return "0.0.0";
-}
-var CURRENT_VERSION = getPackageVersion();
-var CACHE_DIR = join5(homedir2(), ".squads");
-var CACHE_FILE = join5(CACHE_DIR, "update-check.json");
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-function isNewerVersion(v1, v2) {
-  const parts1 = v1.replace(/^v/, "").split(".").map(Number);
-  const parts2 = v2.replace(/^v/, "").split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const p1 = parts1[i] || 0;
-    const p2 = parts2[i] || 0;
-    if (p2 > p1) return true;
-    if (p2 < p1) return false;
-  }
-  return false;
-}
-function readCache() {
-  try {
-    if (!existsSync5(CACHE_FILE)) return null;
-    const data = JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
-    return data;
-  } catch {
-    return null;
-  }
-}
-function writeCache(latestVersion) {
-  try {
-    if (!existsSync5(CACHE_DIR)) {
-      mkdirSync3(CACHE_DIR, { recursive: true });
-    }
-    const cache = {
-      latestVersion,
-      checkedAt: Date.now()
-    };
-    writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-function fetchLatestVersion() {
-  try {
-    const result = execSync3("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 {
-    execSync3("npm update -g squads-cli", {
-      encoding: "utf-8",
-      stdio: "inherit",
-      timeout: 12e4
-      // 2 minutes
-    });
-    try {
-      unlinkSync(CACHE_FILE);
-    } catch {
-    }
-    return { success: true };
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : "Unknown error"
-    };
-  }
-}
-function refreshVersionCache() {
-  const latestVersion = fetchLatestVersion();
-  if (latestVersion) {
-    writeCache(latestVersion);
-    return {
-      currentVersion: CURRENT_VERSION,
-      latestVersion,
-      updateAvailable: isNewerVersion(CURRENT_VERSION, latestVersion)
-    };
-  }
-  return checkForUpdate();
-}
-
-// src/commands/status.ts
 async function statusCommand(squadName, options = {}) {
   await track(Events.CLI_STATUS, { squad: squadName || "all", verbose: options.verbose });
   const squadsDir = findSquadsDir();
@@ -10052,6 +10109,7 @@ for (const envPath of envPaths) {
   }
 }
 applyStackConfig();
+await autoUpdateOnStartup();
 registerExitHandler();
 var program = new Command();
 program.name("squads").description("A CLI for humans and agents").version(version).showSuggestionAfterError(true).configureOutput({
@@ -10133,7 +10191,7 @@ 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-SEITSWEV.js");
+  const { buildCurrentSessionSummary } = await import("./sessions-B6GVXJ2H.js");
   let data;
   if (options.file) {
     const { readFileSync: readFileSync17 } = await import("fs");