squads-cli 0.2.1 → 0.2.2

package/dist/cli.js

@@ -4,6 +4,20 @@ import {
   getNextCronRun,
   parseCooldown
 } from "./chunk-RM6BWILN.js";
+import {
+  registerExitHandler,
+  track,
+  version
+} from "./chunk-QJ7C7CMB.js";
+import {
+  RESET,
+  bold,
+  colors,
+  writeLine
+} from "./chunk-M5FXNY6Y.js";
+import {
+  findMemoryDir
+} from "./chunk-ZTQ7ISUR.js";
 import {
   getApiUrl
 } from "./chunk-EHQJHRIW.js";
@@ -11,32 +25,26 @@ import {
   loadSession
 } from "./chunk-Z2UKDBNL.js";
 import {
-  registerExitHandler,
-  track,
-  version
-} from "./chunk-QJ7C7CMB.js";
+  detectTier
+} from "./chunk-O632SBON.js";
+import {
+  calculateCostSummary,
+  queryExecutions
+} from "./chunk-NP5BDPE6.js";
 import {
+  findProjectRoot,
   findSquadsDir,
   listAgents,
   listSquads,
   loadSquad,
   resolveMcpConfigPath
 } from "./chunk-TYFTF53O.js";
-import {
-  findMemoryDir
-} from "./chunk-ZTQ7ISUR.js";
-import {
-  RESET,
-  bold,
-  colors,
-  writeLine
-} from "./chunk-M5FXNY6Y.js";
 import "./chunk-7OCVIDC7.js";
 
 // src/cli.ts
 import { config } from "dotenv";
-import { existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join10 } from "path";
 import { homedir as homedir3 } from "os";
 import { Command } from "commander";
 import chalk6 from "chalk";
@@ -874,7 +882,7 @@ async function startScheduler() {
     }
   );
   child.unref();
