@askexenow/exe-os 0.9.239 → 0.9.244

package/dist/chunk-HOGTZLVU.js

@@ -0,0 +1,244 @@
+import {
+  employeeSessionName,
+  ensureEmployee,
+  markAsReadByTaskFile,
+  notifyParentExe,
+  resolveExeSession,
+  sendIntercom
+} from "./chunk-F7JLZXHC.js";
+import {
+  getTransport
+} from "./chunk-MVW62NIZ.js";
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-HCBMPZDT.js";
+import {
+  getAgentRuntime
+} from "./chunk-XJUUWHVN.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
+import {
+  isCoordinatorName,
+  isMultiInstance,
+  shouldAutoInstance
+} from "./chunk-CEJO7244.js";
+
+// src/lib/tasks-notify.ts
+var VERIFY_DELAY_MS = 1e4;
+var ACK_PATTERNS = [
+  /New task assigned/,
+  /START WORKING NOW/,
+  /marked in_progress/,
+  /Reading.*\.md/
+];
+function resolveDispatchRuntime(agentId, override) {
+  if (override) return override;
+  try {
+    return getAgentRuntime(agentId).runtime ?? null;
+  } catch {
+    return null;
+  }
+}
+async function verifyDispatch(sessionName, delayMs = VERIFY_DELAY_MS) {
+  const transport = getTransport();
+  await new Promise((r) => setTimeout(r, delayMs));
+  if (!transport.isAlive(sessionName)) {
+    return "session_dead";
+  }
+  try {
+    const output = transport.capturePane(sessionName, 20);
+    const acked = ACK_PATTERNS.some((p) => p.test(output));
+    return acked ? "verified" : "sent_unverified";
+  } catch {
+    return "sent_unverified";
+  }
+}
+async function dispatchTaskToEmployee(input) {
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  const dispatchRuntime = resolveDispatchRuntime(input.assignedTo, input.spawnRuntime);
+  recordOrchestrationEventBestEffort({
+    eventType: "dispatch.attempted",
+    source: "tasks-notify.dispatchTaskToEmployee",
+    taskId: input.taskId ?? null,
+    agentId: input.assignedTo,
+    runtime: dispatchRuntime,
+    payload: { priority: input.priority, projectName: input.projectName }
+  });
+  let crossProject = false;
+  if (input.projectName) {
+    try {
+      const { assertSessionScope } = await import("./session-scope-VMIPAZU7.js");
+      const check = assertSessionScope("dispatch_task", input.projectName);
+      if (check.reason === "cross_session_denied") {
+        crossProject = true;
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          runtime: dispatchRuntime,
+          errorCode: "cross_session_denied",
+          payload: { projectName: input.projectName }
+        });
+        return { dispatched: "skipped", crossProject: true };
+      }
+    } catch {
+    }
+  }
+  try {
+    const transport = getTransport();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.failed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        runtime: dispatchRuntime,
+        errorCode: "no_exe_session"
+      });
+      return { dispatched: "session_missing" };
+    }
+    const multiInstance = isMultiInstance(input.assignedTo);
+    if (multiInstance) {
+      const projectDir = input.projectDir ?? process.cwd();
+      const autoOpts = shouldAutoInstance(input.assignedTo);
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        ...autoOpts,
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "multi_instance", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      const dispatched = result.status === "intercom_sent" || result.status === "intercom_unprocessed" ? "sent_unverified" : "spawned";
+      process.stderr.write(
+        `[dispatch-audit] ${dispatched === "spawned" ? "SPAWNED" : "INTERCOM"} \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "multi_instance", priority: input.priority }
+      });
+      return { dispatched, session: result.sessionName, crossProject };
+    }
+    const sessionName = employeeSessionName(input.assignedTo, exeSession);
+    if (transport.isAlive(sessionName)) {
+      const result = sendIntercom(sessionName, { force: true });
+      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: sessionName,
+        runtime: dispatchRuntime,
+        result: dispatched,
+        payload: { path: "single_instance_intercom", priority: input.priority }
+      });
+      return { dispatched, session: sessionName, crossProject };
+    } else {
+      const projectDir = input.projectDir ?? process.cwd();
+      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+        runtimeOverride: input.spawnRuntime,
+        modelOverride: input.spawnModel
+      });
+      if (result.status === "failed") {
+        process.stderr.write(
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+`
+        );
+        recordOrchestrationEventBestEffort({
+          eventType: "dispatch.failed",
+          source: "tasks-notify.dispatchTaskToEmployee",
+          taskId: input.taskId ?? null,
+          agentId: input.assignedTo,
+          sessionScope: exeSession,
+          runtime: dispatchRuntime,
+          errorCode: "spawn_failed",
+          payload: { path: "single_instance_spawn", error: result.error }
+        });
+        return { dispatched: "session_missing" };
+      }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
+      recordOrchestrationEventBestEffort({
+        eventType: "dispatch.completed",
+        source: "tasks-notify.dispatchTaskToEmployee",
+        taskId: input.taskId ?? null,
+        agentId: input.assignedTo,
+        sessionScope: exeSession,
+        tmuxSession: result.sessionName,
+        runtime: dispatchRuntime,
+        result: "spawned",
+        payload: { path: "single_instance_spawn", priority: input.priority }
+      });
+      return { dispatched: "spawned", session: result.sessionName, crossProject };
+    }
+  } catch {
+    recordOrchestrationEventBestEffort({
+      eventType: "dispatch.failed",
+      source: "tasks-notify.dispatchTaskToEmployee",
+      taskId: input.taskId ?? null,
+      agentId: input.assignedTo,
+      runtime: dispatchRuntime,
+      errorCode: "exception"
+    });
+    return { dispatched: "session_missing" };
+  }
+}
+function notifyTaskDone() {
+  try {
+    const key = getSessionKey();
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
+  } catch {
+  }
+}
+async function markTaskNotificationsRead(taskFile) {
+  try {
+    await markAsReadByTaskFile(taskFile);
+  } catch {
+  }
+}
+
+export {
+  verifyDispatch,
+  dispatchTaskToEmployee,
+  notifyTaskDone,
+  markTaskNotificationsRead
+};

