squads-cli 0.4.6 → 0.4.8

package/dist/cli.js

@@ -28,15 +28,15 @@ import {
   truncate,
   updateHeartbeat,
   writeLine
-} from "./chunk-G63RBKDH.js";
+} from "./chunk-IDZYXBZY.js";
 import {
   __require
 } from "./chunk-7OCVIDC7.js";
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync17 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join21 } from "path";
 import { homedir as homedir5 } from "os";
 import { Command } from "commander";
 import chalk4 from "chalk";
@@ -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 }
         );
@@ -286,15 +495,17 @@ function getMultiRepoGitStats(basePath, days = 30) {
     activeDays: 0,
     avgCommitsPerDay: 0,
     peakDay: null,
-    repos: []
+    repos: [],
+    recentCommits: []
   };
+  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();
@@ -303,7 +514,9 @@ function getMultiRepoGitStats(basePath, days = 30) {
       const authors = /* @__PURE__ */ new Set();
       let lastCommit = "";
       for (const line of commits) {
-        const [hash, author, date] = line.split("|");
+        const parts = line.split("|");
+        const [hash, author, date, ...messageParts] = parts;
+        const message = messageParts.join("|");
         if (!hash) continue;
         stats.totalCommits++;
         authors.add(author);
@@ -314,6 +527,7 @@ function getMultiRepoGitStats(basePath, days = 30) {
         stats.commitsByAuthor.set(author, authorCount + 1);
         const repoCount = stats.commitsByRepo.get(repo) || 0;
         stats.commitsByRepo.set(repo, repoCount + 1);
+        allCommits.push({ hash, author, date, message, repo });
       }
       stats.repos.push({
         name: repo,
@@ -338,6 +552,7 @@ function getMultiRepoGitStats(basePath, days = 30) {
   if (peakDate) {
     stats.peakDay = { date: peakDate, count: peakCount };
   }
+  stats.recentCommits = allCommits.sort((a, b) => b.date.localeCompare(a.date) || b.hash.localeCompare(a.hash)).slice(0, 5);
   return stats;
 }
 function getActivitySparkline(basePath, days = 7) {
@@ -347,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();
@@ -372,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"
@@ -387,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: "" };
   }
@@ -464,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 = [];
     }
@@ -475,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
@@ -487,6 +702,9 @@ var Events = {
   CLI_DASHBOARD: "cli.dashboard",
   CLI_WORKERS: "cli.workers",
   CLI_TONIGHT: "cli.tonight",
+  CLI_CONTEXT: "cli.context",
+  CLI_COST: "cli.cost",
+  CLI_EXEC: "cli.exec",
   // Goals
   CLI_GOAL_SET: "cli.goal.set",
   CLI_GOAL_LIST: "cli.goal.list",
@@ -569,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;
@@ -577,7 +795,7 @@ function commandExists(cmd) {
 }
 function dockerRunning() {
   try {
-    execSync2("docker info", { stdio: "ignore" });
+    execSync3("docker info", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -585,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 };
@@ -598,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;
@@ -735,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;
       }
@@ -1147,20 +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;
   }
@@ -1169,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));
 }
@@ -1185,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);
       }
     }
@@ -1197,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") {
@@ -1207,7 +1426,7 @@ function listAgents(squadsDir, squadName) {
           name: agentName,
           role: `Agent in ${dir}`,
           trigger: "manual",
-          filePath: join3(squadPath, file)
+          filePath: join4(squadPath, file)
         });
       }
     }
@@ -1215,17 +1434,24 @@ function listAgents(squadsDir, squadName) {
   return agents;
 }
 function parseSquadFile(filePath) {
-  const content = readFileSync2(filePath, "utf-8");
-  const lines = content.split("\n");
+  const rawContent = readFileSync3(filePath, "utf-8");
+  const { data: frontmatter, content: bodyContent } = matter(rawContent);
+  const fm = frontmatter;
+  const lines = bodyContent.split("\n");
   const squad = {
-    name: basename(filePath).replace(".md", ""),
-    mission: "",
+    name: fm.name || basename(filePath).replace(".md", ""),
+    mission: fm.mission || "",
     agents: [],
     pipelines: [],
     triggers: { scheduled: [], event: [], manual: [] },
     dependencies: [],
     outputPath: "",
-    goals: []
+    goals: [],
+    // Apply frontmatter fields
+    effort: fm.effort,
+    context: fm.context,
+    repo: fm.repo,
+    stack: fm.stack
   };
   let currentSection = "";
   let inTable = false;
@@ -1245,6 +1471,10 @@ function parseSquadFile(filePath) {
         squad.mission = line.trim();
       }
     }
+    const effortMatch = line.match(/^effort:\s*(high|medium|low)/i);
+    if (effortMatch && !squad.effort) {
+      squad.effort = effortMatch[1].toLowerCase();
+    }
     if (currentSection.includes("agent") || currentSection.includes("orchestrator") || currentSection.includes("evaluator") || currentSection.includes("builder") || currentSection.includes("priority")) {
       if (line.includes("|") && line.includes("Agent")) {
         inTable = true;
@@ -1257,12 +1487,16 @@ function parseSquadFile(filePath) {
         const roleIdx = tableHeaders.findIndex((h) => h === "role");
         const triggerIdx = tableHeaders.findIndex((h) => h === "trigger");
         const statusIdx = tableHeaders.findIndex((h) => h === "status");
+        const effortIdx = tableHeaders.findIndex((h) => h === "effort");
         if (agentIdx >= 0 && cells[agentIdx]) {
+          const effortValue = effortIdx >= 0 ? cells[effortIdx]?.toLowerCase() : void 0;
+          const effort = ["high", "medium", "low"].includes(effortValue || "") ? effortValue : void 0;
           squad.agents.push({
             name: cells[agentIdx],
             role: roleIdx >= 0 ? cells[roleIdx] : "",
             trigger: triggerIdx >= 0 ? cells[triggerIdx] : "manual",
-            status: statusIdx >= 0 ? cells[statusIdx] : "active"
+            status: statusIdx >= 0 ? cells[statusIdx] : "active",
+            effort
           });
         }
       }
@@ -1321,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) {
@@ -1369,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;
@@ -1399,7 +1633,7 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
             }
           }
           lines[i] = newLine;
-          writeFileSync2(squadFile, lines.join("\n"));
+          writeFileSync3(squadFile, lines.join("\n"));
           return true;
         }
         goalCount++;
@@ -1409,14 +1643,287 @@ function updateGoalInSquad(squadName, goalIndex, updates) {
   return false;
 }
 