-  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  await new Promise((resolve2) => setTimeout(resolve2, 2e3));
   const check = isRunning();
   if (check.running) {
     writeLine(chalk2.green(`
@@ -1194,7 +1202,7 @@ Approval: ${approvalId}`);
   }
   writeLine(chalk3.dim(`Waiting for decision on ${approvalId}...`));
   while (Date.now() - startTime < timeoutMs) {
-    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 5e3));
     const updated = await check();
     if (!updated) {
       console.error(chalk3.red("Approval disappeared"));
@@ -1226,7 +1234,7 @@ function registerApprovalCommand(program2) {
 Types: issue, pr, content, run, brief
 
 Examples:
-  $ squads approval send pr --title "Merge feature X" --json '{"repo":"agents-squads/hq","number":123}'
+  $ squads approval send pr --title "Merge feature X" --json '{"repo":"my-org/my-repo","number":123}'
   $ squads approval send content -t "LinkedIn post" -d "New blog announcement"
   $ echo '{"title":"Run overnight"}' | squads approval send run --json -
 `
@@ -1446,13 +1454,13 @@ async function deployPullCommand(options) {
     writeLine("");
     writeLine(chalk4.bold("Recent Platform Executions"));
     writeLine(chalk4.dim("\u2500".repeat(70)));
-    for (const exec2 of executions) {
-      const statusColor = exec2.status === "completed" ? chalk4.green : exec2.status === "failed" ? chalk4.red : exec2.status === "running" ? chalk4.yellow : chalk4.dim;
-      const cost = exec2.cost_usd !== null ? chalk4.dim(`$${exec2.cost_usd.toFixed(2)}`) : "";
-      const time = new Date(exec2.started_at).toLocaleString();
-      writeLine(`  ${statusColor(exec2.status.padEnd(10))} ${chalk4.cyan(exec2.trigger_name)} ${chalk4.dim(time)} ${cost}`);
-      if (options.verbose && exec2.completed_at) {
-        const duration = (new Date(exec2.completed_at).getTime() - new Date(exec2.started_at).getTime()) / 1e3;
+    for (const exec4 of executions) {
+      const statusColor = exec4.status === "completed" ? chalk4.green : exec4.status === "failed" ? chalk4.red : exec4.status === "running" ? chalk4.yellow : chalk4.dim;
+      const cost = exec4.cost_usd !== null ? chalk4.dim(`$${exec4.cost_usd.toFixed(2)}`) : "";
+      const time = new Date(exec4.started_at).toLocaleString();
+      writeLine(`  ${statusColor(exec4.status.padEnd(10))} ${chalk4.cyan(exec4.trigger_name)} ${chalk4.dim(time)} ${cost}`);
+      if (options.verbose && exec4.completed_at) {
+        const duration = (new Date(exec4.completed_at).getTime() - new Date(exec4.started_at).getTime()) / 1e3;
         writeLine(`    ${chalk4.dim(`duration: ${duration.toFixed(0)}s`)}`);
       }
     }
@@ -2170,6 +2178,928 @@ Examples:
   cmd.command("reflect").description("Trigger meta-cognition reflection").option("-s, --scope <scope>", "Reflection scope (business, squad:X, agent:X)", "business").action(async (options) => reflectCommand(options));
 }
 
+// src/lib/idp/catalog-loader.ts
+import { readdirSync as readdirSync5, readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+import matter3 from "gray-matter";
+
+// src/lib/idp/resolver.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join6, resolve } from "path";
+function findIdpDir() {
+  const envPath = process.env.SQUADS_IDP_PATH;
+  if (envPath && existsSync7(envPath)) {
+    return resolve(envPath);
+  }
+  const projectRoot = findProjectRoot();
+  if (projectRoot) {
+    const colocated = join6(projectRoot, ".agents", "idp");
+    if (existsSync7(join6(colocated, "catalog"))) {
+      return colocated;
+    }
+    const sibling = join6(projectRoot, "..", "idp");
+    if (existsSync7(join6(sibling, "catalog"))) {
+      return resolve(sibling);
+    }
+  }
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const absolute = join6(home, "agents-squads", "idp");
+  if (existsSync7(join6(absolute, "catalog"))) {
+    return absolute;
+  }
+  return null;
+}
+
+// src/lib/idp/catalog-loader.ts
+function loadYaml(filePath) {
+  if (!existsSync8(filePath)) return null;
+  try {
+    const raw = readFileSync7(filePath, "utf-8");
+    const { data } = matter3(`---
+${raw}
+---`);
+    return data;
+  } catch {
+    return null;
+  }
+}
+function loadCatalog() {
+  const idpDir = findIdpDir();
+  if (!idpDir) return [];
+  const catalogDir = join7(idpDir, "catalog");
+  if (!existsSync8(catalogDir)) return [];
+  const entries = [];
+  for (const file of readdirSync5(catalogDir).filter((f) => f.endsWith(".yaml")).sort()) {
+    const entry = loadYaml(join7(catalogDir, file));
+    if (entry?.metadata?.name) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function loadService(name) {
+  const idpDir = findIdpDir();
+  if (!idpDir) return null;
+  const filePath = join7(idpDir, "catalog", `${name}.yaml`);
+  return loadYaml(filePath);
+}
+function loadScorecard(name) {
+  const idpDir = findIdpDir();
+  if (!idpDir) return null;
+  const filePath = join7(idpDir, "scorecards", `${name}.yaml`);
+  return loadYaml(filePath);
+}
+function loadDependencyGraph() {
+  const idpDir = findIdpDir();
+  if (!idpDir) return null;
+  return loadYaml(join7(idpDir, "dependencies", "graph.yaml"));
+}
+
+// src/lib/idp/scorecard-engine.ts
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
+import { execSync as execSync3 } from "child_process";
+function exec(cmd, cwd) {
+  try {
+    return execSync3(cmd, { encoding: "utf-8", timeout: 15e3, cwd, stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function ghAvailable() {
+  return exec("gh --version") !== null;
+}
+function runCheck(check, service, repoPath) {
+  const result = { name: check.name, passed: false, weight: check.weight, detail: "unknown" };
+  const repo = service.metadata.repo;
+  switch (check.name) {
+    case "ci-passing": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const out = exec(`gh api repos/${repo}/actions/runs?per_page=1&status=completed --jq '.[0].conclusion // empty'`);
+      const out2 = exec(`gh api repos/${repo}/actions/runs --jq '.workflow_runs[0].conclusion // empty'`);
+      const conclusion = out || out2;
+      if (conclusion === "success") {
+        result.passed = true;
+        result.detail = "latest run: success";
+      } else if (conclusion) {
+        result.detail = `latest run: ${conclusion}`;
+      } else {
+        result.detail = "no CI runs found";
+      }
+      break;
+    }
+    case "test-coverage": {
+      if (service.spec.ci.test_command && service.spec.ci.test_command !== "null") {
+        result.passed = true;
+        result.detail = `test command defined: ${service.spec.ci.test_command}`;
+      } else {
+        result.detail = "no test command configured";
+      }
+      break;
+    }
+    case "build-succeeds": {
+      if (repoPath && service.spec.ci.build_command) {
+        const buildResult = exec(`cd "${repoPath}" && ${service.spec.ci.build_command} 2>&1`);
+        if (buildResult !== null) {
+          result.passed = true;
+          result.detail = "build passed";
+        } else {
+          result.detail = "build failed";
+        }
+      } else {
+        result.detail = repoPath ? "no build command" : "repo not found locally";
+      }
+      break;
+    }
+    case "no-security-alerts": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const alerts = exec(`gh api repos/${repo}/dependabot/alerts --jq '[.[] | select(.state=="open" and (.security_advisory.severity=="high" or .security_advisory.severity=="critical"))] | length'`);
+      if (alerts === "0") {
+        result.passed = true;
+        result.detail = "no high/critical alerts";
+      } else if (alerts) {
+        result.detail = `${alerts} high/critical alerts`;
+      } else {
+        result.detail = "could not check alerts";
+      }
+      break;
+    }
+    case "readme-exists": {
+      if (repoPath) {
+        const readmePath = join8(repoPath, "README.md");
+        if (existsSync9(readmePath)) {
+          const size = statSync2(readmePath).size;
+          if (size > 100) {
+            result.passed = true;
+            result.detail = `README.md (${size} bytes)`;
+          } else {
+            result.detail = `README.md too short (${size} bytes)`;
+          }
+        } else {
+          result.detail = "README.md not found";
+        }
+      } else {
+        result.detail = "repo not found locally";
+      }
+      break;
+    }
+    case "branch-protection": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const protection = exec(`gh api repos/${repo}/branches/${service.spec.branches.default}/protection --jq '.required_status_checks.strict // false' 2>/dev/null`);
+      if (protection && protection !== "null") {
+        result.passed = true;
+        result.detail = "branch protection enabled";
+      } else {
+        result.detail = "no branch protection";
+      }
+      break;
+    }
+    case "deploy-frequency": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const runs = exec(`gh api repos/${repo}/actions/runs --jq '[.workflow_runs[] | select(.event=="push" and .head_branch=="${service.spec.branches.default}")] | length'`);
+      const count = parseInt(runs || "0", 10);
+      if (count > 0) {
+        result.passed = true;
+        result.detail = `${count} deploys recently`;
+      } else {
+        result.detail = "no recent deploys";
+      }
+      break;
+    }
+    case "stale-prs": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const stalePrs = exec(`gh pr list --repo ${repo} --state open --json updatedAt --jq '[.[] | select((now - (.updatedAt | fromdateiso8601)) > 1209600)] | length'`);
+      const count = parseInt(stalePrs || "0", 10);
+      if (count === 0) {
+        result.passed = true;
+        result.detail = "no stale PRs";
+      } else {
+        result.detail = `${count} PRs stale >14d`;
+      }
+      break;
+    }
+    case "recent-activity": {
+      if (repoPath) {
+        const commits = exec(`git -C "${repoPath}" log --since="30 days ago" --oneline 2>/dev/null | wc -l`);
+        const count = parseInt(commits?.trim() || "0", 10);
+        if (count > 0) {
+          result.passed = true;
+          result.detail = `${count} commits in last 30d`;
+        } else {
+          result.detail = "no commits in 30 days";
+        }
+      } else if (ghAvailable()) {
+        const out = exec(`gh api repos/${repo}/commits?per_page=1 --jq '.[0].commit.committer.date // empty'`);
+        if (out) {
+          result.passed = true;
+          result.detail = `last commit: ${out.slice(0, 10)}`;
+        } else {
+          result.detail = "no recent commits";
+        }
+      } else {
+        result.detail = "repo not found locally";
+      }
+      break;
+    }
+    case "no-stale-prs": {
+      if (!ghAvailable()) {
+        result.detail = "gh CLI not available";
+        break;
+      }
+      const stalePrs = exec(`gh pr list --repo ${repo} --state open --json updatedAt --jq '[.[] | select((now - (.updatedAt | fromdateiso8601)) > 604800)] | length'`);
+      const count = parseInt(stalePrs || "0", 10);
+      if (count === 0) {
+        result.passed = true;
+        result.detail = "no stale PRs";
+      } else {
+        result.detail = `${count} PRs stale >7d`;
+      }
+      break;
+    }
+    case "clean-structure": {
+      result.passed = true;
+      result.detail = "check not implemented (v0.2)";
+      break;
+    }
+    default:
+      result.detail = `unknown check: ${check.name}`;
+  }
+  return result;
+}
+function findRepoPath(repoFullName) {
+  const repoName = repoFullName.split("/")[1];
+  if (!repoName) return null;
+  const home = process.env.HOME || "";
+  const candidates = [
+    join8(home, "agents-squads", repoName),
+    join8(process.cwd(), "..", repoName)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync9(candidate)) return candidate;
+  }
+  return null;
+}
+function evaluateService(service, scorecard) {
+  const repoPath = findRepoPath(service.metadata.repo);
+  const checks = [];
+  for (const check of scorecard.checks) {
+    checks.push(runCheck(check, service, repoPath));
+  }
+  const totalWeight = checks.reduce((sum, c) => sum + c.weight, 0);
+  const earnedWeight = checks.filter((c) => c.passed).reduce((sum, c) => sum + c.weight, 0);
+  const score = totalWeight > 0 ? Math.round(earnedWeight / totalWeight * 100) : 0;
+  let grade = "F";
+  const sortedGrades = Object.entries(scorecard.grades).sort((a, b) => b[1].min - a[1].min);
+  for (const [g, { min }] of sortedGrades) {
+    if (score >= min) {
+      grade = g;
+      break;
+    }
+  }
+  return {
+    service: service.metadata.name,
+    scorecard: scorecard.metadata.name,
+    score,
+    grade,
+    checks,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/commands/catalog.ts
+function noIdp() {
+  if (!findIdpDir()) {
+    writeLine(`  ${colors.red}IDP not found${RESET}`);
+    writeLine(`  ${colors.dim}Set SQUADS_IDP_PATH or clone the idp repo as a sibling directory.${RESET}`);
+    return true;
+  }
+  return false;
+}
+function registerCatalogCommands(program2) {
+  const catalog = program2.command("catalog").description("Service catalog \u2014 browse, inspect, and validate services");
+  catalog.command("list").description("List all services in the catalog").option("--type <type>", "Filter by type (product, domain)").option("--json", "Output as JSON").action((opts) => {
+    if (noIdp()) return;
+    const entries = loadCatalog();
+    if (entries.length === 0) {
+      writeLine("  No catalog entries found.");
+      return;
+    }
+    const filtered = opts.type ? entries.filter((e) => e.spec.type === opts.type) : entries;
+    if (opts.json) {
+      console.log(JSON.stringify(filtered.map((e) => ({
+        name: e.metadata.name,
+        type: e.spec.type,
+        stack: e.spec.stack,
+        owner: e.metadata.owner,
+        repo: e.metadata.repo
+      })), null, 2));
+      return;
+    }
+    writeLine();
+    writeLine(`  ${bold}Service Catalog${RESET} (${filtered.length} services)`);
+    writeLine();
+    const products = filtered.filter((e) => e.spec.type === "product");
+    const domains = filtered.filter((e) => e.spec.type === "domain");
+    if (products.length > 0) {
+      writeLine(`  ${colors.cyan}Product Services${RESET}`);
+      writeLine();
+      for (const e of products) {
+        const ci = e.spec.ci.template ? `ci:${e.spec.ci.template}` : "no-ci";
+        const deploy = e.spec.deploy?.target || "manual";
+        writeLine(`  ${bold}${e.metadata.name}${RESET}  ${colors.dim}${e.spec.stack} | ${ci} | deploy:${deploy} | owner:${e.metadata.owner}${RESET}`);
+        writeLine(`    ${colors.dim}${e.metadata.description}${RESET}`);
+      }
+      writeLine();
+    }
+    if (domains.length > 0) {
+      writeLine(`  ${colors.cyan}Domain Repos${RESET}`);
+      writeLine();
+      for (const e of domains) {
+        writeLine(`  ${e.metadata.name}  ${colors.dim}owner:${e.metadata.owner} | ${e.metadata.repo}${RESET}`);
+      }
+      writeLine();
+    }
+  });
+  catalog.command("show <service>").description("Show detailed info for a service").option("--json", "Output as JSON").action((serviceName, opts) => {
+    if (noIdp()) return;
+    const entry = loadService(serviceName);
+    if (!entry) {
+      writeLine(`  ${colors.red}Service not found: ${serviceName}${RESET}`);
+      writeLine(`  ${colors.dim}Run 'squads catalog list' to see available services.${RESET}`);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(entry, null, 2));
+      return;
+    }
+    writeLine();
+    writeLine(`  ${bold}${entry.metadata.name}${RESET}  ${colors.dim}${entry.spec.type}${RESET}`);
+    writeLine(`  ${entry.metadata.description}`);
+    writeLine();
+    writeLine(`  ${colors.cyan}General${RESET}`);
+    writeLine(`    Owner:      ${entry.metadata.owner}`);
+    writeLine(`    Repo:       ${entry.metadata.repo}`);
+    writeLine(`    Stack:      ${entry.spec.stack}${entry.spec.framework ? ` (${entry.spec.framework})` : ""}`);
+    writeLine(`    Scorecard:  ${entry.spec.scorecard}`);
+    writeLine(`    Tags:       ${entry.metadata.tags?.join(", ") || "none"}`);
+    writeLine();
+    writeLine(`  ${colors.cyan}Branches${RESET}`);
+    writeLine(`    Default:    ${entry.spec.branches.default}`);
+    writeLine(`    Workflow:   ${entry.spec.branches.workflow}`);
+    if (entry.spec.branches.development) {
+      writeLine(`    Dev branch: ${entry.spec.branches.development}`);
+    }
+    writeLine();
+    if (entry.spec.ci.template) {
+      writeLine(`  ${colors.cyan}CI/CD${RESET}`);
+      writeLine(`    Template:   ${entry.spec.ci.template}`);
+      writeLine(`    Checks:     ${entry.spec.ci.required_checks.join(", ") || "none"}`);
+      if (entry.spec.ci.build_command) writeLine(`    Build:      ${entry.spec.ci.build_command}`);
+      if (entry.spec.ci.test_command) writeLine(`    Test:       ${entry.spec.ci.test_command}`);
+      writeLine();
+    }
+    if (entry.spec.deploy) {
+      writeLine(`  ${colors.cyan}Deploy${RESET}`);
+      writeLine(`    Target:     ${entry.spec.deploy.target}`);
+      writeLine(`    Trigger:    ${entry.spec.deploy.trigger}`);
+      if (entry.spec.deploy.environments) {
+        for (const env2 of entry.spec.deploy.environments) {
+          writeLine(`    ${env2.name}: ${env2.url}`);
+        }
+      }
+      writeLine();
+    }
+    if (entry.spec.dependencies.runtime.length > 0) {
+      writeLine(`  ${colors.cyan}Dependencies${RESET}`);
+      for (const dep of entry.spec.dependencies.runtime) {
+        const req = dep.required === false ? "(optional)" : "(required)";
+        writeLine(`    \u2192 ${dep.service} ${dep.version || ""} ${req}`);
+        writeLine(`      ${colors.dim}${dep.description}${RESET}`);
+      }
+      writeLine();
+    }
+    if (entry.spec.health.length > 0) {
+      writeLine(`  ${colors.cyan}Health Endpoints${RESET}`);
+      for (const h of entry.spec.health) {
+        writeLine(`    ${h.name}: ${h.url}`);
+      }
+      writeLine();
+    }
+  });
+  catalog.command("check [service]").description("Run scorecard checks for a service (or all)").option("--json", "Output as JSON").action((serviceName, opts) => {
+    if (noIdp()) return;
+    const entries = serviceName ? [loadService(serviceName)].filter(Boolean) : loadCatalog();
+    if (entries.length === 0) {
+      writeLine(`  ${colors.red}No services found${RESET}`);
+      return;
+    }
+    const results = [];
+    for (const entry of entries) {
+      const scorecard = loadScorecard(entry.spec.scorecard);
+      if (!scorecard) {
+        writeLine(`  ${colors.dim}No scorecard '${entry.spec.scorecard}' for ${entry.metadata.name}${RESET}`);
+        continue;
+      }
+      const result = evaluateService(entry, scorecard);
+      results.push(result);
+      if (!opts.json) {
+        const gradeColor = result.grade === "A" ? colors.green : result.grade === "B" ? colors.cyan : result.grade === "C" ? colors.yellow : colors.red;
+        writeLine();
+        writeLine(`  ${bold}${result.service}${RESET}  ${gradeColor}${result.grade}${RESET} (${result.score}/100)`);
+        for (const check of result.checks) {
+          const icon = check.passed ? `${colors.green}pass${RESET}` : `${colors.red}fail${RESET}`;
+          writeLine(`    ${icon}  ${check.name} ${colors.dim}(${check.detail})${RESET}`);
+        }
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      writeLine();
+    }
+  });
+}
+
+// src/commands/release-check.ts
+async function checkHealth(url, expect) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+    return { ok: response.status === expect, status: response.status };
+  } catch (e) {
+    return { ok: false, status: e instanceof Error ? e.message : "unreachable" };
+  }
+}
+function registerReleaseCommands(program2) {
+  const release = program2.command("release").description("Release management \u2014 pre-deploy checks and status");
+  release.command("pre-check <service>").description("Validate dependencies and health before deploying a service").option("--skip-health", "Skip health endpoint checks").action(async (serviceName, opts) => {
+    const idpDir = findIdpDir();
+    if (!idpDir) {
+      writeLine(`  ${colors.red}IDP not found${RESET}`);
+      return;
+    }
+    const service = loadService(serviceName);
+    if (!service) {
+      writeLine(`  ${colors.red}Service not found: ${serviceName}${RESET}`);
+      return;
+    }
+    const graph = loadDependencyGraph();
+    const deps = service.spec.dependencies.runtime;
+    writeLine();
+    writeLine(`  ${bold}Release Pre-Check: ${serviceName}${RESET}`);
+    writeLine();
+    let allGreen = true;
+    if (deps.length === 0) {
+      writeLine(`  ${colors.green}pass${RESET}  No runtime dependencies`);
+    } else {
+      writeLine(`  ${colors.cyan}Dependencies${RESET}`);
+      for (const dep of deps) {
+        const depService = loadService(dep.service);
+        const req = dep.required !== false;
+        if (!depService) {
+          if (dep.type === "infrastructure") {
+            writeLine(`    ${colors.dim}skip${RESET}  ${dep.service} (infrastructure \u2014 not in catalog)`);
+            continue;
+          }
+          if (req) {
+            writeLine(`    ${colors.red}fail${RESET}  ${dep.service} \u2014 not found in catalog`);
+            allGreen = false;
+          } else {
+            writeLine(`    ${colors.yellow}warn${RESET}  ${dep.service} \u2014 not in catalog (optional)`);
+          }
+          continue;
+        }
+        if (!opts.skipHealth && depService.spec.health.length > 0) {
+          for (const h of depService.spec.health) {
+            const result = await checkHealth(h.url, h.expect);
+            if (result.ok) {
+              writeLine(`    ${colors.green}pass${RESET}  ${dep.service}/${h.name} \u2014 ${result.status}`);
+            } else if (req) {
+              writeLine(`    ${colors.red}fail${RESET}  ${dep.service}/${h.name} \u2014 ${result.status}`);
+              allGreen = false;
+            } else {
+              writeLine(`    ${colors.yellow}warn${RESET}  ${dep.service}/${h.name} \u2014 ${result.status} (optional)`);
+            }
+          }
+        } else {
+          writeLine(`    ${colors.dim}skip${RESET}  ${dep.service} health check (${opts.skipHealth ? "skipped" : "no endpoints"})`);
+        }
+      }
+    }
+    writeLine();
+    if (graph) {
+      const order = graph.deploy_order;
+      let servicePhase = -1;
+      for (let i = 0; i < order.length; i++) {
+        if (order[i].includes(serviceName)) {
+          servicePhase = i;
+          break;
+        }
+      }
+      if (servicePhase >= 0) {
+        writeLine(`  ${colors.cyan}Deploy Order${RESET}`);
+        for (let i = 0; i < order.length; i++) {
+          const marker = i === servicePhase ? `${colors.green}\u2192${RESET}` : " ";
+          const phase = order[i].join(", ");
+          writeLine(`  ${marker} Phase ${i + 1}: ${i === servicePhase ? bold : colors.dim}${phase}${RESET}`);
+        }
+        writeLine();
+      }
+    }
+    if (!opts.skipHealth && service.spec.health.length > 0) {
+      writeLine(`  ${colors.cyan}Self Health${RESET}`);
+      for (const h of service.spec.health) {
+        const result = await checkHealth(h.url, h.expect);
+        if (result.ok) {
+          writeLine(`    ${colors.green}pass${RESET}  ${h.name} \u2014 ${result.status}`);
+        } else {
+          writeLine(`    ${colors.yellow}warn${RESET}  ${h.name} \u2014 ${result.status}`);
+        }
+      }
+      writeLine();
+    }
+    if (allGreen) {
+      writeLine(`  ${colors.green}All checks passed \u2014 safe to deploy ${serviceName}${RESET}`);
+    } else {
+      writeLine(`  ${colors.red}Pre-check failed \u2014 fix issues before deploying ${serviceName}${RESET}`);
+    }
+    writeLine();
+  });
+}
+
+// src/commands/observability.ts
+function registerObservabilityCommands(program2) {
+  const obs = program2.command("obs").description("Observability \u2014 execution history, token costs, and trends");
+  obs.command("history").description("Show execution history with tokens and cost").option("-s, --squad <squad>", "Filter by squad").option("-a, --agent <agent>", "Filter by agent").option("-n, --limit <n>", "Number of records", "20").option("--since <date>", "Since date (ISO or relative: 1d, 7d, 30d)").option("--json", "Output as JSON").action((opts) => {
+    let since = opts.since;
+    if (since && /^\d+d$/.test(since)) {
+      const days = parseInt(since, 10);
+      since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    }
+    const records = queryExecutions({
+      squad: opts.squad,
+      agent: opts.agent,
+      since,
+      limit: parseInt(opts.limit, 10)
+    });
+    if (records.length === 0) {
+      writeLine(`
+  ${colors.dim}No executions found. Run \`squads run <squad>\` to generate data.${RESET}
+`);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(records, null, 2));
+      return;
+    }
+    writeLine(`
+  ${bold}Execution History${RESET} (${records.length} records)
+`);
+    for (const r of records) {
+      const icon = r.status === "completed" ? `${colors.green}pass${RESET}` : r.status === "failed" ? `${colors.red}fail${RESET}` : `${colors.yellow}timeout${RESET}`;
+      const dur = r.duration_ms > 6e4 ? `${Math.round(r.duration_ms / 6e4)}m` : `${Math.round(r.duration_ms / 1e3)}s`;
+      const cost = r.cost_usd > 0 ? `$${r.cost_usd.toFixed(3)}` : "$\u2014";
+      const tok = r.input_tokens + r.output_tokens > 0 ? `${(r.input_tokens + r.output_tokens).toLocaleString()} tok` : "\u2014 tok";
+      const date = r.ts.slice(0, 16).replace("T", " ");
+      const grade = r.grade ? ` ${r.grade}` : "";
+      writeLine(`  ${icon}  ${bold}${r.squad}/${r.agent}${RESET}  ${colors.dim}${date}  ${dur}  ${tok}  ${cost}  ${r.model}${grade}${RESET}`);
+      if (r.error) writeLine(`       ${colors.red}${r.error.slice(0, 80)}${RESET}`);
+      if (r.goals_changed && r.goals_changed.length > 0) {
+        for (const g of r.goals_changed) {
+          writeLine(`       ${colors.green}goal: ${g.name} ${g.before} \u2192 ${g.after}${RESET}`);
+        }
+      }
+    }
+    writeLine();
+  });
+  obs.command("cost").description("Show token spend summary").option("-p, --period <period>", "Time period: today, 7d, 30d, all", "7d").option("--json", "Output as JSON").action((opts) => {
+    const summary = calculateCostSummary(opts.period);
+    if (summary.total_runs === 0) {
+      writeLine(`
+  ${colors.dim}No executions in the last ${opts.period}.${RESET}
+`);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    writeLine(`
+  ${bold}Cost Summary${RESET} (${summary.period})`);
+    writeLine(`
+  Total:  ${bold}$${summary.total_cost.toFixed(2)}${RESET} across ${summary.total_runs} runs`);
+    writeLine(`  Tokens: ${summary.total_input_tokens.toLocaleString()} in / ${summary.total_output_tokens.toLocaleString()} out
+`);
+    const squads = Object.entries(summary.by_squad).sort((a, b) => b[1].cost - a[1].cost);
+    if (squads.length > 0) {
+      writeLine(`  ${colors.cyan}By Squad${RESET}`);
+      for (const [name, data] of squads) {
+        const bar = "\u2588".repeat(Math.max(1, Math.round(data.cost / (summary.total_cost || 1) * 20)));
+        writeLine(`    ${name.padEnd(20)} ${colors.dim}${bar}${RESET} $${data.cost.toFixed(2)} (${data.runs} runs, avg $${data.avg_cost.toFixed(3)})`);
+      }
+      writeLine();
+    }
+    const models = Object.entries(summary.by_model).sort((a, b) => b[1].cost - a[1].cost);
+    if (models.length > 0) {
+      writeLine(`  ${colors.cyan}By Model${RESET}`);
+      for (const [name, data] of models) {
+        writeLine(`    ${name.padEnd(30)} $${data.cost.toFixed(2)} (${data.runs} runs)`);
+      }
+      writeLine();
+    }
+  });
+  obs.command("sync").description("Backfill JSONL execution data to Postgres (Tier 2)").option("--dry-run", "Show what would be synced without sending").action(async (opts) => {
+    const { detectTier: detectTier2 } = await import("./tier-detect-YX2HPNNR.js");
+    const { queryExecutions: queryExecutions2 } = await import("./observability-CL23L7LD.js");
+    const info = await detectTier2();
+    if (info.tier < 2 || !info.urls.api) {
+      writeLine(`
+  ${colors.dim}Tier 2 not available. Run 'squads services up' first.${RESET}
+`);
+      return;
+    }
+    const records = queryExecutions2({ limit: 1e4 });
+    if (records.length === 0) {
+      writeLine(`
+  ${colors.dim}No JSONL records to sync.${RESET}
+`);
+      return;
+    }
+    writeLine(`
+  ${bold}Syncing ${records.length} records to Postgres...${RESET}
+`);
+    let synced = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const record of records) {
+      if (opts.dryRun) {
+        writeLine(`  ${colors.dim}[dry-run] ${record.ts} ${record.squad}/${record.agent} $${record.cost_usd.toFixed(3)}${RESET}`);
+        synced++;
+        continue;
+      }
+      try {
+        const res = await fetch(`${info.urls.api}/agent-executions`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            execution_id: record.id,
+            squad: record.squad,
+            agent: record.agent,
+            model: record.model,
+            status: record.status,
+            input_tokens: record.input_tokens,
+            output_tokens: record.output_tokens,
+            cache_read_tokens: record.cache_read_tokens,
+            cache_write_tokens: record.cache_write_tokens,
+            cost_usd: record.cost_usd,
+            duration_seconds: Math.round(record.duration_ms / 1e3),
+            error_message: record.error || null,
+            metadata: { trigger: record.trigger, provider: record.provider }
+          }),
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (res.ok) {
+          synced++;
+        } else if (res.status === 409) {
+          skipped++;
+        } else {
+          errors++;
+        }
+      } catch {
+        errors++;
+      }
+    }
+    writeLine(`  ${colors.green}Synced: ${synced}${RESET}  ${colors.dim}Skipped: ${skipped}  Errors: ${errors}${RESET}
+`);
+  });
+}
+
+// src/commands/tier.ts
+import { existsSync as existsSync10, readdirSync as readdirSync6 } from "fs";
+function registerTierCommand(program2) {
+  program2.command("tier").description("Show active infrastructure tier and available services").option("--json", "Output as JSON").action(async (opts) => {
+    const info = await detectTier();
+    if (opts.json) {
+      console.log(JSON.stringify(info, null, 2));
+      return;
+    }
+    writeLine();
+    if (info.tier === 1) {
+      writeLine(`  ${bold}Tier 1${RESET} ${colors.dim}(file-based)${RESET}`);
+    } else {
+      writeLine(`  ${bold}Tier 2${RESET} ${colors.green}(local services)${RESET}`);
+    }
+    writeLine();
+    writeLine(`  ${colors.cyan}Data${RESET}`);
+    const executions = queryExecutions({ limit: 1e3 });
+    writeLine(`    Observability:  ${executions.length} executions logged`);
+    const squadsDir = findSquadsDir();
+    if (squadsDir) {
+      const squads = readdirSync6(squadsDir).filter((f) => {
+        try {
+          return existsSync10(`${squadsDir}/${f}/SQUAD.md`);
+        } catch {
+          return false;
+        }
+      });
+      writeLine(`    Squads:         ${squads.length} defined`);
+    }
+    const memoryDir = findMemoryDir();
+    if (memoryDir) {
+      writeLine(`    Memory:         ${memoryDir}`);
+    }
+    const idpDir = findIdpDir();
+    if (idpDir) {
+      const catalog = loadCatalog();
+      writeLine(`    IDP:            ${catalog.length} catalog entries`);
+    } else {
+      writeLine(`    IDP:            not configured`);
+    }
+    writeLine();
+    writeLine(`  ${colors.cyan}Services${RESET}`);
+    const svc = info.services;
+    const icon = (ok) => ok ? `${colors.green}up${RESET}` : `${colors.dim}\u2014${RESET}`;
+    writeLine(`    API:       ${icon(svc.api)}${svc.api ? `  ${info.urls.api}` : ""}`);
+    writeLine(`    Bridge:    ${icon(svc.bridge)}${svc.bridge ? `  ${info.urls.bridge}` : ""}`);
+    writeLine(`    Postgres:  ${icon(svc.postgres)}`);
+    writeLine(`    Redis:     ${icon(svc.redis)}`);
+    writeLine();
+    if (info.tier === 1) {
+      writeLine(`  ${colors.dim}Upgrade: run 'squads services up' for Tier 2${RESET}`);
+      writeLine(`  ${colors.dim}(smart triggers, Postgres, webhooks, budget enforcement)${RESET}`);
+    } else {
+      writeLine(`  ${colors.dim}All local services healthy. Data syncs to Postgres.${RESET}`);
+    }
+    writeLine();
+  });
+}
+
+// src/commands/services.ts
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { join as join9 } from "path";
+function exec2(cmd, opts) {
+  try {
+    return execSync4(cmd, { encoding: "utf-8", timeout: 3e4, stdio: ["pipe", "pipe", "pipe"], ...opts }).trim();
+  } catch {
+    return null;
+  }
+}
+function findComposeFile() {
+  const home = process.env.HOME || "";
+  const candidates = [
+    join9(home, "agents-squads", "engineering", "docker", "docker-compose.yml"),
+    join9(home, "agents-squads", "engineering", "docker", "docker-compose.yaml"),
+    join9(process.cwd(), "..", "engineering", "docker", "docker-compose.yml")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync11(candidate)) return candidate;
+  }
+  return null;
+}
+function dockerAvailable() {
+  return exec2("docker --version") !== null;
+}
+function dockerComposeAvailable() {
+  return exec2("docker compose version") !== null;
+}
+function registerServicesCommands(program2) {
+  const services = program2.command("services").description("Manage Tier 2 local services (Postgres, Redis, API, Bridge)");
+  services.command("up").description("Start local services (Docker required)").option("--webhooks", "Also start ngrok tunnel for GitHub webhooks").option("--telemetry", "Also start OpenTelemetry collector").action(async (opts) => {
+    if (!dockerAvailable()) {
+      writeLine(`
+  ${colors.red}Docker not found.${RESET}`);
+      writeLine(`  ${colors.dim}Install Docker Desktop: https://www.docker.com/products/docker-desktop${RESET}
+`);
+      return;
+    }
+    if (!dockerComposeAvailable()) {
+      writeLine(`
+  ${colors.red}Docker Compose not found.${RESET}
+`);
+      return;
+    }
+    const composeFile = findComposeFile();
+    if (!composeFile) {
+      writeLine(`
+  ${colors.red}docker-compose.yml not found.${RESET}`);
+      writeLine(`  ${colors.dim}Expected at: ../engineering/docker/docker-compose.yml (sibling repo)${RESET}
+`);
+      return;
+    }
+    const composeDir = join9(composeFile, "..");
+    writeLine(`
+  ${bold}Starting Tier 2 services...${RESET}
+`);
+    let profileArgs = "";
+    if (opts.webhooks) profileArgs += " --profile webhooks";
+    if (opts.telemetry) profileArgs += " --profile telemetry";
+    try {
+      writeLine(`  ${colors.dim}docker compose up -d${profileArgs}${RESET}`);
+      execSync4(`docker compose${profileArgs} up -d`, {
+        cwd: composeDir,
+        stdio: "inherit",
+        timeout: 12e4
+      });
+      writeLine();
+      writeLine(`  ${colors.green}Services started.${RESET} Waiting for health checks...`);
+      let healthy = false;
+      for (let i = 0; i < 15; i++) {
+        await new Promise((r) => setTimeout(r, 2e3));
+        const info = await detectTier();
+        if (info.services.api) {
+          healthy = true;
+          break;
+        }
+      }
+      if (healthy) {
+        writeLine(`  ${colors.green}Tier 2 active.${RESET} All services healthy.
+`);
+        writeLine(`  ${colors.dim}API:     http://localhost:8090${RESET}`);
+        writeLine(`  ${colors.dim}Bridge:  http://localhost:8088${RESET}`);
+        writeLine(`  ${colors.dim}Postgres: localhost:5432${RESET}`);
+        writeLine(`  ${colors.dim}Redis:   localhost:6379${RESET}`);
+      } else {
+        writeLine(`  ${colors.yellow}Services started but API not healthy yet. Run 'squads services status' to check.${RESET}`);
+      }
+      writeLine();
+    } catch (e) {
+      writeLine(`
+  ${colors.red}Failed to start services: ${e instanceof Error ? e.message : String(e)}${RESET}
+`);
+    }
+  });
+  services.command("down").description("Stop local services").action(() => {
+    const composeFile = findComposeFile();
+    if (!composeFile) {
+      writeLine(`
+  ${colors.dim}No docker-compose.yml found. Nothing to stop.${RESET}
+`);
+      return;
+    }
+    const composeDir = join9(composeFile, "..");
+    writeLine(`
+  ${bold}Stopping Tier 2 services...${RESET}
+`);
+    try {
+      execSync4("docker compose down", {
+        cwd: composeDir,
+        stdio: "inherit",
+        timeout: 6e4
+      });
+      writeLine(`
+  ${colors.dim}Services stopped. Falling back to Tier 1 (file-based).${RESET}
+`);
+    } catch (e) {
+      writeLine(`
+  ${colors.red}Failed to stop services: ${e instanceof Error ? e.message : String(e)}${RESET}
+`);
+    }
+  });
+  services.command("status").description("Show running services and health").action(async () => {
+    const info = await detectTier();
+    writeLine();
+    writeLine(`  ${bold}Services${RESET} (Tier ${info.tier})
+`);
+    const containers = exec2('docker ps --filter name=squads --format "{{.Names}}\\t{{.Status}}\\t{{.Ports}}"');
+    if (!containers) {
+      writeLine(`  ${colors.dim}No Docker containers running.${RESET}
+`);
+      return;
+    }
+    for (const line of containers.split("\n").filter(Boolean)) {
+      const [name, status, ports] = line.split("	");
+      const healthy = status?.includes("healthy") || status?.includes("Up");
+      const icon = healthy ? `${colors.green}up${RESET}` : `${colors.red}down${RESET}`;
+      const portStr = ports ? `  ${colors.dim}${ports.split(",")[0]}${RESET}` : "";
+      writeLine(`  ${icon}  ${bold}${name}${RESET}${portStr}`);
+    }
+    writeLine();
+    const jobCount = exec2("docker exec squads-postgres psql -U squads -d squads -t -c 'SELECT count(*) FROM procrastinate_jobs;'");
+    const execCount = exec2("docker exec squads-postgres psql -U squads -d squads -t -c 'SELECT count(*) FROM agent_executions;'");
+    if (jobCount || execCount) {
+      writeLine(`  ${colors.cyan}Database${RESET}`);
+      if (jobCount) writeLine(`    Procrastinate jobs: ${jobCount.trim()}`);
+      if (execCount) writeLine(`    Agent executions:  ${execCount.trim()}`);
+      writeLine();
+    }
+  });
+}
+
 // src/cli.ts
 if (!process.stdout.isTTY) {
   chalk6.level = 0;
@@ -2187,12 +3117,12 @@ process.stderr.on("error", (err) => {
   throw err;
 });
 var envPaths = [
-  join6(process.cwd(), ".env"),
-  join6(process.cwd(), "..", "hq", ".env"),
-  join6(homedir3(), "agents-squads", "hq", ".env")
+  join10(process.cwd(), ".env"),
+  join10(process.cwd(), "..", "hq", ".env"),
+  join10(homedir3(), "agents-squads", "hq", ".env")
 ];
 for (const envPath of envPaths) {
-  if (existsSync7(envPath)) {
+  if (existsSync12(envPath)) {
     config({ path: envPath, quiet: true });
     break;
   }
@@ -2318,11 +3248,11 @@ program.name("squads").description("Your AI workforce \u2014 business operating
     writeLine(`  ${colors3.dim}Run \`squads update\` to install${RESET2}`);
     writeLine();
   }
-  const { statusCommand } = await import("./status-AQNLDZVN.js");
+  const { statusCommand } = await import("./status-PFFB2NV6.js");
   await statusCommand(void 0, {});
 });
 program.command("init").description("Plant the seed: create manager agent, CLI skill, and starter squads").option("-p, --provider <provider>", "LLM provider (claude, gemini, openai, ollama, none)").option("--pack <packs...>", "Additional squad packs to install (engineering, marketing, operations, all)").option("--skip-infra", "Skip infrastructure setup prompt").option("--force", "Skip requirement checks (for CI/testing)").option("-y, --yes", "Accept all defaults (non-interactive mode)").option("-q, --quick", "Quick init - create files only, skip interactive prompts").action(async (options) => {
-  const { initCommand } = await import("./init-XQZ7BOGT.js");
+  const { initCommand } = await import("./init-BQSCG57S.js");
   return initCommand(options);
 });
 program.command("add <name>").description("Add a new squad with directory structure and starter files").option("-d, --description <text>", "Squad mission (one sentence)").option("-g, --goal <text>", "First goal for the squad").option("-m, --model <model>", "Default model (default: sonnet)").option("-f, --force", "Overwrite existing squad").option("-y, --yes", "Accept all defaults (non-interactive)").option("-r, --repo", "Create a GitHub repository for the squad").option("-o, --org <org>", "GitHub organization for --repo (default: detected from git remote)").addHelpText("after", `
@@ -2337,7 +3267,7 @@ Examples:
   return createCommand(name, options);
 });
 program.command("create <name>", { hidden: true }).description("[renamed]").action(removedCommand("create", "Renamed to: squads add <name>"));
-program.command("run [target]").description("Run a squad, agent, or autopilot (no target = autopilot mode)").option("-v, --verbose", "Verbose output").option("-d, --dry-run", "Show what would be run without executing").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("-b, --background", "Run agent in background (detached process)").option("-w, --watch", "Run in background but tail the log for visibility").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)").option("--provider <provider>", "LLM provider: anthropic, google, openai, mistral, xai, aider, ollama").option("--model <model>", "Model to use (e.g., opus, sonnet, haiku, gemini-2.5-flash, gpt-4o)").option("--trigger <type>", "Trigger source: manual, scheduled, event, smart (default: manual)").option("--cloud", "Dispatch execution to cloud worker via API (requires squads login)").option("--task <directive>", "Founder directive for conversation mode (replaces lead briefing)").option("--max-turns <n>", "Max conversation turns (default: 20)", "20").option("--cost-ceiling <usd>", "Cost ceiling in USD (default: 25)", "25").option("--no-verify", "Skip post-execution verification (Ralph loop)").option("--execute", "Explicitly execute agents (default for run <target>)").option("-j, --json", "Output as JSON").option("-i, --interval <minutes>", "Autopilot: minutes between cycles", "30").option("--max-parallel <count>", "Autopilot: max parallel squad loops", "2").option("--budget <usd>", "Autopilot: daily budget cap ($)", "0").option("--once", "Autopilot: run one cycle then exit").option("--phased", "Autopilot: use dependency-based phase ordering (from SQUAD.md depends_on)").option("--no-eval", "Skip post-run COO evaluation").addHelpText("after", `
+program.command("run [target]").description("Run a squad, agent, or autopilot (no target = autopilot mode)").option("-v, --verbose", "Verbose output").option("-d, --dry-run", "Show what would be run without executing").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("-b, --background", "Run agent in background (detached process)").option("-w, --watch", "Run in background but tail the log for visibility").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)").option("--provider <provider>", "LLM provider: anthropic, google, openai, mistral, xai, aider, ollama").option("--model <model>", "Model to use (e.g., opus, sonnet, haiku, gemini-2.5-flash, gpt-4o)").option("--trigger <type>", "Trigger source: manual, scheduled, event, smart (default: manual)").option("--cloud", "Dispatch execution to cloud worker via API (requires squads login)").option("--task <directive>", "Founder directive for conversation mode (replaces lead briefing)").option("--max-turns <n>", "Max conversation turns (default: 20)", "20").option("--cost-ceiling <usd>", "Cost ceiling in USD (default: 25)", "25").option("--no-verify", "Skip post-execution verification (Ralph loop)").option("--execute", "Explicitly execute agents (default for run <target>)").option("-j, --json", "Output as JSON").option("-i, --interval <minutes>", "Autopilot: minutes between cycles", "30").option("--max-parallel <count>", "Autopilot: max parallel squad loops", "2").option("--budget <usd>", "Autopilot: daily budget cap ($)", "0").option("--once", "Autopilot: run one cycle then exit").option("--phased", "Autopilot: use dependency-based phase ordering (from SQUAD.md depends_on)").option("--no-eval", "Skip post-run COO evaluation").option("--org", "Run all squads as a coordinated org cycle (scan \u2192 plan \u2192 execute \u2192 report)").addHelpText("after", `
 Examples:
   $ squads run engineering              Run squad conversation (lead \u2192 scan \u2192 work \u2192 review)
   $ squads run engineering --task "fix CI"  Conversation with founder directive
@@ -2354,37 +3284,40 @@ Examples:
   $ squads run --once --dry-run         Preview one autopilot cycle
   $ squads run -i 15 --budget 50       Autopilot: 15min cycles, $50/day cap
 `).action(async (target, options) => {
-  const { runCommand } = await import("./run-I6KAXU6U.js");
+  const { runCommand } = await import("./run-DOY5SGF3.js");
   return runCommand(target || null, { ...options, timeout: parseInt(options.timeout, 10) });
 });
-program.command("list", { hidden: true }).description("[removed]").action(removedCommand("list", "Use: squads status"));
+program.command("list").description("List squads (alias for: squads status)").action(async () => {
+  const { statusCommand } = await import("./status-PFFB2NV6.js");
+  return statusCommand();
+});
 registerOrchestrateCommand(program);
 var env = program.command("env").description("View squad execution environment (MCP, skills, model, budget)").action(() => {
   env.outputHelp();
 });
 env.command("show <squad>").description("Show execution environment for a squad").option("--json", "Output as JSON").action(async (squad, options) => {
-  const { contextShowCommand } = await import("./context-GWPF4SEY.js");
+  const { contextShowCommand } = await import("./context-PYTO2UQG.js");
   return contextShowCommand(squad, options);
 });
 env.command("prompt <squad>").description("Output ready-to-use prompt for Claude Code execution").option("-a, --agent <agent>", "Agent to execute (required)").option("--json", "Output as JSON").action(async (squad, options) => {
-  const { contextPromptCommand } = await import("./context-GWPF4SEY.js");
+  const { contextPromptCommand } = await import("./context-PYTO2UQG.js");
   return contextPromptCommand(squad, options);
 });
-var exec = program.command("exec").description("View execution history and statistics");
-exec.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(async (options) => {
-  const { execListCommand } = await import("./exec-OUXM7JBF.js");
+var exec3 = program.command("exec").description("View execution history and statistics");
+exec3.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(async (options) => {
+  const { execListCommand } = await import("./exec-DYLI4TXY.js");
   return execListCommand({ ...options, limit: parseInt(options.limit, 10) });
 });
-exec.command("show <id>").description("Show execution details").option("--json", "Output as JSON").action(async (id, options) => {
-  const { execShowCommand } = await import("./exec-OUXM7JBF.js");
+exec3.command("show <id>").description("Show execution details").option("--json", "Output as JSON").action(async (id, options) => {
+  const { execShowCommand } = await import("./exec-DYLI4TXY.js");
   return execShowCommand(id, options);
 });
-exec.command("stats").description("Show execution statistics").option("-s, --squad <squad>", "Filter by squad").option("--json", "Output as JSON").action(async (options) => {
-  const { execStatsCommand } = await import("./exec-OUXM7JBF.js");
+exec3.command("stats").description("Show execution statistics").option("-s, --squad <squad>", "Filter by squad").option("--json", "Output as JSON").action(async (options) => {
+  const { execStatsCommand } = await import("./exec-DYLI4TXY.js");
   return execStatsCommand(options);
 });
-exec.action(async (options) => {
-  const { execListCommand } = await import("./exec-OUXM7JBF.js");
+exec3.action(async (options) => {
+  const { execListCommand } = await import("./exec-DYLI4TXY.js");
   return execListCommand(options);
 });
 program.command("dashboard [name]").alias("dash").description('Show dashboards. Use "squads dash" for overview, "squads dash <name>" for specific dashboard, "squads dash --list" to see all.').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)").option("-l, --list", "List available declarative dashboards").option("--view <view>", "Render specific view from dashboard").option("-j, --json", "Output as JSON").action(async (name, options) => {
@@ -2403,58 +3336,58 @@ program.command("dashboard [name]").alias("dash").description('Show dashboards.
     writeLine(`  Dashboard "${name}" not found. Showing default dashboard.
 `);
   }
-  const { dashboardCommand } = await import("./dashboard-LGT2B2BL.js");
+  const { dashboardCommand } = await import("./dashboard-HQIEHTZC.js");
   dashboardCommand({ ...options, fast: !options.full });
 });
 program.command("status [squad]").description("Show squad status and state").option("-v, --verbose", "Show detailed status").option("-j, --json", "Output as JSON").action(async (squad, options) => {
-  const { statusCommand } = await import("./status-AQNLDZVN.js");
+  const { statusCommand } = await import("./status-PFFB2NV6.js");
   return statusCommand(squad, options);
 });
 program.command("context").alias("feed").description("Get business context for alignment: goals, memory, costs, activity").option("-s, --squad <squad>", "Focus on specific squad").option("-t, --topic <topic>", "Search memory for relevant context").option("-a, --agent", "Output JSON for agent consumption").option("-j, --json", "Output as JSON (alias for --agent)").option("-v, --verbose", "Show additional details").action(async (options) => {
-  const { contextFeedCommand } = await import("./context-feed-AJGVAR6H.js");
+  const { contextFeedCommand } = await import("./context-feed-TLVZZ24S.js");
   return contextFeedCommand(options);
 });
 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(async (options) => {
-  const { costCommand } = await import("./cost-XBCDJ7XC.js");
+  const { costCommand } = await import("./cost-OALPURUQ.js");
   return costCommand(options);
 });
 program.command("budget").description("Check budget status for a squad").argument("<squad>", "Squad to check").option("--json", "Output as JSON").action(async (squad, options) => {
-  const { budgetCheckCommand } = await import("./cost-XBCDJ7XC.js");
+  const { budgetCheckCommand } = await import("./cost-OALPURUQ.js");
   return budgetCheckCommand(squad, options);
 });
 program.command("health").description("Quick health check for all infrastructure services").option("-v, --verbose", "Show optional services").action(async (options) => {
-  const { healthCommand } = await import("./health-4UXN44PF.js");
+  const { healthCommand } = await import("./health-ZF3HSA4W.js");
   return healthCommand(options);
 });
 program.command("doctor").description("Check local tools, auth, and project readiness").option("-v, --verbose", "Show install hints and optional tools").action(async (options) => {
-  const { doctorCommand } = await import("./doctor-XPUIIBHJ.js");
+  const { doctorCommand } = await import("./doctor-TWHMR23W.js");
   return doctorCommand(options);
 });
 program.command("history").description("Show recent agent execution history").option("-d, --days <days>", "Days to look back", "7").option("-s, --squad <squad>", "Filter by squad").option("-v, --verbose", "Show cost and token details").option("-j, --json", "Output as JSON").action(async (options) => {
-  const { historyCommand } = await import("./history-ILH3SWHB.js");
+  const { historyCommand } = await import("./history-WP6R5BNG.js");
   return historyCommand(options);
 });
 program.command("results [squad]").description("Show squad results: git activity + KPI goals vs actuals").option("-d, --days <days>", "Days to look back", "7").option("-v, --verbose", "Show detailed KPIs per goal").action(async (squad, options) => {
-  const { resultsCommand } = await import("./results-UECWGLTB.js");
+  const { resultsCommand } = await import("./results-6TH33HPN.js");
   return resultsCommand({ ...options, squad });
 });
 var goal = program.command("goal").description("Manage squad goals").action(() => {
   goal.outputHelp();
 });
 goal.command("set <squad> <description>").description("Set a goal for a squad").option("-m, --metric <metrics...>", "Metrics to track").action(async (squad, description, options) => {
-  const { goalSetCommand } = await import("./goal-BVHV5573.js");
+  const { goalSetCommand } = await import("./goal-XUNV3CKV.js");
   return goalSetCommand(squad, description, options);
 });
 goal.command("list [squad]").description("List goals for squad(s)").option("-a, --all", "Show completed goals too").option("-j, --json", "Output as JSON").action(async (squad, options) => {
-  const { goalListCommand } = await import("./goal-BVHV5573.js");
+  const { goalListCommand } = await import("./goal-XUNV3CKV.js");
   return goalListCommand(squad, options);
 });
 goal.command("complete <squad> <index>").description("Mark a goal as completed").action(async (squad, index) => {
-  const { goalCompleteCommand } = await import("./goal-BVHV5573.js");
+  const { goalCompleteCommand } = await import("./goal-XUNV3CKV.js");
   return goalCompleteCommand(squad, index);
 });
 goal.command("progress <squad> <index> <progress>").description("Update goal progress").action(async (squad, index, progress2) => {
-  const { goalProgressCommand } = await import("./goal-BVHV5573.js");
+  const { goalProgressCommand } = await import("./goal-XUNV3CKV.js");
   return goalProgressCommand(squad, index, progress2);
 });
 var kpi = program.command("kpi").description("Track and analyze squad KPIs (defined in SQUAD.md frontmatter)").addHelpText("after", `
@@ -2468,60 +3401,60 @@ Examples:
   kpi.outputHelp();
 });
 kpi.command("list").description("List all KPIs across squads").option("-j, --json", "Output as JSON").action(async (options) => {
-  const { kpiListCommand } = await import("./kpi-RQIU7WGK.js");
+  const { kpiListCommand } = await import("./kpi-VBGDO4GI.js");
   return kpiListCommand(options);
 });
 kpi.command("show <squad>").description("Show KPI status for a squad").option("-j, --json", "Output as JSON").action(async (squad, options) => {
-  const { kpiShowCommand } = await import("./kpi-RQIU7WGK.js");
+  const { kpiShowCommand } = await import("./kpi-VBGDO4GI.js");
   return kpiShowCommand(squad, options);
 });
 kpi.command("record <squad> <kpi> <value>").description("Record a KPI value").option("-n, --note <note>", "Add a note to the record").option("-j, --json", "Output as JSON").action(async (squad, kpi2, value, options) => {
-  const { kpiRecordCommand } = await import("./kpi-RQIU7WGK.js");
+  const { kpiRecordCommand } = await import("./kpi-VBGDO4GI.js");
   return kpiRecordCommand(squad, kpi2, value, options);
 });
 kpi.command("trend <squad> <kpi>").description("Show KPI trend over time").option("-p, --periods <n>", "Number of periods to show", "7").option("-j, --json", "Output as JSON").action(async (squad, kpi2, options) => {
-  const { kpiTrendCommand } = await import("./kpi-RQIU7WGK.js");
+  const { kpiTrendCommand } = await import("./kpi-VBGDO4GI.js");
   return kpiTrendCommand(squad, kpi2, options);
 });
 kpi.command("insights [squad]").description("Generate insights from KPI data").option("-j, --json", "Output as JSON").action(async (squad, options) => {
-  const { kpiInsightsCommand } = await import("./kpi-RQIU7WGK.js");
+  const { kpiInsightsCommand } = await import("./kpi-VBGDO4GI.js");
   return kpiInsightsCommand(squad, options);
 });
 var progress = program.command("progress").description("Track active and completed agent tasks").option("-v, --verbose", "Show more activity").action(async (options) => {
-  const { progressCommand } = await import("./progress-DAUZMT3N.js");
+  const { progressCommand } = await import("./progress-P2EIZBKP.js");
   return progressCommand(options);
 });
 progress.command("start <squad> <description>").description("Register a new active task").action(async (squad, description) => {
-  const { progressStartCommand } = await import("./progress-DAUZMT3N.js");
+  const { progressStartCommand } = await import("./progress-P2EIZBKP.js");
   return progressStartCommand(squad, description);
 });
 progress.command("complete <taskId>").description("Mark a task as completed").option("-f, --failed", "Mark as failed instead").action(async (taskId, options) => {
-  const { progressCompleteCommand } = await import("./progress-DAUZMT3N.js");
+  const { progressCompleteCommand } = await import("./progress-P2EIZBKP.js");
   return progressCompleteCommand(taskId, options);
 });
 var feedback = program.command("feedback").description("Record and view execution feedback").action(() => {
   feedback.outputHelp();
 });
 feedback.command("add <squad> <rating> <feedback>").description("Add feedback for last execution (rating 1-5)").option("-l, --learning <learnings...>", "Learnings to extract").action(async (squad, rating, feedbackText, options) => {
-  const { feedbackAddCommand } = await import("./feedback-KNAOG5QK.js");
+  const { feedbackAddCommand } = await import("./feedback-5AEACUX6.js");
   return feedbackAddCommand(squad, rating, feedbackText, options);
 });
 feedback.command("show <squad>").description("Show feedback history").option("-n, --limit <n>", "Number of entries to show", "5").action(async (squad, options) => {
-  const { feedbackShowCommand } = await import("./feedback-KNAOG5QK.js");
+  const { feedbackShowCommand } = await import("./feedback-5AEACUX6.js");
   return feedbackShowCommand(squad, options);
 });
 feedback.command("stats").description("Show feedback summary across all squads").action(async () => {
-  const { feedbackStatsCommand } = await import("./feedback-KNAOG5QK.js");
+  const { feedbackStatsCommand } = await import("./feedback-5AEACUX6.js");
   return feedbackStatsCommand();
 });
 program.command("autonomy").description("Show autonomy score and confidence metrics").option("-s, --squad <squad>", "Filter by squad").option("-p, --period <period>", "Time period: today, week, month", "today").option("-j, --json", "Output as JSON").action(async (options) => {
-  const { autonomyCommand } = await import("./autonomy-PSVZVX7A.js");
+  const { autonomyCommand } = await import("./autonomy-GARI6J2J.js");
   return autonomyCommand({ squad: options.squad, period: options.period, json: options.json });
 });
 program.command("autopilot").alias("daemon").description('[deprecated] Use "squads run" instead \u2014 autopilot mode when no target given').option("-i, --interval <minutes>", "Minutes between cycles", "30").option("-p, --parallel <count>", "Max parallel agent runs", "2").option("-b, --budget <dollars>", "Max daily spend in dollars (0 = unlimited/subscription)", "0").option("--once", "Run one cycle and exit").option("--dry-run", "Show what would run without dispatching").option("-v, --verbose", "Show detailed scoring").action(async (options) => {
   const colors3 = colors;
   writeLine(`  ${colors3.yellow}Note: "squads autopilot" is now "squads run" (no arguments)${RESET}`);
-  const { runCommand } = await import("./run-I6KAXU6U.js");
+  const { runCommand } = await import("./run-DOY5SGF3.js");
   return runCommand(null, { interval: parseInt(options.interval || "30", 10), ...options });
 });
 program.command("stats [squad]").description("Show agent outcome scorecards: merge rate, waste, cost per outcome").option("-p, --period <period>", "Time period: 7d or 30d", "7d").option("-j, --json", "Output as JSON").action(async (squad, options) => {
@@ -2539,27 +3472,27 @@ Examples:
   memory.outputHelp();
 });
 memory.command("query <query>").description("Search across all squad memory").option("-s, --squad <squad>", "Limit search to specific squad").option("-a, --agent <agent>", "Limit search to specific agent").action(async (query, options) => {
-  const { memoryQueryCommand } = await import("./memory-T3ACCS7E.js");
+  const { memoryQueryCommand } = await import("./memory-33HYD6AN.js");
   return memoryQueryCommand(query, options);
 });
 memory.command("read <squad>").alias("show").description("Show memory for a squad").action(async (squad, options) => {
-  const { memoryShowCommand } = await import("./memory-T3ACCS7E.js");
+  const { memoryShowCommand } = await import("./memory-33HYD6AN.js");
   return memoryShowCommand(squad, options);
 });
 memory.command("write <squad> <content>").alias("update").description("Add to squad memory").option("-a, --agent <agent>", "Specific agent (default: squad-lead)").option("-t, --type <type>", "Memory type: state, learnings, feedback", "learnings").action(async (squad, content, options) => {
-  const { memoryUpdateCommand } = await import("./memory-T3ACCS7E.js");
+  const { memoryUpdateCommand } = await import("./memory-33HYD6AN.js");
   return memoryUpdateCommand(squad, content, options);
 });
 memory.command("list").description("List all memory entries").action(async () => {
-  const { memoryListCommand } = await import("./memory-T3ACCS7E.js");
+  const { memoryListCommand } = await import("./memory-33HYD6AN.js");
   return memoryListCommand();
 });
 memory.command("sync").description("Sync memory from git: pull remote changes, process commits, optionally push to Postgres").option("-v, --verbose", "Show detailed commit info").option("-p, --push", "Push local memory changes to remote after sync").option("--no-pull", "Skip pulling from remote").option("--postgres", "Sync cycle data (goals, feedback, KPIs, learnings) to Postgres").option("--dimensions", "Sync squad/agent definitions to Postgres dim tables").option("--learnings", "Sync learnings.md files to Postgres").option("--auto-learn", "Auto-generate learnings from session commits").action(async (options) => {
-  const { syncCommand } = await import("./sync-ZI3MHA4G.js");
+  const { syncCommand } = await import("./sync-FR6LQJ4C.js");
   return syncCommand({ verbose: options.verbose, push: options.push, pull: options.pull, postgres: options.postgres, dimensions: options.dimensions, learnings: options.learnings, autoLearn: options.autoLearn });
 });
 memory.command("search <query>").description("Search stored conversations (requires authentication: squads login)").option("-l, --limit <limit>", "Number of results", "10").option("-r, --role <role>", "Filter by role: user, assistant, thinking").option("-i, --importance <importance>", "Filter by importance: low, normal, high").action(async (query, opts) => {
-  const { memorySearchCommand } = await import("./memory-T3ACCS7E.js");
+  const { memorySearchCommand } = await import("./memory-33HYD6AN.js");
   return memorySearchCommand(query, {
     limit: parseInt(opts.limit, 10),
     role: opts.role,
@@ -2567,7 +3500,7 @@ memory.command("search <query>").description("Search stored conversations (requi
   });
 });
 memory.command("extract").description("Extract memories from recent conversations into Engram").option("-s, --session <session>", "Extract specific session only").option("-h, --hours <hours>", "Look back period in hours", "24").option("-d, --dry-run", "Preview without sending to Engram").action(async (opts) => {
-  const { memoryExtractCommand } = await import("./memory-T3ACCS7E.js");
+  const { memoryExtractCommand } = await import("./memory-33HYD6AN.js");
   return memoryExtractCommand({
     session: opts.session,
     hours: parseInt(opts.hours, 10),
@@ -2575,20 +3508,20 @@ memory.command("extract").description("Extract memories from recent conversation
   });
 });
 program.command("learn <insight>").description("Capture a learning for future sessions").option("-s, --squad <squad>", "Squad to associate learning with").option("-c, --category <category>", "Category: success, failure, pattern, tip").option("-t, --tags <tags>", "Comma-separated tags").option("--context <context>", "Additional context").action(async (insight, options) => {
-  const { learnCommand } = await import("./learn-OIFUVZAS.js");
+  const { learnCommand } = await import("./learn-C4B2PQ5J.js");
   return learnCommand(insight, options);
 });
 var learn = program.command("learnings").description("View and search learnings");
 learn.command("show <squad>").description("Show learnings for a squad").option("-n, --limit <n>", "Number to show", "10").option("-c, --category <category>", "Filter by category").option("--tag <tag>", "Filter by tag").action(async (squad, options) => {
-  const { learnShowCommand } = await import("./learn-OIFUVZAS.js");
+  const { learnShowCommand } = await import("./learn-C4B2PQ5J.js");
   return learnShowCommand(squad, options);
 });
 learn.command("search <query>").description("Search learnings across all squads").option("-n, --limit <n>", "Max results", "10").action(async (query, options) => {
-  const { learnSearchCommand } = await import("./learn-OIFUVZAS.js");
+  const { learnSearchCommand } = await import("./learn-C4B2PQ5J.js");
   return learnSearchCommand(query, options);
 });
 program.command("sync").description("Git memory synchronization (Postgres sync optional)").option("-v, --verbose", "Show detailed commit info").option("-p, --push", "Push local memory changes to remote after sync").option("--no-pull", "Skip pulling from remote").option("--postgres", "Sync cycle data to Postgres").action(async (options) => {
-  const { syncCommand } = await import("./sync-ZI3MHA4G.js");
+  const { syncCommand } = await import("./sync-FR6LQJ4C.js");
   return syncCommand({ verbose: options.verbose, push: options.push, pull: options.pull, postgres: options.postgres });
 });
 registerTriggerCommand(program);
@@ -2610,8 +3543,8 @@ sessions.command("summary").description("Show pretty session summary (auto-detec
   const { buildCurrentSessionSummary, sessionsSummaryCommand } = await import("./sessions-CK25VGPL.js");
   let data;
   if (options.file) {
-    const { readFileSync: readFileSync7 } = await import("fs");
-    data = JSON.parse(readFileSync7(options.file, "utf-8"));
+    const { readFileSync: readFileSync9 } = await import("fs");
+    data = JSON.parse(readFileSync9(options.file, "utf-8"));
   } else if (options.data) {
     data = JSON.parse(options.data);
   } else if (!process.stdin.isTTY) {
@@ -2650,22 +3583,27 @@ program.command("detect-squad").description("Detect current squad based on cwd (
   return detectSquadCommand();
 });
 program.command("login").description("Log in to Squads (Pro & Enterprise)").action(async () => {
-  const { loginCommand } = await import("./login-DXZANWZY.js");
+  const { loginCommand } = await import("./login-F6ITE7PR.js");
   return loginCommand();
 });
 program.command("logout").description("Log out from Squads").action(async () => {
-  const { logoutCommand } = await import("./login-DXZANWZY.js");
+  const { logoutCommand } = await import("./login-F6ITE7PR.js");
   return logoutCommand();
 });
 program.command("whoami").description("Show current logged in user").action(async () => {
-  const { whoamiCommand } = await import("./login-DXZANWZY.js");
+  const { whoamiCommand } = await import("./login-F6ITE7PR.js");
   return whoamiCommand();
 });
 registerEvalCommand(program);
 registerDeployCommand(program);
 registerCognitionCommand(program);
+registerCatalogCommands(program);
+registerReleaseCommands(program);
+registerObservabilityCommands(program);
+registerTierCommand(program);
+registerServicesCommands(program);
 program.command("providers").description("Show available LLM CLI providers (claude, gemini, codex, etc.)").option("-j, --json", "Output as JSON").action(async (options) => {
-  const { providersCommand } = await import("./providers-3P5D2XL5.js");
+  const { providersCommand } = await import("./providers-LE744DM6.js");
   return providersCommand(options);
 });
 program.command("update").description("Check for and install updates").option("-y, --yes", "Auto-confirm update without prompting").option("-c, --check", "Check for updates without installing").action(async (options) => {