squads-cli 0.4.6 → 0.4.7

package/dist/cli.js

@@ -28,15 +28,15 @@ import {
   truncate,
   updateHeartbeat,
   writeLine
-} from "./chunk-G63RBKDH.js";
+} from "./chunk-EGOVJOZJ.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";
@@ -286,8 +286,10 @@ 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"))) {
@@ -303,7 +305,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 +318,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 +343,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) {
@@ -487,6 +493,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",
@@ -1153,6 +1162,7 @@ import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync
 // 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 matter from "gray-matter";
 function findSquadsDir() {
   let dir = process.cwd();
   for (let i = 0; i < 5; i++) {
@@ -1215,17 +1225,24 @@ function listAgents(squadsDir, squadName) {
   return agents;
 }
 function parseSquadFile(filePath) {
-  const content = readFileSync2(filePath, "utf-8");
-  const lines = content.split("\n");
+  const rawContent = readFileSync2(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 +1262,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 +1278,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
           });
         }
       }
@@ -1409,7 +1434,280 @@ 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 = join4(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 = join4(configsDir, configFile);
+    if (existsSync4(configPath)) {
+      return configPath;
+    }
+  }
+  return join4(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)) {
@@ -1451,34 +1749,75 @@ function logExecution(record) {
   }
   let content = "";
   if (existsSync4(logPath)) {
-    content = readFileSync3(logPath, "utf-8");
+    content = readFileSync3(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);
 }
-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");
   const endTime = (/* @__PURE__ */ new Date()).toISOString();
-  content = content.replace(
-    /Status: running\n$/,
-    `Status: ${status}
-Completed: ${endTime}
-${outcome ? `Outcome: ${outcome}
-` : ""}`
-  );
+  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);
   writeFileSync3(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();
   if (!squadsDir) {
@@ -1508,6 +1847,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}`);
@@ -1697,7 +2039,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 +2060,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 +2073,40 @@ async function runAgent(agentName, agentPath, squadName, options) {
     }
     return;
   }
+  const squadsDir = findSquadsDir();
+  if (squadsDir) {
+    const squadFilePath = join4(squadsDir, squadName, "SQUAD.md");
+    if (existsSync4(squadFilePath)) {
+      const squadContent = readFileSync3(squadFilePath, "utf-8");
+      const permContext = buildContextFromSquad(squadName, squadContent, agentName);
+      const mcpServers = extractMcpServersFromDefinition(definition);
+      const execRequest = {
+        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 +2138,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 +2150,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 +2179,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 +2225,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 +2254,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 +2286,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();
@@ -4705,9 +5127,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 +5141,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 +5171,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 +5182,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 +5193,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 +5423,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 +7067,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 +7103,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 +7133,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 +7158,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 +8415,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 +9853,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,12 +10041,12 @@ 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;
   }
@@ -8320,10 +10066,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 +10133,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-SEITSWEV.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 +10170,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),