package/dist/{chunk-IQSCZDBQ.js → chunk-I5PIBL56.js}

@@ -3,15 +3,15 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-2H55BIV2.js";
+} from "./chunk-CEJO7244.js";
 import {
   PLAN_LIMITS,
   checkLicense,
   isFeatureAllowed
-} from "./chunk-D5C56WO3.js";
+} from "./chunk-MOZ2YQ54.js";
 import {
   EXE_AI_DIR
-} from "./chunk-TRZ5KA2R.js";
+} from "./chunk-VXIMSRTO.js";
 
 // src/lib/plan-limits.ts
 import { readFileSync, existsSync } from "fs";

package/dist/chunk-IRHNV4GY.js

@@ -0,0 +1,388 @@
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/verify-stack.ts
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import http from "http";
+import path from "path";
+var DEFAULT_COMPOSE = "/opt/exe-stack/docker-compose.yml";
+var DEFAULT_ENV = "/opt/exe-stack/.env";
+var CHECK_TIMEOUT_MS = 5e3;
+var TOTAL_TIMEOUT_MS = 6e4;
+var SERVICE_URLS = {
+  "exe-os": "http://127.0.0.1:8765/health",
+  "exe-gateway": "http://127.0.0.1:3100/health",
+  "exe-wiki": "http://127.0.0.1:3001/api/ping",
+  "exe-crm": "http://127.0.0.1:3000/healthz",
+  "exe-monitor-hub": "http://127.0.0.1:8090/api/health"
+};
+var FRONTEND_URLS = {
+  "exe-crm": "http://127.0.0.1:3000",
+  "exe-wiki": "http://127.0.0.1:3001",
+  "exe-monitor-hub": "http://127.0.0.1:8090"
+};
+var GOTRUE_TOKEN_URL = "http://127.0.0.1:9999/token?grant_type=password";
+function loadEnvFile(envPath) {
+  if (!existsSync(envPath)) return {};
+  const raw = readFileSync(envPath, "utf8");
+  const vars = {};
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx < 1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let val = trimmed.slice(eqIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    vars[key] = val;
+  }
+  return vars;
+}
+function httpGet(url, timeoutMs, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const opts = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 80,
+      path: urlObj.pathname + urlObj.search,
+      method: "GET",
+      timeout: timeoutMs,
+      headers: headers ?? {}
+    };
+    const req = http.request(opts, (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      res.on("end", () => resolve({ status: res.statusCode ?? 0, body, contentType: res.headers["content-type"] ?? "" }));
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`Timeout after ${timeoutMs}ms`));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+function httpPost(url, body, contentType, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const opts = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 80,
+      path: urlObj.pathname + urlObj.search,
+      method: "POST",
+      timeout: timeoutMs,
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": Buffer.byteLength(body)
+      }
+    };
+    const req = http.request(opts, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => resolve({ status: res.statusCode ?? 0, body: data }));
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`Timeout after ${timeoutMs}ms`));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+async function checkContainersHealthy(composeFile) {
+  const check = "All containers healthy";
+  try {
+    const dir = path.dirname(composeFile);
+    const file = path.basename(composeFile);
+    const raw = execSync(`docker compose -f "${file}" ps --format json`, {
+      cwd: dir,
+      timeout: CHECK_TIMEOUT_MS,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const lines = raw.trim().split("\n").filter(Boolean);
+    if (lines.length === 0) {
+      return { check, status: "fail", message: "No containers found" };
+    }
+    const unhealthy = [];
+    const notRunning = [];
+    for (const line of lines) {
+      try {
+        const c = JSON.parse(line);
+        const name = c.Name || c.name || "unknown";
+        const state = (c.State || c.state || "").toLowerCase();
+        const health = (c.Health || c.health || "").toLowerCase();
+        if (state !== "running") notRunning.push(name);
+        else if (health && health !== "healthy") unhealthy.push(name);
+      } catch {
+      }
+    }
+    if (notRunning.length > 0) {
+      return { check, status: "fail", message: `Not running: ${notRunning.join(", ")}` };
+    }
+    if (unhealthy.length > 0) {
+      return { check, status: "warn", message: `Unhealthy: ${unhealthy.join(", ")}` };
+    }
+    return { check, status: "pass", message: `${lines.length} containers running and healthy` };
+  } catch (err) {
+    return { check, status: "fail", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function checkServiceUrls() {
+  const check = "All service URLs respond 200";
+  const failures = [];
+  for (const [service, url] of Object.entries(SERVICE_URLS)) {
+    try {
+      const res = await httpGet(url, CHECK_TIMEOUT_MS);
+      if (res.status !== 200) {
+        failures.push(`${service}: HTTP ${res.status}`);
+      }
+    } catch (err) {
+      failures.push(`${service}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (failures.length > 0) {
+    return { check, status: "fail", message: failures.join("; ") };
+  }
+  return { check, status: "pass", message: `${Object.keys(SERVICE_URLS).length} services responding` };
+}
+async function checkGoTrueLogin(env) {
+  const check = "GoTrue login works";
+  const email = env.GOTRUE_TEST_EMAIL || process.env.GOTRUE_TEST_EMAIL;
+  const password = env.GOTRUE_TEST_PASSWORD || process.env.GOTRUE_TEST_PASSWORD;
+  if (!email || !password) {
+    return { result: { check, status: "skip", message: "GOTRUE_TEST_EMAIL / GOTRUE_TEST_PASSWORD not set" } };
+  }
+  try {
+    const body = JSON.stringify({ email, password });
+    const res = await httpPost(GOTRUE_TOKEN_URL, body, "application/json", CHECK_TIMEOUT_MS);
+    if (res.status !== 200) {
+      return { result: { check, status: "fail", message: `HTTP ${res.status}: ${res.body.slice(0, 200)}` } };
+    }
+    const parsed = JSON.parse(res.body);
+    const jwt = parsed.access_token;
+    if (!jwt) {
+      return { result: { check, status: "fail", message: "No access_token in response" } };
+    }
+    return { result: { check, status: "pass", message: "Login succeeded" }, jwt };
+  } catch (err) {
+    return { result: { check, status: "fail", message: err instanceof Error ? err.message : String(err) } };
+  }
+}
+async function checkWhatsAppConnected() {
+  const check = "WhatsApp still connected";
+  try {
+    const res = await httpGet(SERVICE_URLS["exe-gateway"], CHECK_TIMEOUT_MS);
+    if (res.status !== 200) {
+      return { check, status: "warn", message: `Gateway health returned HTTP ${res.status}` };
+    }
+    try {
+      const data = JSON.parse(res.body);
+      const adapters = data.adapters || data.channels;
+      if (!adapters || !Array.isArray(adapters)) {
+        return { check, status: "skip", message: "No adapters array in gateway health response" };
+      }
+      const connected = adapters.filter(
+        (a) => a.status === "connected" || a.connected === true
+      );
+      if (connected.length === 0) {
+        return { check, status: "warn", message: `0/${adapters.length} adapters connected` };
+      }
+      return { check, status: "pass", message: `${connected.length}/${adapters.length} adapter(s) connected` };
+    } catch {
+      return { check, status: "skip", message: "Could not parse gateway health response" };
+    }
+  } catch (err) {
+    return { check, status: "fail", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function checkFrontendsLoad() {
+  const check = "Each frontend loads";
+  const failures = [];
+  for (const [service, url] of Object.entries(FRONTEND_URLS)) {
+    try {
+      const res = await httpGet(url, CHECK_TIMEOUT_MS);
+      if (!res.contentType.includes("text/html")) {
+        failures.push(`${service}: Content-Type=${res.contentType} (expected text/html)`);
+      } else if (res.body.length < 1e3) {
+        failures.push(`${service}: body ${res.body.length} bytes (expected >1000)`);
+      }
+    } catch (err) {
+      failures.push(`${service}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (failures.length > 0) {
+    return { check, status: "fail", message: failures.join("; ") };
+  }
+  return { check, status: "pass", message: `${Object.keys(FRONTEND_URLS).length} frontends serving HTML` };
+}
+async function checkMonitorMetrics() {
+  const check = "Monitor reports metrics";
+  try {
+    const res = await httpGet(SERVICE_URLS["exe-monitor-hub"], CHECK_TIMEOUT_MS);
+    if (res.status !== 200) {
+      return { check, status: "fail", message: `HTTP ${res.status}` };
+    }
+    return { check, status: "pass", message: "Monitor hub health OK" };
+  } catch (err) {
+    return { check, status: "fail", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function checkRawPipeline(env) {
+  const check = "Raw pipeline alive";
+  const dbUrl = env.DATABASE_URL || env.EXED_DATABASE_URL || process.env.DATABASE_URL;
+  if (!dbUrl) {
+    return { check, status: "skip", message: "DATABASE_URL not set" };
+  }
+  try {
+    const result = execSync(
+      `psql "${dbUrl}" -t -c "SELECT COUNT(*) FROM raw.raw_events WHERE created_at > NOW() - INTERVAL '24 hours'" 2>&1`,
+      { timeout: CHECK_TIMEOUT_MS, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const count = parseInt(result.trim(), 10);
+    if (isNaN(count)) {
+      return { check, status: "warn", message: `Unexpected psql output: ${result.trim().slice(0, 100)}` };
+    }
+    if (count === 0) {
+      return { check, status: "warn", message: "0 events in last 24h \u2014 pipeline may be idle" };
+    }
+    return { check, status: "pass", message: `${count} event(s) in last 24h` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("does not exist") || msg.includes("relation")) {
+      return { check, status: "skip", message: "raw.raw_events table does not exist" };
+    }
+    return { check, status: "fail", message: msg.slice(0, 200) };
+  }
+}
+async function checkCrossServiceAuth(jwt) {
+  const check = "Cross-service auth";
+  if (!jwt) {
+    return { check, status: "skip", message: "No GoTrue JWT available (check 3 skipped or failed)" };
+  }
+  const targets = {
+    "exe-wiki": "http://127.0.0.1:3001/api/ping",
+    "exe-crm": "http://127.0.0.1:3000/healthz"
+  };
+  const failures = [];
+  for (const [service, url] of Object.entries(targets)) {
+    try {
+      const res = await httpGet(url, CHECK_TIMEOUT_MS, { Authorization: `Bearer ${jwt}` });
+      if (res.status !== 200) {
+        failures.push(`${service}: HTTP ${res.status}`);
+      }
+    } catch (err) {
+      failures.push(`${service}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (failures.length > 0) {
+    return { check, status: "fail", message: failures.join("; ") };
+  }
+  return { check, status: "pass", message: "JWT accepted by wiki + CRM" };
+}
+async function runVerifyStack(options) {
+  const composeFile = options?.composeFile ?? DEFAULT_COMPOSE;
+  const envFile = options?.envFile ?? DEFAULT_ENV;
+  const totalTimeout = options?.timeoutMs ?? TOTAL_TIMEOUT_MS;
+  const env = loadEnvFile(envFile);
+  const results = [];
+  const deadline = Date.now() + totalTimeout;
+  const addResult = (r) => {
+    results.push(r);
+    if (Date.now() > deadline) {
+      results.push({ check: "Total timeout", status: "fail", message: `Exceeded ${totalTimeout}ms` });
+    }
+  };
+  addResult(await checkContainersHealthy(composeFile));
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkServiceUrls());
+  if (Date.now() > deadline) return summarize(results);
+  const goTrueResult = await checkGoTrueLogin(env);
+  addResult(goTrueResult.result);
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkWhatsAppConnected());
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkFrontendsLoad());
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkMonitorMetrics());
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkRawPipeline(env));
+  if (Date.now() > deadline) return summarize(results);
+  addResult(await checkCrossServiceAuth(goTrueResult.jwt));
+  return summarize(results);
+}
+function summarize(results) {
+  return {
+    results,
+    passed: results.filter((r) => r.status === "pass").length,
+    failed: results.filter((r) => r.status === "fail").length,
+    warned: results.filter((r) => r.status === "warn").length,
+    skipped: results.filter((r) => r.status === "skip").length
+  };
+}
+function printReport(report) {
+  const icons = { pass: "\u2705", fail: "\u274C", warn: "\u26A0\uFE0F ", skip: "\u23ED\uFE0F " };
+  console.log("\n\x1B[1mPost-Deploy Verification\x1B[0m\n");
+  for (const r of report.results) {
+    console.log(`  ${icons[r.status] ?? "?"} ${r.check}: ${r.message}`);
+  }
+  console.log(
+    `
+  Pass: ${report.passed}  Fail: ${report.failed}  Warn: ${report.warned}  Skip: ${report.skipped}
+`
+  );
+}
+function printUsage() {
+  console.log(`
+Usage: exe-os verify-stack [options]
+
+Post-deploy verification \u2014 8 runtime checks after stack-update.
+
+Options:
+  --compose <path>   Path to docker-compose.yml (default: ${DEFAULT_COMPOSE})
+  --env <path>       Path to .env file (default: ${DEFAULT_ENV})
+  --help             Show this help message
+
+Checks:
+  1. All containers healthy (docker compose ps)
+  2. All service URLs respond 200
+  3. GoTrue login works (requires GOTRUE_TEST_EMAIL + GOTRUE_TEST_PASSWORD)
+  4. WhatsApp still connected (adapter status)
+  5. Each frontend loads (HTML > 1000 bytes)
+  6. Monitor reports metrics
+  7. Raw pipeline alive (recent raw_events)
+  8. Cross-service auth (JWT \u2192 wiki + CRM)
+`);
+}
+if (isMainModule(import.meta.url) && process.argv[1]?.includes("verify-stack")) {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    printUsage();
+    process.exit(0);
+  }
+  const composeIdx = args.indexOf("--compose");
+  const envIdx = args.indexOf("--env");
+  const options = {};
+  if (composeIdx >= 0 && args[composeIdx + 1]) options.composeFile = args[composeIdx + 1];
+  if (envIdx >= 0 && args[envIdx + 1]) options.envFile = args[envIdx + 1];
+  runVerifyStack(options).then((report) => {
+    printReport(report);
+    process.exit(report.failed > 0 ? 1 : 0);
+  }).catch((err) => {
+    console.error(`[verify-stack] Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+}
+
+export {
+  runVerifyStack
+};

package/dist/{chunk-4HROS3GJ.js → chunk-IZVKWBIP.js}

@@ -1,6 +1,6 @@
 import {
   redactSecrets
-} from "./chunk-F7LU65PQ.js";
+} from "./chunk-Y25OJWOQ.js";
 
 // src/lib/memory-write-governor.ts
 import { createHash } from "crypto";

package/dist/{chunk-DKI5BTBC.js → chunk-J7V7LPPX.js}

@@ -1,6 +1,6 @@
 import {
   sessionScopeFilter
-} from "./chunk-HNLPLLE6.js";
+} from "./chunk-F7JLZXHC.js";
 
 // src/lib/git-task-sweep.ts
 import { execSync } from "child_process";
@@ -178,7 +178,7 @@ async function sweepTasks(projectName, options = {}) {
     }
     if (!dryRun) {
       try {
-        const { updateTaskStatus } = await import("./tasks-crud-JXZEBZFR.js");
+        const { updateTaskStatus } = await import("./tasks-crud-DQOG2NPG.js");
         await updateTaskStatus({
           taskId: task.id,
           status: "needs_review",

package/dist/{chunk-TOZ5NN5V.js → chunk-JLKUVK5J.js}

@@ -1,6 +1,6 @@
 import {
   getGlobalProceduresBlock
-} from "./chunk-GN5VHPPR.js";
+} from "./chunk-NVZR7T4E.js";
 
 // src/lib/employee-templates.ts
 var BASE_OPERATING_PROCEDURES = `

package/dist/{chunk-4SC65UBG.js → chunk-JLNXKG3K.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployees
-} from "./chunk-2H55BIV2.js";
+} from "./chunk-CEJO7244.js";
 
 // src/lib/agent-symlinks.ts
 import os from "os";