+// src/lib/permissions.ts
+import { minimatch } from "minimatch";
+function getDefaultContext(squad, agent) {
+  return {
+    squad,
+    agent,
+    permissions: {
+      mode: "warn",
+      bash: ["*"],
+      // All commands allowed by default
+      write: ["**"],
+      // All paths writable by default
+      read: ["**"],
+      // All paths readable by default
+      mcp: {
+        allow: ["*"],
+        // All MCP servers allowed
+        deny: []
+      }
+    }
+  };
+}
+function validateBashCommand(command, allowedCommands) {
+  const baseCommand = command.trim().split(/\s+/)[0];
+  if (allowedCommands.includes("*")) {
+    return null;
+  }
+  const isAllowed = allowedCommands.some((allowed) => {
+    if (allowed === baseCommand) return true;
+    if (allowed.includes("*")) {
+      return minimatch(baseCommand, allowed);
+    }
+    return false;
+  });
+  if (!isAllowed) {
+    return {
+      type: "bash",
+      requested: baseCommand,
+      reason: `Bash command '${baseCommand}' not in allowlist: [${allowedCommands.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateFilePath(path3, allowedGlobs, operation) {
+  if (allowedGlobs.includes("**") || allowedGlobs.includes("*")) {
+    return null;
+  }
+  const isAllowed = allowedGlobs.some((glob) => minimatch(path3, glob));
+  if (!isAllowed) {
+    return {
+      type: operation,
+      requested: path3,
+      reason: `${operation === "write" ? "Write" : "Read"} to '${path3}' not allowed. Permitted paths: [${allowedGlobs.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateMcpServer(server, allow, deny) {
+  const isDenied = deny.some((pattern) => {
+    if (pattern === server) return true;
+    if (pattern.includes("*")) return minimatch(server, pattern);
+    return false;
+  });
+  if (isDenied) {
+    return {
+      type: "mcp",
+      requested: server,
+      reason: `MCP server '${server}' is explicitly denied`,
+      severity: "error"
+    };
+  }
+  if (allow.includes("*")) {
+    return null;
+  }
+  const isAllowed = allow.some((pattern) => {
+    if (pattern === server) return true;
+    if (pattern.includes("*")) return minimatch(server, pattern);
+    return false;
+  });
+  if (!isAllowed) {
+    return {
+      type: "mcp",
+      requested: server,
+      reason: `MCP server '${server}' not in allowlist: [${allow.join(", ")}]`,
+      severity: "error"
+    };
+  }
+  return null;
+}
+function validateExecution(context2, request) {
+  const violations = [];
+  if (request.bashCommands) {
+    for (const cmd of request.bashCommands) {
+      const violation = validateBashCommand(cmd, context2.permissions.bash);
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.writePaths) {
+    for (const path3 of request.writePaths) {
+      const violation = validateFilePath(path3, context2.permissions.write, "write");
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.readPaths) {
+    for (const path3 of request.readPaths) {
+      const violation = validateFilePath(path3, context2.permissions.read, "read");
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  if (request.mcpServers) {
+    for (const server of request.mcpServers) {
+      const violation = validateMcpServer(
+        server,
+        context2.permissions.mcp.allow,
+        context2.permissions.mcp.deny
+      );
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+  }
+  const hasErrors = violations.some((v) => v.severity === "error");
+  const allowed = context2.permissions.mode !== "strict" || !hasErrors;
+  return {
+    allowed,
+    violations,
+    mode: context2.permissions.mode
+  };
+}
+function formatViolations(result) {
+  const lines = [];
+  if (result.violations.length === 0) {
+    return lines;
+  }
+  const modeLabel = {
+    warn: "\u26A0\uFE0F  PERMISSION WARNING",
+    strict: "\u{1F6AB} PERMISSION DENIED",
+    audit: "\u{1F4DD} PERMISSION AUDIT"
+  }[result.mode];
+  lines.push(modeLabel);
+  lines.push("");
+  for (const v of result.violations) {
+    const icon = v.severity === "error" ? "\u2717" : "\u26A0";
+    lines.push(`  ${icon} [${v.type}] ${v.reason}`);
+  }
+  if (result.mode === "warn") {
+    lines.push("");
+    lines.push("  Continuing with warnings (mode: warn)");
+  } else if (result.mode === "audit") {
+    lines.push("");
+    lines.push("  Logged for audit, continuing (mode: audit)");
+  } else if (!result.allowed) {
+    lines.push("");
+    lines.push("  Execution blocked (mode: strict)");
+  }
+  return lines;
+}
+function parsePermissionsYaml(content) {
+  const yamlMatch = content.match(/```ya?ml\n([\s\S]*?)```/);
+  if (!yamlMatch) return null;
+  const yamlContent = yamlMatch[1];
+  const permissions = {};
+  const modeMatch = yamlContent.match(/^\s*mode:\s*(warn|strict|audit)/m);
+  if (modeMatch) {
+    permissions.mode = modeMatch[1];
+  }
+  const bashMatch = yamlContent.match(/^\s*bash:\s*\[(.*?)\]/m);
+  if (bashMatch) {
+    permissions.bash = bashMatch[1].split(",").map((s) => s.trim());
+  }
+  const writeMatch = yamlContent.match(/^\s*write:\s*\[(.*?)\]/m);
+  if (writeMatch) {
+    permissions.write = writeMatch[1].split(",").map((s) => s.trim());
+  }
+  const readMatch = yamlContent.match(/^\s*read:\s*\[(.*?)\]/m);
+  if (readMatch) {
+    permissions.read = readMatch[1].split(",").map((s) => s.trim());
+  }
+  const mcpAllowMatch = yamlContent.match(/^\s*allow:\s*\[(.*?)\]/m);
+  const mcpDenyMatch = yamlContent.match(/^\s*deny:\s*\[(.*?)\]/m);
+  if (mcpAllowMatch || mcpDenyMatch) {
+    permissions.mcp = {
+      allow: mcpAllowMatch ? mcpAllowMatch[1].split(",").map((s) => s.trim()) : ["*"],
+      deny: mcpDenyMatch ? mcpDenyMatch[1].split(",").map((s) => s.trim()) : []
+    };
+  }
+  return Object.keys(permissions).length > 0 ? permissions : null;
+}
+function buildContextFromSquad(squadName, squadContent, agentName) {
+  const context2 = getDefaultContext(squadName, agentName);
+  const parsed = parsePermissionsYaml(squadContent);
+  if (parsed) {
+    if (parsed.mode) context2.permissions.mode = parsed.mode;
+    if (parsed.bash) context2.permissions.bash = parsed.bash;
+    if (parsed.write) context2.permissions.write = parsed.write;
+    if (parsed.read) context2.permissions.read = parsed.read;
+    if (parsed.mcp) context2.permissions.mcp = parsed.mcp;
+  }
+  return context2;
+}
+
 // src/commands/run.ts
+async function registerContextWithBridge(ctx) {
+  const bridgeUrl = process.env.SQUADS_BRIDGE_URL || "http://localhost:8088";
+  try {
+    const response = await fetch(`${bridgeUrl}/api/context/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        execution_id: ctx.executionId,
+        squad: ctx.squad,
+        agent: ctx.agent,
+        task_type: ctx.taskType,
+        trigger: ctx.trigger
+      })
+    });
+    if (!response.ok) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateExecutionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `exec_${timestamp}_${random}`;
+}
+function selectMcpConfig(squadName) {
+  const home = process.env.HOME || "";
+  const configsDir = join5(home, ".claude", "mcp-configs");
+  const squadConfigs = {
+    website: "website.json",
+    // chrome-devtools, nano-banana
+    research: "research.json",
+    // x-mcp
+    intelligence: "research.json",
+    // x-mcp
+    analytics: "data.json",
+    // supabase, grafana, ga4-admin
+    engineering: "data.json"
+    // supabase, grafana
+  };
+  const configFile = squadConfigs[squadName.toLowerCase()];
+  if (configFile) {
+    const configPath = join5(configsDir, configFile);
+    if (existsSync5(configPath)) {
+      return configPath;
+    }
+  }
+  return join5(home, ".claude.json");
+}
+function detectTaskType(agentName) {
+  const name = agentName.toLowerCase();
+  if (name.includes("eval") || name.includes("critic") || name.includes("review") || name.includes("test")) {
+    return "evaluation";
+  }
+  if (name.includes("lead") || name.includes("orchestrator")) {
+    return "lead";
+  }
+  if (name.includes("research") || name.includes("analyst") || name.includes("intel")) {
+    return "research";
+  }
+  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 = {};
     }
@@ -1425,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 {
   }
@@ -1433,51 +1940,92 @@ 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");
+  if (existsSync5(logPath)) {
+    content = readFileSync4(logPath, "utf-8").trimEnd();
   } else {
-    content = `# ${record.squadName}/${record.agentName} - Execution Log
-
-`;
+    content = `# ${record.squadName}/${record.agentName} - Execution Log`;
   }
   const entry = `
+
 ---
+<!-- exec:${record.executionId} -->
 **${record.startTime}** | Status: ${record.status}
-${record.endTime ? `Completed: ${record.endTime}` : ""}
-${record.outcome ? `Outcome: ${record.outcome}` : ""}
+- ID: \`${record.executionId}\`
+- Trigger: ${record.trigger || "manual"}
+- Task Type: ${record.taskType || "execution"}
 `;
-  writeFileSync3(logPath, content + entry);
+  writeFileSync4(logPath, content + entry);
 }
-function updateExecutionStatus(squadName, agentName, status, outcome) {
+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();
-  content = content.replace(
-    /Status: running\n$/,
-    `Status: ${status}
-Completed: ${endTime}
-${outcome ? `Outcome: ${outcome}
-` : ""}`
-  );
-  writeFileSync3(logPath, content);
+  const execMarker = `<!-- exec:${executionId} -->`;
+  const markerIndex = content.indexOf(execMarker);
+  if (markerIndex === -1) return;
+  const nextEntryIndex = content.indexOf("\n---\n", markerIndex + 1);
+  const entryEnd = nextEntryIndex === -1 ? content.length : nextEntryIndex;
+  const entryStart = content.lastIndexOf("\n---\n", markerIndex);
+  const currentEntry = content.slice(entryStart, entryEnd);
+  const durationStr = details?.durationMs ? `${(details.durationMs / 1e3).toFixed(1)}s` : "unknown";
+  let updatedEntry = currentEntry.replace(/Status: running/, `Status: ${status}`) + `- Completed: ${endTime}
+- Duration: ${durationStr}`;
+  if (details?.outcome) {
+    updatedEntry += `
+- Outcome: ${details.outcome}`;
+  }
+  if (details?.error) {
+    updatedEntry += `
+- Error: ${details.error}`;
+  }
+  content = content.slice(0, entryStart) + updatedEntry + content.slice(entryEnd);
+  writeFileSync4(logPath, content);
+}
+function extractMcpServersFromDefinition(definition) {
+  const servers = /* @__PURE__ */ new Set();
+  const knownServers = [
+    "chrome-devtools",
+    "firecrawl",
+    "supabase",
+    "grafana",
+    "context7",
+    "huggingface",
+    "nano-banana"
+  ];
+  for (const server of knownServers) {
+    if (definition.toLowerCase().includes(server)) {
+      servers.add(server);
+    }
+  }
+  const mcpMatch = definition.match(/mcp:\s*\n((?:\s*-\s*\S+\s*\n?)+)/i);
+  if (mcpMatch) {
+    const lines = mcpMatch[1].split("\n");
+    for (const line of lines) {
+      const serverMatch = line.match(/^\s*-\s*(\S+)/);
+      if (serverMatch) {
+        servers.add(serverMatch[1]);
+      }
+    }
+  }
+  return Array.from(servers);
 }
 async function runCommand(target, options) {
   const squadsDir = findSquadsDir();
@@ -1508,6 +2056,9 @@ async function runCommand(target, options) {
 }
 async function runSquad(squad, squadsDir, options) {
   if (!squad) return;
+  if (!options.effort && squad.effort) {
+    options.effort = squad.effort;
+  }
   const startTime = (/* @__PURE__ */ new Date()).toISOString();
   writeLine();
   writeLine(`  ${gradient("squads")} ${colors.dim}run${RESET} ${colors.cyan}${squad.name}${RESET}`);
@@ -1525,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;
@@ -1562,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();
@@ -1573,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}`);
@@ -1585,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 {
@@ -1612,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;
@@ -1697,7 +2248,7 @@ Begin by assessing pending work, then delegate to agents via Task tool.`;
   writeLine(`  ${gradient("Launching")} lead session${options.foreground ? " (foreground)" : ""}...`);
   writeLine();
   try {
-    const result = await executeWithClaude(prompt2, options.verbose, timeoutMins, options.foreground, options.useApi);
+    const result = await executeWithClaude(prompt2, options.verbose, timeoutMins, options.foreground, options.useApi, options.effort, options.skills, options.trigger || "manual");
     if (options.foreground) {
       writeLine();
       writeLine(`  ${icons.success} Lead session completed`);
@@ -1718,7 +2269,10 @@ Begin by assessing pending work, then delegate to agents via Task tool.`;
 }
 async function runAgent(agentName, agentPath, squadName, options) {
   const spinner = ora2(`Running agent: ${agentName}`).start();
-  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  const startMs = Date.now();
+  const startTime = new Date(startMs).toISOString();
+  const executionId = generateExecutionId();
+  const taskType = detectTaskType(agentName);
   const definition = loadAgentDefinition(agentPath);
   if (options.dryRun) {
     spinner.info(`[DRY RUN] Would run ${agentName}`);
@@ -1728,11 +2282,40 @@ async function runAgent(agentName, agentPath, squadName, options) {
     }
     return;
   }
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    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 = {
+        mcpServers
+      };
+      const permResult = validateExecution(permContext, execRequest);
+      if (permResult.violations.length > 0) {
+        spinner.stop();
+        const violationLines = formatViolations(permResult);
+        for (const line of violationLines) {
+          writeLine(`  ${line}`);
+        }
+        writeLine();
+        if (!permResult.allowed) {
+          writeLine(`  ${colors.red}Execution blocked due to permission violations.${RESET}`);
+          writeLine(`  ${colors.dim}Configure permissions in ${squadFilePath}${RESET}`);
+          return;
+        }
+      }
+    }
+  }
   logExecution({
     squadName,
     agentName,
+    executionId,
     startTime,
-    status: "running"
+    status: "running",
+    trigger: options.trigger || "manual",
+    taskType
   });
   const timeoutMins = options.timeout || 30;
   const prompt2 = `Execute the ${agentName} agent from squad ${squadName}.
@@ -1764,7 +2347,7 @@ CRITICAL: When you have completed your tasks OR reached the time limit:
   if (options.execute && claudeAvailable) {
     spinner.text = options.foreground ? `Running ${agentName} in foreground...` : `Launching ${agentName} as background task...`;
     try {
-      const result = await executeWithClaude(prompt2, options.verbose, options.timeout || 30, options.foreground, options.useApi);
+      const result = await executeWithClaude(prompt2, options.verbose, options.timeout || 30, options.foreground, options.useApi, options.effort, options.skills, options.trigger || "manual");
       if (options.foreground) {
         spinner.succeed(`Agent ${agentName} completed`);
       } else {
@@ -1776,7 +2359,10 @@ CRITICAL: When you have completed your tasks OR reached the time limit:
       }
     } catch (error) {
       spinner.fail(`Agent ${agentName} failed to launch`);
-      updateExecutionStatus(squadName, agentName, "failed", String(error));
+      updateExecutionStatus(squadName, agentName, executionId, "failed", {
+        error: String(error),
+        durationMs: Date.now() - startMs
+      });
       writeLine(`  ${colors.red}${String(error)}${RESET}`);
     }
   } else {
@@ -1802,28 +2388,45 @@ async function checkClaudeCliAvailable() {
     check.on("error", () => resolve(false));
   });
 }
-async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foreground, useApi) {
-  const userConfigPath = join4(process.env.HOME || "", ".claude.json");
+async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foreground, useApi, effort, skills, trigger = "manual") {
   const projectRoot = getProjectRoot();
   ensureProjectTrusted(projectRoot);
   const squadMatch = prompt2.match(/squad (\w+)/);
   const agentMatch = prompt2.match(/(\w+) agent/);
   const squadName = process.env.SQUADS_SQUAD || squadMatch?.[1] || "unknown";
   const agentName = process.env.SQUADS_AGENT || agentMatch?.[1] || "unknown";
+  const mcpConfigPath = selectMcpConfig(squadName);
+  const execContext = {
+    squad: squadName,
+    agent: agentName,
+    taskType: detectTaskType(agentName),
+    trigger,
+    executionId: generateExecutionId()
+  };
   const { ANTHROPIC_API_KEY: _apiKey, ...envWithoutApiKey } = process.env;
   const spawnEnv = useApi ? process.env : envWithoutApiKey;
   const escapedPrompt = prompt2.replace(/'/g, "'\\''");
+  await registerContextWithBridge(execContext);
   if (foreground) {
     if (verbose) {
       writeLine(`  ${colors.dim}Project: ${projectRoot}${RESET}`);
       writeLine(`  ${colors.dim}Mode: foreground${RESET}`);
       writeLine(`  ${colors.dim}Auth: ${useApi ? "API credits" : "subscription"}${RESET}`);
+      writeLine(`  ${colors.dim}Execution: ${execContext.executionId}${RESET}`);
+      writeLine(`  ${colors.dim}Task type: ${execContext.taskType}${RESET}`);
+      writeLine(`  ${colors.dim}Trigger: ${execContext.trigger}${RESET}`);
+      if (effort) {
+        writeLine(`  ${colors.dim}Effort: ${effort}${RESET}`);
+      }
+      if (skills && skills.length > 0) {
+        writeLine(`  ${colors.dim}Skills: ${skills.join(", ")}${RESET}`);
+      }
     }
     return new Promise((resolve, reject) => {
       const claude = spawn2("claude", [
         "--dangerously-skip-permissions",
         "--mcp-config",
-        userConfigPath,
+        mcpConfigPath,
         "--",
         prompt2
       ], {
@@ -1831,8 +2434,17 @@ async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foregro
         cwd: projectRoot,
         env: {
           ...spawnEnv,
-          SQUADS_SQUAD: squadName,
-          SQUADS_AGENT: agentName
+          // Telemetry context for per-agent cost tracking
+          SQUADS_SQUAD: execContext.squad,
+          SQUADS_AGENT: execContext.agent,
+          SQUADS_TASK_TYPE: execContext.taskType,
+          SQUADS_TRIGGER: execContext.trigger,
+          SQUADS_EXECUTION_ID: execContext.executionId,
+          // OTel resource attributes for telemetry pipeline
+          OTEL_RESOURCE_ATTRIBUTES: `squads.squad=${execContext.squad},squads.agent=${execContext.agent},squads.task_type=${execContext.taskType},squads.trigger=${execContext.trigger},squads.execution_id=${execContext.executionId}`,
+          // Claude-specific options
+          ...effort && { CLAUDE_EFFORT: effort },
+          ...skills && skills.length > 0 && { CLAUDE_SKILLS: skills.join(",") }
         }
       });
       claude.on("close", (code) => {
@@ -1851,9 +2463,19 @@ async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foregro
   if (verbose) {
     writeLine(`  ${colors.dim}Project: ${projectRoot}${RESET}`);
     writeLine(`  ${colors.dim}Session: ${sessionName}${RESET}`);
+    writeLine(`  ${colors.dim}MCP config: ${mcpConfigPath}${RESET}`);
     writeLine(`  ${colors.dim}Auth: ${useApi ? "API credits" : "subscription"}${RESET}`);
+    writeLine(`  ${colors.dim}Execution: ${execContext.executionId}${RESET}`);
+    writeLine(`  ${colors.dim}Task type: ${execContext.taskType}${RESET}`);
+    writeLine(`  ${colors.dim}Trigger: ${execContext.trigger}${RESET}`);
+    if (effort) {
+      writeLine(`  ${colors.dim}Effort: ${effort}${RESET}`);
+    }
+    if (skills && skills.length > 0) {
+      writeLine(`  ${colors.dim}Skills: ${skills.join(", ")}${RESET}`);
+    }
   }
-  const claudeCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions --mcp-config '${userConfigPath}' -- '${escapedPrompt}'; tmux kill-session -t ${sessionName} 2>/dev/null`;
+  const claudeCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions --mcp-config '${mcpConfigPath}' -- '${escapedPrompt}'; tmux kill-session -t ${sessionName} 2>/dev/null`;
   const tmux = spawn2("tmux", [
     "new-session",
     "-d",
@@ -1873,8 +2495,17 @@ async function executeWithClaude(prompt2, verbose, _timeoutMinutes = 30, foregro
     detached: true,
     env: {
       ...spawnEnv,
-      SQUADS_SQUAD: squadName,
-      SQUADS_AGENT: agentName
+      // Telemetry context for per-agent cost tracking
+      SQUADS_SQUAD: execContext.squad,
+      SQUADS_AGENT: execContext.agent,
+      SQUADS_TASK_TYPE: execContext.taskType,
+      SQUADS_TRIGGER: execContext.trigger,
+      SQUADS_EXECUTION_ID: execContext.executionId,
+      // OTel resource attributes for telemetry pipeline
+      OTEL_RESOURCE_ATTRIBUTES: `squads.squad=${execContext.squad},squads.agent=${execContext.agent},squads.task_type=${execContext.taskType},squads.trigger=${execContext.trigger},squads.execution_id=${execContext.executionId}`,
+      // Claude-specific options
+      ...effort && { CLAUDE_EFFORT: effort },
+      ...skills && skills.length > 0 && { CLAUDE_SKILLS: skills.join(",") }
     }
   });
   tmux.unref();
@@ -1937,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();
@@ -4705,9 +5184,9 @@ function getPool() {
 async function isDatabaseAvailable() {
   try {
     const pool2 = getPool();
-    const client = await pool2.connect();
-    await client.query("SELECT 1");
-    client.release();
+    const client2 = await pool2.connect();
+    await client2.query("SELECT 1");
+    client2.release();
     return true;
   } catch (err) {
     if (process.env.DEBUG) {
@@ -4719,8 +5198,8 @@ async function isDatabaseAvailable() {
 async function saveDashboardSnapshot(snapshot) {
   try {
     const pool2 = getPool();
-    const client = await pool2.connect();
-    const result = await client.query(`
+    const client2 = await pool2.connect();
+    const result = await client2.query(`
       INSERT INTO squads.dashboard_snapshots (
         total_squads, total_commits, total_prs_merged, total_issues_closed, total_issues_open,
         goal_progress_pct, cost_usd, daily_budget_usd, input_tokens, output_tokens,
@@ -4749,7 +5228,7 @@ async function saveDashboardSnapshot(snapshot) {
       JSON.stringify(snapshot.authorsData),
       JSON.stringify(snapshot.reposData)
     ]);
-    client.release();
+    client2.release();
     return result.rows[0]?.id ?? null;
   } catch (err) {
     if (process.env.DEBUG) {
@@ -4760,8 +5239,8 @@ async function saveDashboardSnapshot(snapshot) {
 }
 async function getDashboardHistory(limit = 30) {
   try {
-    const client = await getPool().connect();
-    const result = await client.query(`
+    const client2 = await getPool().connect();
+    const result = await client2.query(`
       SELECT
         total_squads, total_commits, total_prs_merged, total_issues_closed, total_issues_open,
         goal_progress_pct, cost_usd, daily_budget_usd, input_tokens, output_tokens,
@@ -4771,7 +5250,7 @@ async function getDashboardHistory(limit = 30) {
       ORDER BY captured_at DESC
       LIMIT $1
     `, [limit]);
-    client.release();
+    client2.release();
     return result.rows.map((row) => ({
       totalSquads: row.total_squads,
       totalCommits: row.total_commits,
@@ -5001,16 +5480,50 @@ async function dashboardCommand(options = {}) {
   renderAcquisitionCached(cache);
   renderHistoricalTrendsCached(cache);
   renderInsightsCached(cache);
+  if (gitStats && gitStats.recentCommits && gitStats.recentCommits.length > 0) {
+    writeLine(`  ${bold}Working On${RESET}`);
+    writeLine();
+    for (const commit of gitStats.recentCommits.slice(0, 3)) {
+      const shortHash = commit.hash.slice(0, 7);
+      const shortMsg = truncate(commit.message, 45);
+      writeLine(`  ${colors.dim}${shortHash}${RESET} ${shortMsg} ${colors.dim}(${commit.repo})${RESET}`);
+    }
+    writeLine();
+  }
   const allActiveGoals = squadData.flatMap(
     (s) => s.goals.filter((g) => !g.completed).map((g) => ({ squad: s.name, goal: g }))
   );
   if (allActiveGoals.length > 0) {
-    writeLine(`  ${bold}Goals${RESET}`);
+    const activeSquads2 = new Set(gitStats?.recentCommits?.map((c) => {
+      const repoSquadMap = {
+        "agents-squads-web": "website",
+        "squads-cli": "cli",
+        "hq": "engineering",
+        "company": "company",
+        "product": "product",
+        "research": "research",
+        "intelligence": "intelligence",
+        "customer": "customer",
+        "finance": "finance",
+        "marketing": "marketing"
+      };
+      return repoSquadMap[c.repo] || c.repo;
+    }) || []);
+    const sortedGoals = [...allActiveGoals].sort((a, b) => {
+      const aActive = activeSquads2.has(a.squad) ? 1 : 0;
+      const bActive = activeSquads2.has(b.squad) ? 1 : 0;
+      if (aActive !== bActive) return bActive - aActive;
+      const aHasProgress = a.goal.progress ? 1 : 0;
+      const bHasProgress = b.goal.progress ? 1 : 0;
+      return bHasProgress - aHasProgress;
+    });
+    writeLine(`  ${bold}Goals${RESET} ${colors.dim}(${allActiveGoals.length} active)${RESET}`);
     writeLine();
-    const maxGoals = 6;
-    for (const { squad, goal: goal2 } of allActiveGoals.slice(0, maxGoals)) {
+    const maxGoals = 3;
+    for (const { squad, goal: goal2 } of sortedGoals.slice(0, maxGoals)) {
       const hasProgress = goal2.progress && goal2.progress.length > 0;
-      const icon = hasProgress ? icons.progress : icons.empty;
+      const isActive = activeSquads2.has(squad);
+      const icon = isActive ? icons.active : hasProgress ? icons.progress : icons.empty;
       writeLine(`  ${icon} ${colors.dim}${squad}${RESET} ${truncate(goal2.description, 48)}`);
       if (hasProgress) {
         writeLine(`    ${colors.dim}\u2514${RESET} ${colors.green}${truncate(goal2.progress, 52)}${RESET}`);
@@ -6611,12 +7124,12 @@ function formatDuration(ms) {
 }
 function groupByDate(executions) {
   const groups = /* @__PURE__ */ new Map();
-  for (const exec2 of executions) {
-    const dateKey = exec2.startedAt.toISOString().split("T")[0];
+  for (const exec3 of executions) {
+    const dateKey = exec3.startedAt.toISOString().split("T")[0];
     if (!groups.has(dateKey)) {
       groups.set(dateKey, []);
     }
-    groups.get(dateKey).push(exec2);
+    groups.get(dateKey).push(exec3);
   }
   return groups;
 }
@@ -6647,13 +7160,13 @@ async function historyCommand(options = {}) {
   ]);
   const seenIds = /* @__PURE__ */ new Set();
   const allExecutions = [];
-  for (const exec2 of bridgeExecs) {
-    seenIds.add(exec2.id);
-    allExecutions.push(exec2);
+  for (const exec3 of bridgeExecs) {
+    seenIds.add(exec3.id);
+    allExecutions.push(exec3);
   }
-  for (const exec2 of localExecs) {
-    if (!seenIds.has(exec2.id)) {
-      allExecutions.push(exec2);
+  for (const exec3 of localExecs) {
+    if (!seenIds.has(exec3.id)) {
+      allExecutions.push(exec3);
     }
   }
   allExecutions.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
@@ -6677,14 +7190,14 @@ async function historyCommand(options = {}) {
     writeLine(`  ${colors.purple}\u250C${"\u2500".repeat(60)}\u2510${RESET}`);
     writeLine(`  ${colors.purple}\u2502${RESET} ${padEnd("TIME", 7)}${padEnd("SQUAD", 13)}${padEnd("AGENT", 16)}${padEnd("DURATION", 10)}${padEnd("STATUS", 8)}${colors.purple}\u2502${RESET}`);
     writeLine(`  ${colors.purple}\u251C${"\u2500".repeat(60)}\u2524${RESET}`);
-    for (const exec2 of execs) {
-      const time = exec2.startedAt.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
-      const squadName = truncate(exec2.squad, 11);
-      const agentName = truncate(exec2.agent, 14);
-      const duration = formatDuration(exec2.durationMs);
+    for (const exec3 of execs) {
+      const time = exec3.startedAt.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+      const squadName = truncate(exec3.squad, 11);
+      const agentName = truncate(exec3.agent, 14);
+      const duration = formatDuration(exec3.durationMs);
       let statusIcon;
       let statusColor;
-      switch (exec2.status) {
+      switch (exec3.status) {
         case "success":
           statusIcon = icons.success;
           statusColor = colors.green;
@@ -6702,14 +7215,14 @@ async function historyCommand(options = {}) {
           statusColor = colors.dim;
       }
       writeLine(`  ${colors.purple}\u2502${RESET} ${colors.dim}${time}${RESET}  ${colors.cyan}${padEnd(squadName, 12)}${RESET}${padEnd(agentName, 16)}${padEnd(duration, 10)}${statusColor}${statusIcon}${RESET}       ${colors.purple}\u2502${RESET}`);
-      if (verbose && (exec2.cost || exec2.tokens)) {
-        const costStr = exec2.cost ? `$${exec2.cost.toFixed(2)}` : "";
-        const tokenStr = exec2.tokens ? `${exec2.tokens.toLocaleString()} tokens` : "";
+      if (verbose && (exec3.cost || exec3.tokens)) {
+        const costStr = exec3.cost ? `$${exec3.cost.toFixed(2)}` : "";
+        const tokenStr = exec3.tokens ? `${exec3.tokens.toLocaleString()} tokens` : "";
         const details = [costStr, tokenStr].filter(Boolean).join("  \u2502  ");
         writeLine(`  ${colors.purple}\u2502${RESET}         ${colors.dim}\u2514 ${details}${RESET}${" ".repeat(Math.max(0, 45 - details.length))}${colors.purple}\u2502${RESET}`);
       }
-      if (exec2.error) {
-        writeLine(`  ${colors.purple}\u2502${RESET}         ${colors.red}\u2514 ${truncate(exec2.error, 45)}${RESET}${" ".repeat(Math.max(0, 45 - exec2.error.length))}${colors.purple}\u2502${RESET}`);
+      if (exec3.error) {
+        writeLine(`  ${colors.purple}\u2502${RESET}         ${colors.red}\u2514 ${truncate(exec3.error, 45)}${RESET}${" ".repeat(Math.max(0, 45 - exec3.error.length))}${colors.purple}\u2502${RESET}`);
       }
     }
     writeLine(`  ${colors.purple}\u2514${"\u2500".repeat(60)}\u2518${RESET}`);
@@ -7959,15 +8472,1305 @@ function registerTriggerCommand(program2) {
   });
 }
 
-// src/commands/tonight.ts
+// 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";
+
+// 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";
+var client = null;
+function getClient() {
+  if (!client) {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error("ANTHROPIC_API_KEY environment variable is required for skills management");
+    }
+    client = new Anthropic({ apiKey });
+  }
+  return client;
+}
+async function listSkills() {
+  getClient();
+  try {
+    console.warn("Skills API: Using placeholder implementation. Actual API may differ.");
+    return [];
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("404")) {
+      return [];
+    }
+    throw error;
+  }
+}
+function loadSkillFiles(skillPath) {
+  const files = [];
+  function walkDir(dir, prefix = "") {
+    const entries = readdirSync7(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join17(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");
+        files.push({
+          name: relativePath,
+          content
+        });
+      }
+    }
+  }
+  walkDir(skillPath);
+  return files;
+}
+function extractSkillTitle(files) {
+  const skillMd = files.find((f) => f.name === "SKILL.md" || f.name.endsWith("/SKILL.md"));
+  if (!skillMd) {
+    throw new Error("SKILL.md not found in skill directory");
+  }
+  const content = skillMd.content;
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (frontmatterMatch) {
+    const nameMatch = frontmatterMatch[1].match(/^name:\s*(.+)$/m);
+    if (nameMatch) {
+      return nameMatch[1].trim();
+    }
+  }
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  if (headingMatch) {
+    return headingMatch[1].trim();
+  }
+  throw new Error("Could not extract skill title from SKILL.md");
+}
+function extractSkillDescription(files) {
+  const skillMd = files.find((f) => f.name === "SKILL.md" || f.name.endsWith("/SKILL.md"));
+  if (!skillMd) return void 0;
+  const content = skillMd.content;
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (frontmatterMatch) {
+    const descMatch = frontmatterMatch[1].match(/^description:\s*(.+)$/m);
+    if (descMatch) {
+      return descMatch[1].trim();
+    }
+  }
+  const paragraphMatch = content.match(/^#.+\n+(.+)/m);
+  if (paragraphMatch) {
+    return paragraphMatch[1].trim();
+  }
+  return void 0;
+}
+async function uploadSkill(skillPath) {
+  getClient();
+  const files = loadSkillFiles(skillPath);
+  if (files.length === 0) {
+    throw new Error(`No files found in skill directory: ${skillPath}`);
+  }
+  const totalSize = files.reduce((sum, f) => sum + Buffer.byteLength(f.content, "utf-8"), 0);
+  const maxSize = 8 * 1024 * 1024;
+  if (totalSize > maxSize) {
+    throw new Error(`Skill size ${(totalSize / 1024 / 1024).toFixed(2)}MB exceeds 8MB limit`);
+  }
+  const displayTitle = extractSkillTitle(files);
+  const description = extractSkillDescription(files);
+  try {
+    console.log(`Uploading skill: ${displayTitle}`);
+    console.log(`Files: ${files.map((f) => f.name).join(", ")}`);
+    console.log(`Total size: ${(totalSize / 1024).toFixed(2)}KB`);
+    const skill = {
+      id: `skill_${Date.now()}`,
+      display_title: displayTitle,
+      description,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      files
+    };
+    console.warn("Skills API: Using placeholder implementation. Skill not actually uploaded.");
+    return skill;
+  } catch (error) {
+    throw new Error(`Failed to upload skill: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function deleteSkill(skillId) {
+  getClient();
+  try {
+    console.log(`Deleting skill: ${skillId}`);
+    console.warn("Skills API: Using placeholder implementation. Skill not actually deleted.");
+  } catch (error) {
+    throw new Error(`Failed to delete skill: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getSkill(skillId) {
+  getClient();
+  try {
+    console.log(`Getting skill: ${skillId}`);
+    console.warn("Skills API: Using placeholder implementation.");
+    return null;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("404")) {
+      return null;
+    }
+    throw error;
+  }
+}
+function isApiKeyConfigured() {
+  return !!process.env.ANTHROPIC_API_KEY;
+}
+
+// src/commands/skill.ts
+function registerSkillCommand(program2) {
+  const skill = program2.command("skill").description("Manage Agent Skills (upload, list, delete)");
+  skill.command("list").description("List uploaded skills from Anthropic API").action(skillListCommand);
+  skill.command("upload <path>").description("Upload a skill directory to Anthropic API").action(skillUploadCommand);
+  skill.command("delete <skillId>").description("Delete a skill from Anthropic API").option("-f, --force", "Skip confirmation prompt").action(skillDeleteCommand);
+  skill.command("show <skillId>").description("Show details for a skill").action(skillShowCommand);
+  skill.command("convert <agent>").description("Convert an agent.md file to SKILL.md format").option("-o, --output <path>", "Output directory (default: .agents/skills/<agent-name>)").action(skillConvertCommand);
+}
+async function skillListCommand() {
+  writeLine();
+  writeLine(`  ${gradient("Skills")} ${colors.dim}list${RESET}`);
+  writeLine();
+  if (!isApiKeyConfigured()) {
+    writeLine(`  ${icons.error} ${colors.red}ANTHROPIC_API_KEY not configured${RESET}`);
+    writeLine(`  ${colors.dim}Set the environment variable to use skills management.${RESET}`);
+    writeLine();
+    return;
+  }
+  const spinner = ora6("Fetching skills...").start();
+  try {
+    const skills = await listSkills();
+    if (skills.length === 0) {
+      spinner.info("No skills uploaded yet");
+      writeLine();
+      writeLine(`  ${colors.dim}Upload a skill:${RESET}`);
+      writeLine(`    ${colors.cyan}squads skill upload <path>${RESET}`);
+      writeLine();
+      writeLine(`  ${colors.dim}Convert an agent to skill format:${RESET}`);
+      writeLine(`    ${colors.cyan}squads skill convert <squad>/<agent>${RESET}`);
+      writeLine();
+      return;
+    }
+    spinner.succeed(`Found ${skills.length} skill(s)`);
+    writeLine();
+    writeLine(`  ${colors.dim}ID${RESET}                    ${colors.dim}Title${RESET}                ${colors.dim}Updated${RESET}`);
+    writeLine(`  ${colors.dim}${"\u2500".repeat(60)}${RESET}`);
+    for (const skill of skills) {
+      const id = skill.id.slice(0, 20).padEnd(22);
+      const title = (skill.display_title || "Untitled").slice(0, 20).padEnd(22);
+      const updated = new Date(skill.updated_at).toLocaleDateString();
+      writeLine(`  ${colors.cyan}${id}${RESET}${title}${colors.dim}${updated}${RESET}`);
+    }
+    writeLine();
+  } catch (error) {
+    spinner.fail("Failed to list skills");
+    writeLine(`  ${colors.red}${error instanceof Error ? error.message : String(error)}${RESET}`);
+    writeLine();
+  }
+}
+async function skillUploadCommand(skillPath) {
+  writeLine();
+  writeLine(`  ${gradient("Skills")} ${colors.dim}upload${RESET}`);
+  writeLine();
+  if (!isApiKeyConfigured()) {
+    writeLine(`  ${icons.error} ${colors.red}ANTHROPIC_API_KEY not configured${RESET}`);
+    writeLine(`  ${colors.dim}Set the environment variable to use skills management.${RESET}`);
+    writeLine();
+    return;
+  }
+  const fullPath = skillPath.startsWith("/") ? skillPath : join18(process.cwd(), skillPath);
+  if (!existsSync17(fullPath)) {
+    writeLine(`  ${icons.error} ${colors.red}Directory not found: ${skillPath}${RESET}`);
+    writeLine();
+    return;
+  }
+  const skillMdPath = join18(fullPath, "SKILL.md");
+  if (!existsSync17(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}`);
+    writeLine(`    ${colors.cyan}squads skill convert <squad>/<agent>${RESET}`);
+    writeLine();
+    return;
+  }
+  const spinner = ora6("Uploading skill...").start();
+  try {
+    const skill = await uploadSkill(fullPath);
+    spinner.succeed(`Skill uploaded: ${skill.display_title}`);
+    writeLine();
+    writeLine(`  ${colors.dim}ID:${RESET} ${colors.cyan}${skill.id}${RESET}`);
+    if (skill.description) {
+      writeLine(`  ${colors.dim}Description:${RESET} ${skill.description}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}Use in run command:${RESET}`);
+    writeLine(`    ${colors.cyan}squads run <squad> --skills ${skill.id}${RESET}`);
+    writeLine();
+  } catch (error) {
+    spinner.fail("Failed to upload skill");
+    writeLine(`  ${colors.red}${error instanceof Error ? error.message : String(error)}${RESET}`);
+    writeLine();
+  }
+}
+async function skillDeleteCommand(skillId, options) {
+  writeLine();
+  writeLine(`  ${gradient("Skills")} ${colors.dim}delete${RESET}`);
+  writeLine();
+  if (!isApiKeyConfigured()) {
+    writeLine(`  ${icons.error} ${colors.red}ANTHROPIC_API_KEY not configured${RESET}`);
+    writeLine();
+    return;
+  }
+  if (!options.force) {
+    writeLine(`  ${colors.yellow}Warning: This will permanently delete the skill.${RESET}`);
+    writeLine(`  ${colors.dim}Use --force to skip this confirmation.${RESET}`);
+    writeLine();
+    return;
+  }
+  const spinner = ora6("Deleting skill...").start();
+  try {
+    await deleteSkill(skillId);
+    spinner.succeed(`Skill deleted: ${skillId}`);
+    writeLine();
+  } catch (error) {
+    spinner.fail("Failed to delete skill");
+    writeLine(`  ${colors.red}${error instanceof Error ? error.message : String(error)}${RESET}`);
+    writeLine();
+  }
+}
+async function skillShowCommand(skillId) {
+  writeLine();
+  writeLine(`  ${gradient("Skills")} ${colors.dim}show${RESET}`);
+  writeLine();
+  if (!isApiKeyConfigured()) {
+    writeLine(`  ${icons.error} ${colors.red}ANTHROPIC_API_KEY not configured${RESET}`);
+    writeLine();
+    return;
+  }
+  const spinner = ora6("Fetching skill...").start();
+  try {
+    const skill = await getSkill(skillId);
+    if (!skill) {
+      spinner.fail(`Skill not found: ${skillId}`);
+      writeLine();
+      return;
+    }
+    spinner.succeed(`Found skill: ${skill.display_title}`);
+    writeLine();
+    writeLine(`  ${colors.dim}ID:${RESET}          ${colors.cyan}${skill.id}${RESET}`);
+    writeLine(`  ${colors.dim}Title:${RESET}       ${skill.display_title}`);
+    if (skill.description) {
+      writeLine(`  ${colors.dim}Description:${RESET} ${skill.description}`);
+    }
+    writeLine(`  ${colors.dim}Created:${RESET}     ${new Date(skill.created_at).toLocaleString()}`);
+    writeLine(`  ${colors.dim}Updated:${RESET}     ${new Date(skill.updated_at).toLocaleString()}`);
+    if (skill.files && skill.files.length > 0) {
+      writeLine();
+      writeLine(`  ${colors.dim}Files:${RESET}`);
+      for (const file of skill.files) {
+        const size = Buffer.byteLength(file.content, "utf-8");
+        writeLine(`    ${colors.cyan}${file.name}${RESET} ${colors.dim}(${formatBytes(size)})${RESET}`);
+      }
+    }
+    writeLine();
+  } catch (error) {
+    spinner.fail("Failed to fetch skill");
+    writeLine(`  ${colors.red}${error instanceof Error ? error.message : String(error)}${RESET}`);
+    writeLine();
+  }
+}
+async function skillConvertCommand(agentPath, options) {
+  writeLine();
+  writeLine(`  ${gradient("Skills")} ${colors.dim}convert${RESET}`);
+  writeLine();
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${icons.error} ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine();
+    return;
+  }
+  let agentFilePath;
+  let squadName;
+  let agentName;
+  if (agentPath.includes("/")) {
+    const [squad, agent] = agentPath.split("/");
+    squadName = squad;
+    agentName = agent.replace(".md", "");
+    agentFilePath = join18(squadsDir, squad, `${agentName}.md`);
+  } else {
+    agentName = agentPath.replace(".md", "");
+    const foundPath = findAgentFile(squadsDir, agentName);
+    if (!foundPath) {
+      writeLine(`  ${icons.error} ${colors.red}Agent not found: ${agentPath}${RESET}`);
+      writeLine(`  ${colors.dim}Use format: squad/agent (e.g., cli/code-eval)${RESET}`);
+      writeLine();
+      return;
+    }
+    agentFilePath = foundPath;
+    squadName = basename2(dirname5(agentFilePath));
+  }
+  if (!existsSync17(agentFilePath)) {
+    writeLine(`  ${icons.error} ${colors.red}Agent file not found: ${agentFilePath}${RESET}`);
+    writeLine();
+    return;
+  }
+  const agentContent = readFileSync14(agentFilePath, "utf-8");
+  const skillName = `${squadName}-${agentName}`;
+  const outputDir = options.output || join18(dirname5(squadsDir), "skills", skillName);
+  if (!existsSync17(outputDir)) {
+    mkdirSync9(outputDir, { recursive: true });
+  }
+  const skillMd = convertAgentToSkill(agentContent, squadName, agentName);
+  const skillMdPath = join18(outputDir, "SKILL.md");
+  writeFileSync10(skillMdPath, skillMd);
+  writeLine(`  ${icons.success} ${colors.green}Converted:${RESET} ${agentPath}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Output:${RESET} ${outputDir}`);
+  writeLine(`  ${colors.dim}Files:${RESET}`);
+  writeLine(`    ${colors.cyan}SKILL.md${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}Next steps:${RESET}`);
+  writeLine(`    1. Review and edit ${colors.cyan}SKILL.md${RESET}`);
+  writeLine(`    2. Add scripts or examples if needed`);
+  writeLine(`    3. Upload: ${colors.cyan}squads skill upload ${outputDir}${RESET}`);
+  writeLine();
+}
+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)) {
+      return agentPath;
+    }
+  }
+  return null;
+}
+function convertAgentToSkill(agentContent, squadName, agentName) {
+  const existingMeta = {};
+  let bodyContent = agentContent;
+  const frontmatterMatch = agentContent.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)/);
+  if (frontmatterMatch) {
+    const frontmatter = frontmatterMatch[1];
+    bodyContent = frontmatterMatch[2];
+    for (const line of frontmatter.split("\n")) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        existingMeta[match[1]] = match[2].trim();
+      }
+    }
+  }
+  const title = existingMeta.name || bodyContent.match(/^#\s+(?:Agent:\s*)?(.+)$/m)?.[1] || `${squadName}-${agentName}`;
+  const roleMatch = bodyContent.match(/^(?:role|description):\s*(.+)$/mi) || bodyContent.match(/^##?\s*(?:Role|Purpose|Description)\s*\n+(.+)/mi);
+  const description = existingMeta.description || roleMatch?.[1] || `Agent from ${squadName} squad. Use when working on ${agentName}-related tasks.`;
+  const skillMd = `---
+name: ${squadName}-${agentName}
+description: ${description}
+---
+
+# ${title}
+
+${bodyContent.trim()}
+`;
+  return skillMd;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+}
+
+// src/commands/permissions.ts
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join19 } 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);
+  permissions.command("check <squad>").description("Validate permissions before execution").option("-a, --agent <agent>", "Specify agent for context").option("--mcp <servers...>", "MCP servers to validate").option("--bash <commands...>", "Bash commands to validate").option("--write <paths...>", "Write paths to validate").option("--read <paths...>", "Read paths to validate").action(permissionsCheckCommand);
+}
+async function permissionsShowCommand(squadName) {
+  writeLine();
+  writeLine(`  ${gradient("Permissions")} ${colors.dim}show${RESET} ${colors.cyan}${squadName}${RESET}`);
+  writeLine();
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${icons.error} ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine();
+    return;
+  }
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`  ${icons.error} ${colors.red}Squad "${squadName}" not found${RESET}`);
+    writeLine();
+    return;
+  }
+  const squadFilePath = join19(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync15(squadFilePath, "utf-8");
+  const context2 = buildContextFromSquad(squadName, squadContent);
+  const defaults = getDefaultContext(squadName);
+  const isDefault = JSON.stringify(context2.permissions) === JSON.stringify(defaults.permissions);
+  writeLine(`  ${bold}Squad:${RESET} ${squadName}`);
+  if (squad.mission) {
+    writeLine(`  ${colors.dim}${squad.mission}${RESET}`);
+  }
+  writeLine();
+  if (isDefault) {
+    writeLine(`  ${icons.warning} ${colors.yellow}Using default (permissive) permissions${RESET}`);
+    writeLine(`  ${colors.dim}Add a permissions block to SQUAD.md to restrict access.${RESET}`);
+    writeLine();
+  }
+  writeLine(`  ${bold}Mode:${RESET} ${formatMode(context2.permissions.mode)}`);
+  writeLine();
+  writeLine(`  ${bold}Bash Commands:${RESET}`);
+  if (context2.permissions.bash.includes("*")) {
+    writeLine(`    ${colors.dim}All commands allowed (*)${RESET}`);
+  } else {
+    for (const cmd of context2.permissions.bash) {
+      writeLine(`    ${icons.active} ${cmd}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${bold}Write Paths:${RESET}`);
+  if (context2.permissions.write.includes("**") || context2.permissions.write.includes("*")) {
+    writeLine(`    ${colors.dim}All paths writable (**)${RESET}`);
+  } else {
+    for (const path3 of context2.permissions.write) {
+      writeLine(`    ${icons.active} ${path3}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${bold}Read Paths:${RESET}`);
+  if (context2.permissions.read.includes("**") || context2.permissions.read.includes("*")) {
+    writeLine(`    ${colors.dim}All paths readable (**)${RESET}`);
+  } else {
+    for (const path3 of context2.permissions.read) {
+      writeLine(`    ${icons.active} ${path3}`);
+    }
+  }
+  writeLine();
+  writeLine(`  ${bold}MCP Servers:${RESET}`);
+  if (context2.permissions.mcp.allow.includes("*")) {
+    writeLine(`    ${colors.dim}All servers allowed (*)${RESET}`);
+  } else {
+    writeLine(`    ${colors.green}Allow:${RESET}`);
+    for (const server of context2.permissions.mcp.allow) {
+      writeLine(`      ${icons.success} ${server}`);
+    }
+  }
+  if (context2.permissions.mcp.deny.length > 0) {
+    writeLine(`    ${colors.red}Deny:${RESET}`);
+    for (const server of context2.permissions.mcp.deny) {
+      writeLine(`      ${icons.error} ${server}`);
+    }
+  }
+  writeLine();
+  if (isDefault) {
+    writeLine(`  ${bold}Add permissions to SQUAD.md:${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}\`\`\`yaml${RESET}`);
+    writeLine(`  ${colors.dim}permissions:${RESET}`);
+    writeLine(`  ${colors.dim}  mode: warn  # or strict, audit${RESET}`);
+    writeLine(`  ${colors.dim}  bash: [npm, git, gh]${RESET}`);
+    writeLine(`  ${colors.dim}  write: [agents-squads-web/**]${RESET}`);
+    writeLine(`  ${colors.dim}  read: [hq/.agents/**]${RESET}`);
+    writeLine(`  ${colors.dim}  mcp:${RESET}`);
+    writeLine(`  ${colors.dim}    allow: [chrome-devtools]${RESET}`);
+    writeLine(`  ${colors.dim}    deny: [supabase]${RESET}`);
+    writeLine(`  ${colors.dim}\`\`\`${RESET}`);
+    writeLine();
+  }
+}
+async function permissionsCheckCommand(squadName, options) {
+  writeLine();
+  writeLine(`  ${gradient("Permissions")} ${colors.dim}check${RESET} ${colors.cyan}${squadName}${RESET}`);
+  if (options.agent) {
+    writeLine(`  ${colors.dim}Agent: ${options.agent}${RESET}`);
+  }
+  writeLine();
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`  ${icons.error} ${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine();
+    return;
+  }
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`  ${icons.error} ${colors.red}Squad "${squadName}" not found${RESET}`);
+    writeLine();
+    return;
+  }
+  const squadFilePath = join19(squadsDir, squadName, "SQUAD.md");
+  const squadContent = readFileSync15(squadFilePath, "utf-8");
+  const context2 = buildContextFromSquad(squadName, squadContent, options.agent);
+  const request = {
+    mcpServers: options.mcp,
+    bashCommands: options.bash,
+    writePaths: options.write,
+    readPaths: options.read
+  };
+  if (!options.mcp && !options.bash && !options.write && !options.read) {
+    writeLine(`  ${colors.yellow}No resources specified to check.${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Examples:${RESET}`);
+    writeLine(`    ${colors.cyan}squads perms check ${squadName} --mcp chrome-devtools firecrawl${RESET}`);
+    writeLine(`    ${colors.cyan}squads perms check ${squadName} --bash npm git docker${RESET}`);
+    writeLine(`    ${colors.cyan}squads perms check ${squadName} --write src/** --read config/**${RESET}`);
+    writeLine();
+    return;
+  }
+  const result = validateExecution(context2, request);
+  if (result.violations.length === 0) {
+    writeLine(`  ${icons.success} ${colors.green}All permissions valid${RESET}`);
+    writeLine();
+    if (options.mcp) {
+      writeLine(`  ${colors.dim}MCP:${RESET} ${options.mcp.join(", ")}`);
+    }
+    if (options.bash) {
+      writeLine(`  ${colors.dim}Bash:${RESET} ${options.bash.join(", ")}`);
+    }
+    if (options.write) {
+      writeLine(`  ${colors.dim}Write:${RESET} ${options.write.join(", ")}`);
+    }
+    if (options.read) {
+      writeLine(`  ${colors.dim}Read:${RESET} ${options.read.join(", ")}`);
+    }
+    writeLine();
+  } else {
+    const violationLines = formatViolations(result);
+    for (const line of violationLines) {
+      writeLine(`  ${line}`);
+    }
+    writeLine();
+    if (!result.allowed) {
+      process.exit(1);
+    }
+  }
+}
+function formatMode(mode) {
+  switch (mode) {
+    case "strict":
+      return `${colors.red}strict${RESET} ${colors.dim}(blocks on violation)${RESET}`;
+    case "warn":
+      return `${colors.yellow}warn${RESET} ${colors.dim}(logs and continues)${RESET}`;
+    case "audit":
+      return `${colors.cyan}audit${RESET} ${colors.dim}(logs to trail)${RESET}`;
+    default:
+      return mode;
+  }
+}
+
+// src/commands/context.ts
+async function contextShowCommand(squadName, options = {}) {
+  await track(Events.CLI_CONTEXT, { squad: squadName });
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    writeLine(`${colors.dim}Run \`squads init\` to create one.${RESET}`);
+    process.exit(1);
+  }
+  const squad = loadSquad(squadName);
+  if (!squad) {
+    writeLine(`${colors.red}Squad "${squadName}" not found.${RESET}`);
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      name: squad.name,
+      mission: squad.mission,
+      repo: squad.repo,
+      stack: squad.stack,
+      effort: squad.effort,
+      context: squad.context
+    }, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}context${RESET} ${colors.cyan}${squad.name}${RESET}`);
+  const ctx = squad.context;
+  if (!ctx) {
+    writeLine();
+    writeLine(`  ${colors.yellow}No context defined in SQUAD.md frontmatter${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Add a frontmatter block to ${squad.name}/SQUAD.md:${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}---${RESET}`);
+    writeLine(`  ${colors.dim}name: ${squad.name}${RESET}`);
+    writeLine(`  ${colors.dim}context:${RESET}`);
+    writeLine(`  ${colors.dim}  mcp: [chrome-devtools]${RESET}`);
+    writeLine(`  ${colors.dim}  model: { default: sonnet }${RESET}`);
+    writeLine(`  ${colors.dim}  budget: { daily: 10 }${RESET}`);
+    writeLine(`  ${colors.dim}---${RESET}`);
+    writeLine();
+    return;
+  }
+  const tableWidth = 54;
+  writeLine();
+  writeLine(`  ${colors.purple}${box.horizontal.repeat(tableWidth)}${RESET}`);
+  if (ctx.mcp && ctx.mcp.length > 0) {
+    writeLine(`  ${bold}MCP${RESET}       ${colors.cyan}${ctx.mcp.join(", ")}${RESET}`);
+  } else {
+    writeLine(`  ${bold}MCP${RESET}       ${colors.dim}none${RESET}`);
+  }
+  if (ctx.skills && ctx.skills.length > 0) {
+    writeLine(`  ${bold}Skills${RESET}    ${colors.cyan}${ctx.skills.join(", ")}${RESET}`);
+  }
+  if (ctx.memory?.load && ctx.memory.load.length > 0) {
+    writeLine(`  ${bold}Memory${RESET}    ${colors.cyan}${ctx.memory.load.join(", ")}${RESET}`);
+  }
+  if (ctx.model) {
+    const modelParts = [];
+    if (ctx.model.default) modelParts.push(`${colors.white}${ctx.model.default}${RESET} ${colors.dim}(default)${RESET}`);
+    if (ctx.model.expensive) modelParts.push(`${colors.yellow}${ctx.model.expensive}${RESET} ${colors.dim}(expensive)${RESET}`);
+    if (ctx.model.cheap) modelParts.push(`${colors.green}${ctx.model.cheap}${RESET} ${colors.dim}(cheap)${RESET}`);
+    writeLine(`  ${bold}Model${RESET}     ${modelParts.join(", ")}`);
+  }
+  if (ctx.budget) {
+    const budgetParts = [];
+    if (ctx.budget.daily) budgetParts.push(`$${ctx.budget.daily}/day`);
+    if (ctx.budget.weekly) budgetParts.push(`$${ctx.budget.weekly}/week`);
+    if (ctx.budget.perExecution) budgetParts.push(`$${ctx.budget.perExecution}/run`);
+    writeLine(`  ${bold}Budget${RESET}    ${colors.green}${budgetParts.join(", ")}${RESET}`);
+  }
+  if (squad.effort) {
+    const effortColor = squad.effort === "high" ? colors.red : squad.effort === "medium" ? colors.yellow : colors.green;
+    writeLine(`  ${bold}Effort${RESET}    ${effortColor}${squad.effort}${RESET}`);
+  }
+  if (squad.repo) {
+    writeLine(`  ${bold}Repo${RESET}      ${colors.dim}${squad.repo}${RESET}`);
+  }
+  if (squad.stack) {
+    writeLine(`  ${bold}Stack${RESET}     ${colors.dim}${squad.stack}${RESET}`);
+  }
+  writeLine(`  ${colors.purple}${box.horizontal.repeat(tableWidth)}${RESET}`);
+  writeLine();
+  writeLine(`  ${colors.dim}$${RESET} squads context show ${colors.cyan}${squad.name}${RESET} --json  ${colors.dim}JSON output${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}${squad.name}${RESET}                  ${colors.dim}Run with this context${RESET}`);
+  writeLine();
+}
+async function contextListCommand(options = {}) {
+  await track(Events.CLI_CONTEXT, { action: "list" });
+  const squadsDir = findSquadsDir();
+  if (!squadsDir) {
+    writeLine(`${colors.red}No .agents/squads directory found${RESET}`);
+    process.exit(1);
+  }
+  const squads = listSquads(squadsDir);
+  if (options.json) {
+    const contexts = {};
+    for (const name of squads) {
+      const squad = loadSquad(name);
+      if (squad) {
+        contexts[name] = squad.context;
+      }
+    }
+    console.log(JSON.stringify(contexts, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}context list${RESET}`);
+  writeLine();
+  const w = { name: 14, mcp: 24, model: 12, budget: 12 };
+  const tableWidth = w.name + w.mcp + w.model + w.budget + 6;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("MCP", w.mcp)}${RESET}${bold}${padEnd("MODEL", w.model)}${RESET}${bold}BUDGET${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const name of squads) {
+    const squad = loadSquad(name);
+    const ctx = squad?.context;
+    const mcpStr = ctx?.mcp?.slice(0, 2).join(", ") || `${colors.dim}\u2014${RESET}`;
+    const modelStr = ctx?.model?.default || `${colors.dim}\u2014${RESET}`;
+    const budgetStr = ctx?.budget?.daily ? `$${ctx.budget.daily}/d` : `${colors.dim}\u2014${RESET}`;
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(name, w.name)}${RESET}${padEnd(mcpStr, w.mcp)}${padEnd(modelStr, w.model)}${padEnd(budgetStr, w.budget)}${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+}
+
+// src/commands/cost.ts
+function getBudgetStatus(squadName, spent, dailyBudget, weeklyBudget) {
+  let status = "no-budget";
+  let dailyPercent = null;
+  let weeklyPercent = null;
+  if (dailyBudget !== null) {
+    dailyPercent = spent / dailyBudget * 100;
+    if (dailyPercent >= 100) {
+      status = "over";
+    } else if (dailyPercent >= 80) {
+      status = "warning";
+    } else {
+      status = "ok";
+    }
+  }
+  if (weeklyBudget !== null) {
+    weeklyPercent = spent / weeklyBudget * 100;
+  }
+  return {
+    squad: squadName,
+    spent,
+    dailyBudget,
+    weeklyBudget,
+    dailyPercent,
+    weeklyPercent,
+    status
+  };
+}
+async function costCommand(options = {}) {
+  await track(Events.CLI_COST, { squad: options.squad || "all" });
+  const stats = await fetchBridgeStats();
+  const plan = detectPlan();
+  if (options.json) {
+    const result = buildJsonOutput(stats, plan, options.squad);
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}cost${RESET}${options.squad ? ` ${colors.cyan}${options.squad}${RESET}` : ""}`);
+  writeLine();
+  if (!stats) {
+    writeLine(`  ${colors.yellow}\u26A0 Bridge unavailable${RESET}`);
+    writeLine(`  ${colors.dim}Run \`squads stack up\` to start infrastructure${RESET}`);
+    writeLine();
+    return;
+  }
+  const todaySection = `  ${bold}Today${RESET}`;
+  writeLine(todaySection);
+  writeLine(`  ${colors.cyan}$${stats.today.costUsd.toFixed(2)}${RESET} ${colors.dim}|${RESET} ${stats.today.generations.toLocaleString()} calls ${colors.dim}|${RESET} ${formatTokens(stats.today.inputTokens + stats.today.outputTokens)} tokens`);
+  if (stats.byModel && stats.byModel.length > 0) {
+    const modelParts = stats.byModel.filter((m) => m.costUsd > 0).sort((a, b) => b.costUsd - a.costUsd).slice(0, 4).map((m) => `${colors.dim}${shortModelName(m.model)}${RESET} $${m.costUsd.toFixed(0)}`);
+    if (modelParts.length > 0) {
+      writeLine(`  ${colors.dim}Models:${RESET} ${modelParts.join(" \xB7 ")}`);
+    }
+  }
+  writeLine();
+  if (stats.week) {
+    writeLine(`  ${bold}Week${RESET}`);
+    writeLine(`  ${colors.purple}$${stats.week.costUsd.toFixed(2)}${RESET} ${colors.dim}|${RESET} ${stats.week.generations.toLocaleString()} calls ${colors.dim}|${RESET} ${formatTokens(stats.week.inputTokens + stats.week.outputTokens)} tokens`);
+    writeLine();
+  }
+  writeLine(`  ${bold}Budget${RESET} ${colors.dim}(daily)${RESET}`);
+  const budgetBar = createBudgetBar(stats.budget.usedPct);
+  const budgetColor = stats.budget.usedPct >= 100 ? colors.red : stats.budget.usedPct >= 80 ? colors.yellow : colors.green;
+  writeLine(`  ${budgetBar} ${budgetColor}$${stats.budget.used.toFixed(0)}${RESET}/${colors.dim}$${stats.budget.daily}${RESET} (${stats.budget.usedPct.toFixed(0)}%)`);
+  writeLine();
+  if (stats.bySquad && stats.bySquad.length > 0 && !options.squad) {
+    writeLine(`  ${bold}By Squad${RESET}`);
+    writeLine();
+    const squadsDir = findSquadsDir();
+    const squadBudgets = /* @__PURE__ */ new Map();
+    if (squadsDir) {
+      for (const name of listSquads(squadsDir)) {
+        const squad = loadSquad(name);
+        if (squad?.context?.budget) {
+          squadBudgets.set(name, {
+            daily: squad.context.budget.daily || null,
+            weekly: squad.context.budget.weekly || null
+          });
+        }
+      }
+    }
+    const tableWidth = 52;
+    writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+    const w = { name: 14, spent: 10, budget: 12, status: 14 };
+    const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("SQUAD", w.name)}${RESET}${bold}${padEnd("SPENT", w.spent)}${RESET}${bold}${padEnd("BUDGET", w.budget)}${RESET}${bold}STATUS${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(header);
+    writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+    for (const sq of stats.bySquad.sort((a, b) => b.costUsd - a.costUsd)) {
+      const budgetInfo = squadBudgets.get(sq.squad);
+      const dailyBudget = budgetInfo?.daily || null;
+      const spentStr = `$${sq.costUsd.toFixed(2)}`;
+      const budgetStr = dailyBudget ? `$${dailyBudget}/d` : `${colors.dim}\u2014${RESET}`;
+      let statusStr;
+      if (dailyBudget) {
+        const pct = sq.costUsd / dailyBudget * 100;
+        if (pct >= 100) {
+          statusStr = `${colors.red}\u25CF OVER${RESET}`;
+        } else if (pct >= 80) {
+          statusStr = `${colors.yellow}\u25CF ${pct.toFixed(0)}%${RESET}`;
+        } else {
+          statusStr = `${colors.green}\u2713 ${pct.toFixed(0)}%${RESET}`;
+        }
+      } else {
+        statusStr = `${colors.dim}no budget${RESET}`;
+      }
+      const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(sq.squad, w.name)}${RESET}${padEnd(spentStr, w.spent)}${padEnd(budgetStr, w.budget)}${padEnd(statusStr, w.status)}${colors.purple}${box.vertical}${RESET}`;
+      writeLine(row);
+    }
+    writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+    writeLine();
+  }
+  if (options.squad) {
+    const squadStats = stats.bySquad?.find((s) => s.squad === options.squad);
+    const squad = loadSquad(options.squad);
+    if (squadStats) {
+      writeLine(`  ${bold}Squad: ${options.squad}${RESET}`);
+      writeLine(`  Spent today: ${colors.cyan}$${squadStats.costUsd.toFixed(2)}${RESET}`);
+      writeLine(`  Calls: ${squadStats.generations.toLocaleString()}`);
+      if (squad?.context?.budget) {
+        const daily = squad.context.budget.daily;
+        const weekly = squad.context.budget.weekly;
+        if (daily) {
+          const pct = squadStats.costUsd / daily * 100;
+          const statusIcon = pct >= 100 ? `${colors.red}\u25CF${RESET}` : pct >= 80 ? `${colors.yellow}\u25CF${RESET}` : `${colors.green}\u2713${RESET}`;
+          writeLine(`  Daily budget: ${statusIcon} $${squadStats.costUsd.toFixed(2)}/$${daily} (${pct.toFixed(0)}%)`);
+        }
+        if (weekly) {
+          writeLine(`  Weekly budget: $${weekly}/week`);
+        }
+      } else {
+        writeLine(`  ${colors.dim}No budget defined in SQUAD.md frontmatter${RESET}`);
+      }
+    } else {
+      writeLine(`  ${colors.dim}No cost data for squad "${options.squad}"${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}Plan: ${plan.plan} (${plan.reason})${RESET}`);
+  writeLine();
+}
+async function budgetCheckCommand(squadName, options = {}) {
+  await track(Events.CLI_COST, { action: "budget-check", squad: squadName });
+  const stats = await fetchBridgeStats();
+  const squad = loadSquad(squadName);
+  if (!stats) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Bridge unavailable" }));
+    } else {
+      writeLine(`  ${colors.yellow}\u26A0 Bridge unavailable${RESET}`);
+    }
+    return;
+  }
+  const squadStats = stats.bySquad?.find((s) => s.squad === squadName);
+  const spent = squadStats?.costUsd || 0;
+  const dailyBudget = squad?.context?.budget?.daily || null;
+  const weeklyBudget = squad?.context?.budget?.weekly || null;
+  const status = getBudgetStatus(squadName, spent, dailyBudget, weeklyBudget);
+  if (options.json) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  writeLine();
+  if (status.status === "no-budget") {
+    writeLine(`  ${colors.dim}\u25CB${RESET} ${colors.cyan}${squadName}${RESET}: No budget defined`);
+    writeLine(`  ${colors.dim}Add budget to SQUAD.md frontmatter:${RESET}`);
+    writeLine(`  ${colors.dim}  context:${RESET}`);
+    writeLine(`  ${colors.dim}    budget: { daily: 50 }${RESET}`);
+  } else if (status.status === "over") {
+    writeLine(`  ${colors.red}\u25CF${RESET} ${colors.cyan}${squadName}${RESET}: ${colors.red}OVER BUDGET${RESET}`);
+    writeLine(`  $${spent.toFixed(2)}/$${dailyBudget} daily (${status.dailyPercent?.toFixed(0)}%)`);
+  } else if (status.status === "warning") {
+    writeLine(`  ${colors.yellow}\u25CF${RESET} ${colors.cyan}${squadName}${RESET}: ${colors.yellow}Approaching limit${RESET}`);
+    writeLine(`  $${spent.toFixed(2)}/$${dailyBudget} daily (${status.dailyPercent?.toFixed(0)}%)`);
+  } else {
+    writeLine(`  ${colors.green}\u2713${RESET} ${colors.cyan}${squadName}${RESET}: OK to proceed`);
+    writeLine(`  $${spent.toFixed(2)}/$${dailyBudget} daily (${status.dailyPercent?.toFixed(0)}%)`);
+  }
+  writeLine();
+}
+function buildJsonOutput(stats, plan, squadFilter) {
+  if (!stats) {
+    return { error: "Bridge unavailable", plan };
+  }
+  const squadsDir = findSquadsDir();
+  const squadBudgets = {};
+  if (squadsDir) {
+    for (const name of listSquads(squadsDir)) {
+      const squad = loadSquad(name);
+      if (squad?.context?.budget) {
+        squadBudgets[name] = {
+          daily: squad.context.budget.daily || null,
+          weekly: squad.context.budget.weekly || null
+        };
+      }
+    }
+  }
+  const bySquadWithBudget = stats.bySquad?.map((sq) => ({
+    ...sq,
+    budget: squadBudgets[sq.squad] || null,
+    budgetStatus: squadBudgets[sq.squad]?.daily ? getBudgetStatus(sq.squad, sq.costUsd, squadBudgets[sq.squad].daily, squadBudgets[sq.squad].weekly) : null
+  }));
+  if (squadFilter) {
+    const filtered = bySquadWithBudget?.find((s) => s.squad === squadFilter);
+    return {
+      squad: squadFilter,
+      ...filtered,
+      plan
+    };
+  }
+  return {
+    today: stats.today,
+    week: stats.week,
+    budget: stats.budget,
+    bySquad: bySquadWithBudget,
+    byModel: stats.byModel,
+    plan,
+    source: stats.source
+  };
+}
+function shortModelName(model) {
+  if (model.includes("opus")) return "opus";
+  if (model.includes("sonnet")) return "sonnet";
+  if (model.includes("haiku")) return "haiku";
+  return model.split("-")[0];
+}
+function formatTokens(tokens) {
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M`;
+  }
+  if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(0)}k`;
+  }
+  return tokens.toString();
+}
+function createBudgetBar(percent, width = 10) {
+  const filled = Math.min(Math.round(percent / 100 * width), width);
+  const empty = width - filled;
+  const filledChar = "\u2501";
+  const emptyChar = "\u2501";
+  const color = percent >= 100 ? colors.red : percent >= 80 ? colors.yellow : colors.green;
+  return `${color}${filledChar.repeat(filled)}${colors.dim}${emptyChar.repeat(empty)}${RESET}`;
+}
+
+// src/lib/executions.ts
+import { readFileSync as readFileSync16, existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
+import { join as join20 } from "path";
+function parseExecutionEntry(content, squad, agent) {
+  const idMatch = content.match(/<!-- exec:(\S+) -->/);
+  if (!idMatch) return null;
+  const id = idMatch[1];
+  const headerMatch = content.match(/\*\*([^*]+)\*\* \| Status: (\w+)/);
+  if (!headerMatch) return null;
+  const startTime = headerMatch[1].trim();
+  const status = headerMatch[2];
+  const triggerMatch = content.match(/- Trigger: (\w+)/);
+  const taskTypeMatch = content.match(/- Task Type: (\w+)/);
+  const completedMatch = content.match(/- Completed: ([^\n]+)/);
+  const durationMatch = content.match(/- Duration: ([^\n]+)/);
+  const outcomeMatch = content.match(/- Outcome: ([^\n]+)/);
+  const errorMatch = content.match(/- Error: ([^\n]+)/);
+  let durationMs;
+  if (durationMatch) {
+    const durationStr = durationMatch[1].trim();
+    const secMatch = durationStr.match(/^([\d.]+)s$/);
+    if (secMatch) {
+      durationMs = parseFloat(secMatch[1]) * 1e3;
+    }
+  }
+  return {
+    id,
+    squad,
+    agent,
+    startTime,
+    endTime: completedMatch?.[1]?.trim(),
+    durationMs,
+    status,
+    trigger: triggerMatch?.[1] || "manual",
+    taskType: taskTypeMatch?.[1] || "execution",
+    outcome: outcomeMatch?.[1]?.trim(),
+    error: errorMatch?.[1]?.trim()
+  };
+}
+function parseExecutionLog(filePath, squad, agent) {
+  if (!existsSync18(filePath)) return [];
+  const content = readFileSync16(filePath, "utf-8");
+  const executions = [];
+  const entries = content.split(/\n---\n/);
+  for (const entry of entries) {
+    if (!entry.includes("<!-- exec:")) continue;
+    const execution = parseExecutionEntry(entry, squad, agent);
+    if (execution) {
+      executions.push(execution);
+    }
+  }
+  for (const entry of entries) {
+    if (entry.includes("<!-- exec:")) continue;
+    const headerMatch = entry.match(/\*\*([^*]+)\*\* \| Status: (\w+)/);
+    if (!headerMatch) continue;
+    const startTime = headerMatch[1].trim();
+    const status = headerMatch[2];
+    const legacyId = `legacy_${startTime.replace(/[^a-z0-9]/gi, "")}`;
+    if (executions.some((e) => e.startTime === startTime)) continue;
+    executions.push({
+      id: legacyId,
+      squad,
+      agent,
+      startTime,
+      status,
+      trigger: "manual",
+      taskType: "execution"
+    });
+  }
+  return executions;
+}
+function listExecutions(options = {}) {
+  const memoryDir = findMemoryDir();
+  if (!memoryDir) return [];
+  const executions = [];
+  const { squad: filterSquad, agent: filterAgent, status: filterStatus, limit, since } = 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 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 agentExecutions = parseExecutionLog(logPath, squad, agent);
+      executions.push(...agentExecutions);
+    }
+  }
+  let filtered = filterStatus ? executions.filter((e) => e.status === filterStatus) : executions;
+  if (since) {
+    const sinceMs = since.getTime();
+    filtered = filtered.filter((e) => {
+      const execDate = new Date(e.startTime).getTime();
+      return !isNaN(execDate) && execDate >= sinceMs;
+    });
+  }
+  filtered.sort((a, b) => {
+    const aTime = new Date(a.startTime).getTime();
+    const bTime = new Date(b.startTime).getTime();
+    if (isNaN(aTime) || isNaN(bTime)) return 0;
+    return bTime - aTime;
+  });
+  if (limit && limit > 0) {
+    filtered = filtered.slice(0, limit);
+  }
+  return filtered;
+}
+function getExecutionStats(options = {}) {
+  const executions = listExecutions(options);
+  const running = executions.filter((e) => e.status === "running").length;
+  const completed = executions.filter((e) => e.status === "completed").length;
+  const failed = executions.filter((e) => e.status === "failed").length;
+  const durations = executions.filter((e) => e.status === "completed" && e.durationMs).map((e) => e.durationMs);
+  const avgDurationMs = durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : null;
+  const bySquad = {};
+  for (const e of executions) {
+    bySquad[e.squad] = (bySquad[e.squad] || 0) + 1;
+  }
+  const byAgent = {};
+  for (const e of executions) {
+    const key = `${e.squad}/${e.agent}`;
+    byAgent[key] = (byAgent[key] || 0) + 1;
+  }
+  return {
+    total: executions.length,
+    running,
+    completed,
+    failed,
+    avgDurationMs,
+    bySquad,
+    byAgent
+  };
+}
+function formatDuration2(ms) {
+  if (!ms) return "\u2014";
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  if (ms < 36e5) {
+    const mins2 = Math.floor(ms / 6e4);
+    const secs = Math.round(ms % 6e4 / 1e3);
+    return `${mins2}m ${secs}s`;
+  }
+  const hours = Math.floor(ms / 36e5);
+  const mins = Math.round(ms % 36e5 / 6e4);
+  return `${hours}h ${mins}m`;
+}
+function formatRelativeTime(isoTime) {
+  const date = new Date(isoTime);
+  if (isNaN(date.getTime())) return isoTime;
+  const now = Date.now();
+  const diff = now - date.getTime();
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  if (diff < 6048e5) return `${Math.floor(diff / 864e5)}d ago`;
+  return date.toLocaleDateString();
+}
+
+// src/commands/exec.ts
+async function execListCommand(options = {}) {
+  await track(Events.CLI_EXEC, { action: "list", squad: options.squad });
+  const listOptions = {
+    squad: options.squad,
+    agent: options.agent,
+    limit: options.limit || 20
+  };
+  if (options.status) {
+    listOptions.status = options.status;
+  }
+  const executions = listExecutions(listOptions);
+  if (options.json) {
+    console.log(JSON.stringify(executions, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}exec list${RESET}${options.squad ? ` ${colors.cyan}${options.squad}${RESET}` : ""}`);
+  writeLine();
+  if (executions.length === 0) {
+    writeLine(`  ${colors.dim}No executions found${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}Executions are logged when running agents:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads run ${colors.cyan}<squad>${RESET} --execute`);
+    writeLine();
+    return;
+  }
+  const w = { agent: 22, status: 12, duration: 10, time: 14, id: 18 };
+  const tableWidth = w.agent + w.status + w.duration + w.time + w.id + 8;
+  writeLine(`  ${colors.purple}${box.topLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.topRight}${RESET}`);
+  const header = `  ${colors.purple}${box.vertical}${RESET} ${bold}${padEnd("AGENT", w.agent)}${RESET}${bold}${padEnd("STATUS", w.status)}${RESET}${bold}${padEnd("DURATION", w.duration)}${RESET}${bold}${padEnd("TIME", w.time)}${RESET}${bold}ID${RESET} ${colors.purple}${box.vertical}${RESET}`;
+  writeLine(header);
+  writeLine(`  ${colors.purple}${box.teeRight}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.teeLeft}${RESET}`);
+  for (const exec3 of executions) {
+    const agentName = `${exec3.squad}/${exec3.agent}`;
+    const truncatedAgent = agentName.length > w.agent - 1 ? agentName.slice(0, w.agent - 4) + "..." : agentName;
+    const statusIcon = exec3.status === "running" ? icons.running : exec3.status === "completed" ? icons.success : icons.error;
+    const statusColor = exec3.status === "running" ? colors.yellow : exec3.status === "completed" ? colors.green : colors.red;
+    const statusStr = `${statusColor}${statusIcon} ${exec3.status}${RESET}`;
+    const durationStr = formatDuration2(exec3.durationMs);
+    const timeStr = formatRelativeTime(exec3.startTime);
+    const shortId = exec3.id.slice(0, 16);
+    const row = `  ${colors.purple}${box.vertical}${RESET} ${colors.cyan}${padEnd(truncatedAgent, w.agent)}${RESET}${padEnd(statusStr, w.status + 10)}${padEnd(durationStr, w.duration)}${colors.dim}${padEnd(timeStr, w.time)}${RESET}${colors.dim}${shortId}${RESET} ${colors.purple}${box.vertical}${RESET}`;
+    writeLine(row);
+  }
+  writeLine(`  ${colors.purple}${box.bottomLeft}${colors.dim}${box.horizontal.repeat(tableWidth)}${colors.purple}${box.bottomRight}${RESET}`);
+  writeLine();
+  const stats = getExecutionStats(listOptions);
+  const parts = [];
+  if (stats.running > 0) parts.push(`${colors.yellow}${stats.running} running${RESET}`);
+  if (stats.completed > 0) parts.push(`${colors.green}${stats.completed} completed${RESET}`);
+  if (stats.failed > 0) parts.push(`${colors.red}${stats.failed} failed${RESET}`);
+  if (parts.length > 0) {
+    writeLine(`  ${parts.join(` ${colors.dim}|${RESET} `)}`);
+    if (stats.avgDurationMs) {
+      writeLine(`  ${colors.dim}Avg duration: ${formatDuration2(stats.avgDurationMs)}${RESET}`);
+    }
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads exec show ${colors.cyan}<id>${RESET}    ${colors.dim}Execution details${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads exec --json       ${colors.dim}JSON output${RESET}`);
+  writeLine();
+}
+async function execShowCommand(executionId, options = {}) {
+  await track(Events.CLI_EXEC, { action: "show", id: executionId });
+  const executions = listExecutions();
+  const matches = executions.filter(
+    (e) => e.id === executionId || e.id.startsWith(executionId)
+  );
+  if (matches.length === 0) {
+    writeLine();
+    writeLine(`  ${colors.red}Execution not found: ${executionId}${RESET}`);
+    writeLine();
+    writeLine(`  ${colors.dim}List recent executions:${RESET}`);
+    writeLine(`  ${colors.dim}$${RESET} squads exec list`);
+    writeLine();
+    return;
+  }
+  if (matches.length > 1) {
+    writeLine();
+    writeLine(`  ${colors.yellow}Multiple matches for "${executionId}":${RESET}`);
+    for (const m of matches.slice(0, 5)) {
+      writeLine(`  ${colors.dim}${m.id}${RESET} - ${m.squad}/${m.agent}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.dim}Provide a more specific ID${RESET}`);
+    writeLine();
+    return;
+  }
+  const exec3 = matches[0];
+  if (options.json) {
+    console.log(JSON.stringify(exec3, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}exec show${RESET}`);
+  writeLine();
+  writeLine(`  ${bold}${exec3.squad}/${exec3.agent}${RESET}`);
+  writeLine(`  ${colors.dim}${exec3.id}${RESET}`);
+  writeLine();
+  const statusIcon = exec3.status === "running" ? icons.running : exec3.status === "completed" ? icons.success : icons.error;
+  const statusColor = exec3.status === "running" ? colors.yellow : exec3.status === "completed" ? colors.green : colors.red;
+  writeLine(`  ${bold}Status${RESET}      ${statusColor}${statusIcon} ${exec3.status}${RESET}`);
+  writeLine(`  ${bold}Task Type${RESET}   ${exec3.taskType}`);
+  writeLine(`  ${bold}Trigger${RESET}     ${exec3.trigger}`);
+  writeLine();
+  writeLine(`  ${bold}Started${RESET}     ${exec3.startTime}`);
+  if (exec3.endTime) {
+    writeLine(`  ${bold}Completed${RESET}   ${exec3.endTime}`);
+  }
+  if (exec3.durationMs) {
+    writeLine(`  ${bold}Duration${RESET}    ${formatDuration2(exec3.durationMs)}`);
+  }
+  writeLine();
+  if (exec3.outcome) {
+    writeLine(`  ${bold}Outcome${RESET}`);
+    writeLine(`  ${colors.dim}${exec3.outcome}${RESET}`);
+    writeLine();
+  }
+  if (exec3.error) {
+    writeLine(`  ${bold}Error${RESET}`);
+    writeLine(`  ${colors.red}${exec3.error}${RESET}`);
+    writeLine();
+  }
+  writeLine(`  ${colors.dim}$${RESET} squads memory show ${colors.cyan}${exec3.squad}${RESET}   ${colors.dim}Squad memory${RESET}`);
+  writeLine(`  ${colors.dim}$${RESET} squads exec list --squad ${colors.cyan}${exec3.squad}${RESET}   ${colors.dim}Squad history${RESET}`);
+  writeLine();
+}
+async function execStatsCommand(options = {}) {
+  await track(Events.CLI_EXEC, { action: "stats", squad: options.squad });
+  const listOptions = {
+    squad: options.squad
+  };
+  const stats = getExecutionStats(listOptions);
+  if (options.json) {
+    console.log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  writeLine();
+  writeLine(`  ${gradient("squads")} ${colors.dim}exec stats${RESET}${options.squad ? ` ${colors.cyan}${options.squad}${RESET}` : ""}`);
+  writeLine();
+  writeLine(`  ${bold}Total${RESET}       ${stats.total}`);
+  writeLine(`  ${colors.yellow}Running${RESET}     ${stats.running}`);
+  writeLine(`  ${colors.green}Completed${RESET}   ${stats.completed}`);
+  writeLine(`  ${colors.red}Failed${RESET}      ${stats.failed}`);
+  writeLine();
+  if (stats.avgDurationMs) {
+    writeLine(`  ${bold}Avg Duration${RESET}  ${formatDuration2(stats.avgDurationMs)}`);
+    writeLine();
+  }
+  const squadEntries = Object.entries(stats.bySquad).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (squadEntries.length > 0) {
+    writeLine(`  ${bold}By Squad${RESET}`);
+    for (const [squad, count] of squadEntries) {
+      writeLine(`  ${colors.cyan}${squad}${RESET}: ${count}`);
+    }
+    writeLine();
+  }
+  const agentEntries = Object.entries(stats.byAgent).sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (agentEntries.length > 0) {
+    writeLine(`  ${bold}Top Agents${RESET}`);
+    for (const [agent, count] of agentEntries) {
+      writeLine(`  ${colors.cyan}${agent}${RESET}: ${count}`);
+    }
+    writeLine();
+  }
+}
+
+// src/commands/tonight.ts
+import ora7 from "ora";
 import fs2 from "fs/promises";
-import path2, { dirname as dirname5 } from "path";
+import path2, { dirname as dirname6 } from "path";
 import { execSync as execSync14, spawn as spawn7 } from "child_process";
 function getProjectRoot2() {
   const squadsDir = findSquadsDir();
   if (squadsDir) {
-    return dirname5(dirname5(squadsDir));
+    return dirname6(dirname6(squadsDir));
   }
   return process.cwd();
 }
@@ -8107,7 +9910,7 @@ async function tonightCommand(targets, options) {
     totalCost: await getCurrentCost(),
     stopped: false
   };
-  const spinner = ora6("Launching agents...").start();
+  const spinner = ora7("Launching agents...").start();
   for (const target of targets) {
     const sessionId = `${target.replace("/", "-")}-${Date.now()}`;
     const logFile = path2.join(logDir, `${sessionId}.log`);
@@ -8295,17 +10098,18 @@ process.stderr.on("error", (err) => {
   throw err;
 });
 var envPaths = [
-  join17(process.cwd(), ".env"),
-  join17(process.cwd(), "..", "hq", ".env"),
-  join17(homedir5(), "agents-squads", "hq", ".env")
+  join21(process.cwd(), ".env"),
+  join21(process.cwd(), "..", "hq", ".env"),
+  join21(homedir5(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync17(envPath)) {
+  if (existsSync19(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
 }
 applyStackConfig();
+await autoUpdateOnStartup();
 registerExitHandler();
 var program = new Command();
 program.name("squads").description("A CLI for humans and agents").version(version).showSuggestionAfterError(true).configureOutput({
@@ -8320,10 +10124,20 @@ program.name("squads").description("A CLI for humans and agents").version(versio
   throw err;
 });
 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").action((target, options) => runCommand(target, { ...options, timeout: parseInt(options.timeout, 10) }));
+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) }));
 program.command("list").description("List agents and squads").option("-s, --squads", "List squads only").option("-a, --agents", "List agents only").action(listCommand);
 program.command("status [squad]").description("Show squad status and state").option("-v, --verbose", "Show detailed status").action(statusCommand);
 program.command("dashboard").alias("dash").description("Show comprehensive goals and metrics dashboard").option("-v, --verbose", "Show additional details").option("-c, --ceo", "Executive summary with priorities and blockers").option("-f, --full", "Include GitHub PR/issue stats (slower, ~30s)").action((options) => dashboardCommand({ ...options, fast: !options.full }));
+var context = program.command("context").description("View and manage squad execution context");
+context.command("show <squad>").description("Show context for a squad (MCP, skills, model, budget)").option("--json", "Output as JSON").action(contextShowCommand);
+context.command("list").description("List context for all squads").option("--json", "Output as JSON").action(contextListCommand);
+program.command("cost").description("Show cost summary (today, week, by squad)").option("-s, --squad <squad>", "Filter to specific squad").option("--json", "Output as JSON").action(costCommand);
+program.command("budget").description("Check budget status for a squad").argument("<squad>", "Squad to check").option("--json", "Output as JSON").action(budgetCheckCommand);
+var exec2 = program.command("exec").description("View execution history and statistics");
+exec2.command("list").description("List recent executions").option("-s, --squad <squad>", "Filter by squad").option("-a, --agent <agent>", "Filter by agent").option("--status <status>", "Filter by status (running, completed, failed)").option("-n, --limit <n>", "Number of executions to show", "20").option("--json", "Output as JSON").action((options) => execListCommand({ ...options, limit: parseInt(options.limit, 10) }));
+exec2.command("show <id>").description("Show execution details").option("--json", "Output as JSON").action(execShowCommand);
+exec2.command("stats").description("Show execution statistics").option("-s, --squad <squad>", "Filter by squad").option("--json", "Output as JSON").action(execStatsCommand);
+exec2.action((options) => execListCommand(options));
 program.command("issues").description("Show GitHub issues across repos").option("-o, --org <org>", "GitHub organization", "agents-squads").option("-r, --repos <repos>", "Comma-separated repo names").action(issuesCommand);
 program.command("solve-issues").description("Solve ready-to-fix issues by creating PRs").option("-r, --repo <repo>", "Target repo (hq, agents-squads-web)").option("-i, --issue <number>", "Specific issue number", parseInt).option("-d, --dry-run", "Show what would be solved").option("-e, --execute", "Execute with Claude CLI").action(solveIssuesCommand);
 program.command("open-issues").description("Run evaluators/critics to find and create issues").option("-s, --squad <squad>", "Target squad (website, engineering, etc.)").option("-a, --agent <agent>", "Specific evaluator agent").option("-d, --dry-run", "Show what would run").option("-e, --execute", "Execute with Claude CLI").action(openIssuesCommand);
@@ -8377,11 +10191,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-JCQ34BEU.js");
+  const { buildCurrentSessionSummary } = await import("./sessions-B6GVXJ2H.js");
   let data;
   if (options.file) {
-    const { readFileSync: readFileSync13 } = await import("fs");
-    data = JSON.parse(readFileSync13(options.file, "utf-8"));
+    const { readFileSync: readFileSync17 } = await import("fs");
+    data = JSON.parse(readFileSync17(options.file, "utf-8"));
   } else if (options.data) {
     data = JSON.parse(options.data);
   } else if (!process.stdin.isTTY) {
@@ -8414,6 +10228,8 @@ stack.command("down").description("Stop Docker containers").action(stackDownComm
 stack.command("health").description("Comprehensive health check with diagnostics").option("-v, --verbose", "Show logs for unhealthy services").action((options) => stackHealthCommand(options.verbose));
 stack.command("logs <service>").description("Show logs for a service (postgres, redis, neo4j, bridge, langfuse, mem0, engram)").option("-n, --tail <lines>", "Number of lines to show", "50").action((service, options) => stackLogsCommand(service, parseInt(options.tail, 10)));
 registerTriggerCommand(program);
+registerSkillCommand(program);
+registerPermissionsCommand(program);
 var tonight = program.command("tonight").description("Run agents autonomously overnight with safety limits");
 tonight.command("run <targets...>").description("Start tonight mode with specified squads/agents").option("-c, --cost-cap <usd>", "Max USD to spend (default: 50)", "50").option("-s, --stop-at <time>", "Stop time HH:MM (default: 07:00)", "07:00").option("-r, --max-retries <n>", "Max restarts per agent (default: 3)", "3").option("-d, --dry-run", "Show what would run without executing").option("-v, --verbose", "Verbose output").action((targets, options) => tonightCommand(targets, {
   costCap: parseFloat(options.costCap),