mergen-server 1.4.0

package/dist/commands/team.js

@@ -0,0 +1,809 @@
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { log, success, error, hr, ask, VERSION } from "./shared.js";
+async function inviteCommand() {
+  let host = process.env.MERGEN_DASHBOARD_URL ?? "";
+  if (!host) {
+    let port = 3e3;
+    for (let p = 3e3; p <= 3010; p++) {
+      try {
+        const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(600) });
+        if (r.ok) {
+          port = p;
+          break;
+        }
+      } catch {
+      }
+    }
+    let lanIp = "127.0.0.1";
+    try {
+      const { networkInterfaces } = await import("os");
+      const ifaces = networkInterfaces();
+      for (const iface of Object.values(ifaces)) {
+        for (const addr of iface ?? []) {
+          if (!addr.internal && addr.family === "IPv4") {
+            lanIp = addr.address;
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    host = `http://${lanIp}:${port}`;
+  }
+  let secret = "";
+  try {
+    const { readFileSync: readFileSync2 } = await import("fs");
+    const { join: join2 } = await import("path");
+    const { homedir: homedir2 } = await import("os");
+    secret = readFileSync2(join2(homedir2(), ".mergen", "secret"), "utf8").trim();
+  } catch {
+  }
+  const inviteUrl = `${host}/setup?server=${encodeURIComponent(host)}&token=${encodeURIComponent(secret)}`;
+  hr();
+  console.log("\u2B21 Mergen Team Invite\n");
+  console.log("Share this URL with your teammate:");
+  console.log(`
+  ${inviteUrl}
+`);
+  console.log("When they open it, the setup wizard auto-fills the server endpoint and secret.");
+  console.log("\nOr they can run:");
+  console.log(`  npx mergen-server join "${inviteUrl}"`);
+  hr();
+  console.log(`
+Note: make sure your Mergen server is reachable from their machine.`);
+  console.log(`      If it's local-only, set MERGEN_BIND=0.0.0.0 and restart.`);
+}
+async function joinCommand(args) {
+  const url = args[1];
+  if (!url) {
+    error("Usage: mergen-server join <invite-url>");
+    process.exit(1);
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    error("Invalid URL: " + url);
+    process.exit(1);
+    return;
+  }
+  const server = parsed.searchParams.get("server") ?? "";
+  const token = parsed.searchParams.get("token") ?? "";
+  if (!server) {
+    error("Invite URL missing server parameter");
+    process.exit(1);
+  }
+  console.log("\u2B21 Joining Mergen team instance...\n");
+  log(`Server: ${server}`);
+  const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
+  const { join: join2 } = await import("path");
+  const { homedir: homedir2 } = await import("os");
+  const configDir = join2(homedir2(), ".mergen");
+  mkdirSync2(configDir, { recursive: true });
+  writeFileSync2(join2(configDir, "team-server"), server, "utf8");
+  if (token) writeFileSync2(join2(configDir, "team-secret"), token, { encoding: "utf8", mode: 384 });
+  success(`Team server saved to ~/.mergen/team-server`);
+  try {
+    const r = await fetch(`${server}/health`, { signal: AbortSignal.timeout(3e3) });
+    if (r.ok) {
+      success(`Server reachable at ${server}`);
+    } else {
+      error(`Server returned ${(await r.json()).status}`);
+    }
+  } catch {
+    error(`Could not reach ${server} \u2014 make sure MERGEN_BIND=0.0.0.0 is set on the server`);
+  }
+  log(`
+Open the dashboard: ${server}/dashboard`);
+}
+async function impactReportCommand(args) {
+  const htmlMode = args.includes("--html");
+  const slideMode = args.includes("--slide");
+  const baselineMode = args.includes("--baseline");
+  const compareMode = args.includes("--compare");
+  let port = 3e3;
+  let serverFound = false;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(800) });
+      if (r.ok) {
+        port = p;
+        serverFound = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!serverFound) {
+    error("Server not running. Start with: mergen-server start");
+    process.exit(1);
+  }
+  const secret = (() => {
+    try {
+      return readFileSync(join(homedir(), ".mergen", "secret"), "utf8").trim();
+    } catch {
+      return "";
+    }
+  })();
+  const headers = {};
+  if (secret) headers["x-mergen-secret"] = secret;
+  const BASE = `http://127.0.0.1:${port}`;
+  if (htmlMode) {
+    const res2 = await fetch(`${BASE}/impact-report?format=html`, { headers, signal: AbortSignal.timeout(1e4) });
+    if (!res2.ok) {
+      error(`Server returned ${res2.status}`);
+      process.exit(1);
+    }
+    const html = await res2.text();
+    const outFile = `./impact-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.html`;
+    writeFileSync(outFile, html, "utf8");
+    success(`HTML report written to ${outFile}`);
+    console.log(`  Open in browser or send to your CISO.
+`);
+    return;
+  }
+  if (slideMode || baselineMode || compareMode) {
+    const res2 = await fetch(`${BASE}/impact-report?format=slide`, { headers, signal: AbortSignal.timeout(1e4) });
+    if (!res2.ok) {
+      error(`Server returned ${res2.status}`);
+      process.exit(1);
+    }
+    const { slide: s } = await res2.json();
+    const baselinePath = join(homedir(), ".mergen", "baseline.json");
+    if (baselineMode) {
+      const { mkdirSync: mkdirSync2 } = await import("fs");
+      mkdirSync2(join(homedir(), ".mergen"), { recursive: true });
+      writeFileSync(baselinePath, JSON.stringify({ ...s, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n", "utf8");
+      success(`Baseline saved to ${baselinePath}`);
+      console.log("  Run again at Day 30 with --compare to see the delta.\n");
+      _printSlide(s);
+      return;
+    }
+    if (compareMode) {
+      let baseline = null;
+      try {
+        baseline = JSON.parse(readFileSync(baselinePath, "utf8"));
+      } catch {
+      }
+      if (!baseline) {
+        error("No baseline found. Run: mergen-server impact-report --baseline  on Day 1 first.");
+        process.exit(1);
+      }
+      _printSlideCompare(baseline, s);
+      return;
+    }
+    _printSlide(s);
+    return;
+  }
+  const res = await fetch(`${BASE}/impact-report`, { headers, signal: AbortSignal.timeout(1e4) });
+  if (!res.ok) {
+    error(`Server returned ${res.status}`);
+    process.exit(1);
+  }
+  const { report: d } = await res.json();
+  const W = 60;
+  const div = "\u2500".repeat(W);
+  const fmtMs = (ms) => {
+    if (ms == null) return "pending";
+    if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+    return `${Math.floor(ms / 6e4)}m ${Math.round(ms % 6e4 / 1e3)}s`;
+  };
+  console.log("\nMergen Day-30 Impact Report");
+  console.log(div);
+  console.log(`Incidents processed:     ${d["totalIncidents"]}  (last ${d["windowDays"]} days)`);
+  console.log(`Resolution rate:         ${d["wouldResolveRate"]}%  (${d["wouldResolveCount"]} would have resolved autonomously)`);
+  console.log(`MTTR delta:              ${fmtMs(d["avgAutonomousMttrMs"])} autonomous vs ${fmtMs(d["avgManualMttrMs"])} manual`);
+  console.log(`False positive rate:     ${d["falsePositiveRate"] != null ? `${Math.round(d["falsePositiveRate"] * 100)}%` : `pending (need ${Math.max(0, 5 - (d["humanReviewedCount"] ?? 0))} more human shadow reviews)`}`);
+  console.log(`Override corpus:         ${d["overridePatterns"]} patterns encoded, ${d["corpusBlockCount"]} triggered this window`);
+  const blunders = d["agentBlunderSummary"];
+  if (blunders) {
+    const chain = blunders.chainVerified ? "\u2713" : "!";
+    console.log(`Agent blunders blocked:  ${blunders.totalPrevented.toLocaleString()}  (chain ${chain})`);
+  }
+  console.log(`
+Full deck summary:`);
+  const summary = (d["deckSummary"] ?? "").match(/.{1,56}(\s|$)/g) ?? [];
+  for (const line of summary) console.log(`  ${line.trim()}`);
+  console.log(`
+Flags:`);
+  console.log(`  --slide      5 pre-agreed numbers, screenshot-ready`);
+  console.log(`  --baseline   save Day-1 numbers to compare at Day 30`);
+  console.log(`  --compare    show delta vs. saved baseline`);
+  console.log(`  --html       write full HTML report to disk`);
+  console.log(div + "\n");
+}
+function _printSlide(s) {
+  const W = 62;
+  const div = "\u2500".repeat(W);
+  const pad = (label, value) => {
+    const dots = ".".repeat(Math.max(2, W - label.length - value.length - 2));
+    return `  ${label} ${dots} ${value}`;
+  };
+  const pend = (v) => v == null ? "pending" : String(v);
+  const pct = (v) => v == null ? "pending" : `${v}%`;
+  console.log("\nMergen \u2014 Pre-agreed Day-30 metrics");
+  console.log(div);
+  console.log(pad("1. Incidents processed", `${s["incidents_processed"]}`));
+  console.log(pad("2. Autonomous resolution rate", pct(s["autonomous_resolution_rate_pct"])));
+  console.log(pad(
+    "3. MTTR: autonomous / manual",
+    `${pend(s["mttr_autonomous_minutes"])}min / ${pend(s["mttr_manual_minutes"])}min`
+  ));
+  console.log(pad("4. Gate false positive rate", pct(s["gate_false_positive_rate_pct"])));
+  console.log(pad("5. Agent blunders blocked", `${s["agent_blunders_blocked"]}`));
+  console.log(div);
+  console.log(`  Window: last ${s["windowDays"]} days  |  Generated: ${new Date(s["generatedAt"]).toLocaleDateString()}`);
+  console.log();
+}
+function _printSlideCompare(baseline, now) {
+  const W = 72;
+  const div = "\u2500".repeat(W);
+  const delta = (b, n, lowerIsBetter = false) => {
+    if (b == null || n == null) return "";
+    const diff = Number(n) - Number(b);
+    if (diff === 0) return "  (no change)";
+    const arrow = diff > 0 ? "+" : "";
+    const good = lowerIsBetter ? diff < 0 : diff > 0;
+    return `  ${arrow}${diff} ${good ? "(better)" : "(worse)"}`;
+  };
+  console.log("\nMergen \u2014 Day-1 vs Day-30 comparison");
+  console.log(div);
+  const row = (label, b, n, d) => console.log(`  ${label.padEnd(34)} ${String(b ?? "n/a").padStart(10)}  \u2192  ${String(n ?? "n/a").padEnd(10)}${d}`);
+  row("Incidents processed", baseline["incidents_processed"], now["incidents_processed"], delta(baseline["incidents_processed"], now["incidents_processed"]));
+  row("Autonomous resolution rate", `${baseline["autonomous_resolution_rate_pct"]}%`, `${now["autonomous_resolution_rate_pct"]}%`, delta(baseline["autonomous_resolution_rate_pct"], now["autonomous_resolution_rate_pct"]));
+  row("MTTR autonomous (min)", baseline["mttr_autonomous_minutes"], now["mttr_autonomous_minutes"], delta(baseline["mttr_autonomous_minutes"], now["mttr_autonomous_minutes"], true));
+  row("MTTR manual (min)", baseline["mttr_manual_minutes"], now["mttr_manual_minutes"], delta(baseline["mttr_manual_minutes"], now["mttr_manual_minutes"], true));
+  row("Gate FP rate", `${baseline["gate_false_positive_rate_pct"]}%`, `${now["gate_false_positive_rate_pct"]}%`, delta(baseline["gate_false_positive_rate_pct"], now["gate_false_positive_rate_pct"], true));
+  row("Agent blunders blocked", baseline["agent_blunders_blocked"], now["agent_blunders_blocked"], delta(baseline["agent_blunders_blocked"], now["agent_blunders_blocked"]));
+  console.log(div);
+  console.log(`  Baseline saved: ${baseline["savedAt"]}`);
+  console.log();
+}
+async function exportCommand(args) {
+  const label = args[1] ?? `session-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}`;
+  const outJson = `./${label}.mergen-report.json`;
+  const outHtml = `./${label}.mergen-report.html`;
+  console.log("\u{1F4E6} Mergen Export\n");
+  hr();
+  let port = 3e3;
+  let serverFound = false;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(800) });
+      if (r.ok) {
+        port = p;
+        serverFound = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!serverFound) {
+    error("Server not running. Start with: mergen-server start");
+    process.exit(1);
+  }
+  log(`Fetching session data from :${port}...`);
+  const BASE = `http://127.0.0.1:${port}`;
+  async function safeFetch(path2) {
+    try {
+      const r = await fetch(`${BASE}${path2}`, { signal: AbortSignal.timeout(3e3) });
+      return r.ok ? await r.json() : null;
+    } catch {
+      return null;
+    }
+  }
+  const [health, lastPack, history, timeline, calibration] = await Promise.all([
+    safeFetch("/health"),
+    safeFetch("/last-pack"),
+    safeFetch("/history?limit=20"),
+    safeFetch("/timeline?seconds=3600&limit=500"),
+    safeFetch("/calibration")
+  ]);
+  const report = {
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    label,
+    server: { port, health },
+    diagnoses: history?.entries ?? [],
+    latest_analysis: lastPack,
+    timeline: timeline?.rows ?? [],
+    calibration
+  };
+  writeFileSync(outJson, JSON.stringify(report, null, 2), "utf8");
+  success(`JSON report: ${outJson}`);
+  const rows = timeline?.rows ?? [];
+  const html = `<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8"><title>Mergen Report \u2014 ${label}</title>
+<style>
+body{font-family:system-ui,sans-serif;max-width:900px;margin:40px auto;padding:0 20px;color:#222}
+h1{font-size:20px;margin-bottom:4px}
+.meta{color:#888;font-size:13px;margin-bottom:24px}
+table{width:100%;border-collapse:collapse;font-size:13px}
+th{text-align:left;padding:6px 10px;background:#f5f5f5;border-bottom:2px solid #ddd}
+td{padding:5px 10px;border-bottom:1px solid #eee}
+.error{color:#d32}
+.warn{color:#b80}
+.request{color:#07a}
+.context{color:#888}
+</style></head><body>
+<h1>Mergen Session Report</h1>
+<div class="meta">Exported ${report.exported_at} \xB7 ${rows.length} events</div>
+<table>
+<thead><tr><th>Time</th><th>Type</th><th>Summary</th></tr></thead>
+<tbody>
+${rows.map((r) => `<tr><td>${r.isoTs.slice(11, 19)}</td><td class="${r.kind}">${r.kind}</td><td>${r.summary.replace(/</g, "&lt;")}</td></tr>`).join("\n")}
+</tbody></table>
+</body></html>`;
+  writeFileSync(outHtml, html, "utf8");
+  success(`HTML report:  ${outHtml}`);
+  hr();
+  const eventCount = rows.length;
+  const diagCount = report.diagnoses.length;
+  console.log(`
+${eventCount} events \xB7 ${diagCount} diagnosis session(s) exported`);
+  console.log(`
+Share with your team: cat ${outJson} | pbcopy`);
+}
+async function initCommand() {
+  console.log("\u2B21 Mergen Init \u2014 Connect Datadog\n");
+  hr();
+  const { mkdirSync: mkdir2, writeFileSync: write2, readFileSync: read2, existsSync: exists2 } = await import("fs");
+  const { join: join2 } = await import("path");
+  const { homedir: home2 } = await import("os");
+  const configDir = join2(home2(), ".mergen");
+  const configPath = join2(configDir, "config.json");
+  let existing = {};
+  if (exists2(configPath)) {
+    try {
+      existing = JSON.parse(read2(configPath, "utf8"));
+    } catch {
+    }
+  }
+  const dd = existing.datadog ?? {};
+  console.log("You will need:");
+  console.log("  - DD_API_KEY  (Datadog \u2192 Organization Settings \u2192 API Keys)");
+  console.log("  - DD_APP_KEY  (Datadog \u2192 Organization Settings \u2192 Application Keys)");
+  console.log("");
+  const apiKey = await ask(`Datadog API Key${dd.apiKey ? " [keep existing]" : ""}: `);
+  const appKey = await ask(`Datadog App Key${dd.appKey ? " [keep existing]" : ""}: `);
+  const sites = {
+    "1": "datadoghq.com",
+    "2": "datadoghq.eu",
+    "3": "us3.datadoghq.com",
+    "4": "us5.datadoghq.com",
+    "5": "ap1.datadoghq.com"
+  };
+  console.log("\nDatadog site:");
+  console.log("  1. US1 - datadoghq.com (default)");
+  console.log("  2. EU  - datadoghq.eu");
+  console.log("  3. US3 - us3.datadoghq.com");
+  console.log("  4. US5 - us5.datadoghq.com");
+  console.log("  5. AP1 - ap1.datadoghq.com");
+  const siteChoice = await ask("\nSite [1]: ");
+  const site = sites[siteChoice.trim() || "1"] ?? "datadoghq.com";
+  const finalApiKey = apiKey.trim() || dd.apiKey || "";
+  const finalAppKey = appKey.trim() || dd.appKey || "";
+  if (!finalApiKey || !finalAppKey) {
+    error("API Key and App Key are both required.");
+    process.exit(1);
+  }
+  process.stdout.write("\nTesting Datadog connection... ");
+  try {
+    const res = await fetch(`https://api.${site}/api/v1/validate`, {
+      headers: { "DD-API-KEY": finalApiKey, "DD-APPLICATION-KEY": finalAppKey },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) {
+      console.log("\u2717");
+      const body = await res.text();
+      error(`Auth failed (${res.status}): ${body.slice(0, 100)}`);
+      error("Double-check your API Key and App Key in Datadog Organization Settings.");
+      process.exit(1);
+    }
+    console.log("\u2713");
+  } catch (e) {
+    console.log("\u2717");
+    error(`Could not reach api.${site}: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
+  mkdir2(configDir, { recursive: true });
+  const config = {
+    ...existing,
+    datadog: { apiKey: finalApiKey, appKey: finalAppKey, site }
+  };
+  write2(configPath, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
+  hr();
+  success("Datadog credentials saved to ~/.mergen/config.json");
+  console.log("");
+  console.log("Available MCP tools:");
+  console.log("  get_incident_context   \u2192 fetch + compact latest error trace");
+  console.log("  get_datadog_trace      \u2192 compact a specific trace by ID");
+  console.log("");
+  console.log("PagerDuty auto-trigger (optional):");
+  console.log("  Add a webhook in PagerDuty \u2192 Service \u2192 Webhooks:");
+  console.log("  URL: http://127.0.0.1:3000/webhooks/pagerduty");
+  console.log("  Type: V3 webhook");
+  console.log("");
+  log("Restart the server to apply: mergen-server start");
+}
+async function demoCommand() {
+  const { createServer } = await import("http");
+  const { createApp } = await import("../app.js");
+  const { loadSeedCorpus, SEED_COUNT } = await import("../seeds/corpus.js");
+  console.log("\n\u2B21 Mergen\n");
+  process.stdout.write("Loading 50 sample incidents...");
+  const { loaded } = loadSeedCorpus();
+  console.log(` \u2713  (${loaded > 0 ? `${loaded} loaded` : `${SEED_COUNT} ready`})`);
+  try {
+    const { listSnapshotPids, replayIncident } = await import("../intelligence/incident-replay.js");
+    const pids = listSnapshotPids().filter((p) => p.startsWith("seed-"));
+    if (pids.length > 0) {
+      const pid = pids[0];
+      process.stdout.write("Running causal analysis...");
+      const result = await replayIncident(pid);
+      if (result) {
+        const conf = Math.round((result.replayedHypothesis.confidenceScore ?? 0) * 100);
+        const rawTag = (result.replayedHypothesis.tag ?? "unknown").replace(/^infra_/, "");
+        const label = rawTag.split("_").map((w, i) => i === 0 ? w.toUpperCase() : w).join(" ");
+        const fix = result.replayedHypothesis.fixHint ?? "";
+        console.log(` \u2713`);
+        console.log("");
+        console.log(`  Detected:   ${label}  [${conf}% confidence]`);
+        if (fix) {
+          console.log(`  Fix:        ${fix.split(".")[0]}.`);
+        }
+        console.log("");
+      }
+    }
+  } catch {
+  }
+  const { createServer: createNetServer } = await import("net");
+  let port = 3e3;
+  for (let p = 3e3; p <= 3010; p++) {
+    const available = await new Promise((res) => {
+      const probe = createNetServer();
+      probe.once("error", () => res(false));
+      probe.once("listening", () => {
+        probe.close(() => res(true));
+      });
+      probe.listen(p, "127.0.0.1");
+    });
+    if (available) {
+      port = p;
+      break;
+    }
+    if (p === 3010) {
+      error("Ports 3000\u20133010 are all in use.");
+      console.log("  Free one with: lsof -ti:3000 | xargs kill");
+      process.exit(1);
+    }
+    log(`Port ${p} in use \u2014 trying ${p + 1}`, "\u21A9");
+  }
+  process.stdout.write("Starting server...");
+  const app = createApp({
+    serverVersion: VERSION,
+    localSecret: "demo",
+    port,
+    bindHost: "127.0.0.1"
+  });
+  const server = createServer(app);
+  await new Promise((resolve2, reject) => {
+    server.listen(port, "127.0.0.1", resolve2);
+    server.on("error", reject);
+  });
+  const url = `http://localhost:${port}/demo`;
+  console.log(` \u2713`);
+  console.log(`  http://localhost:${port}
+`);
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("Connect your stack when ready (all optional):");
+  console.log("  Watch any process:  mergen-server watch npm start");
+  console.log("  Docker containers:  curl -X POST http://127.0.0.1:3000/watchers/docker");
+  console.log("  Add to your IDE:    mergen-server setup");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const open = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const { exec } = await import("child_process");
+    exec(`${open} "${url}"`);
+  } catch {
+  }
+  process.on("SIGINT", () => {
+    console.log("\nDemo server stopped.");
+    server.close();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+async function exportRiskReportCommand(args) {
+  const fmt = args.includes("--markdown") || args.includes("--md") ? "md" : "json";
+  let port = 3e3;
+  for (let p = 3e3; p <= 3010; p++) {
+    try {
+      const r = await fetch(`http://127.0.0.1:${p}/health`, { signal: AbortSignal.timeout(600) });
+      if (r.ok) {
+        port = p;
+        break;
+      }
+    } catch {
+    }
+  }
+  const { join: join2 } = await import("path");
+  const { homedir: homedir2 } = await import("os");
+  const { existsSync: existsSync2, readFileSync: readFileSync2 } = await import("fs");
+  let secret = "";
+  const secretPath = join2(homedir2(), ".mergen", "secret");
+  if (existsSync2(secretPath)) {
+    try {
+      secret = readFileSync2(secretPath, "utf8").trim();
+    } catch {
+    }
+  }
+  const headers = {};
+  if (secret) headers["x-mergen-secret"] = secret;
+  let resp;
+  try {
+    resp = await fetch(`http://127.0.0.1:${port}/risk-report${fmt === "md" ? "?format=md" : ""}`, {
+      headers,
+      signal: AbortSignal.timeout(5e3)
+    });
+  } catch {
+    error("Mergen server is not running. Start it first: mergen-server start");
+    process.exit(1);
+    return;
+  }
+  if (!resp.ok) {
+    error(`Risk report request failed: ${resp.status}`);
+    process.exit(1);
+  }
+  if (fmt === "md") {
+    const { writeFileSync: wf } = await import("fs");
+    const filename = `mergen-risk-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.md`;
+    const body = await resp.text();
+    wf(filename, body, "utf8");
+    success(`CISO risk report saved: ${filename}`);
+    log("Share this with your security team \u2014 all data sourced from your local infrastructure.");
+  } else {
+    const data = await resp.json();
+    if (!data.ok) {
+      error("Failed to generate risk report.");
+      process.exit(1);
+    }
+    const { report } = data;
+    hr();
+    console.log("\u2B21 Mergen \u2014 AI Agent Security Risk Report\n");
+    console.log(`  Risk Level  : ${String(report.riskScore ?? "").toUpperCase()}`);
+    console.log(`  Assessment  : ${report.riskRationale}`);
+    console.log(`  Total blocked (all time) : ${report.totalBlocked}`);
+    console.log(`  Blocked \u2014 last 7 days   : ${report.last7Days}`);
+    console.log(`  Blocked \u2014 last 30 days  : ${report.last30Days}`);
+    console.log(`  Active block rules       : ${report.activeRules}`);
+    console.log(`  Override corpus entries  : ${report.overrideCorpusSize}`);
+    console.log("");
+    log("For a shareable CISO document: mergen-server export-risk-report --markdown");
+    hr();
+  }
+}
+async function partnerShortlistCommand(subArgs) {
+  const listPath = join(homedir(), ".mergen", "partner-shortlist.json");
+  const { mkdirSync: mkdirSync2 } = await import("fs");
+  if (subArgs[0] === "--add") {
+    const [, name = "", company = "", role = "", reach = "", ...noteParts] = subArgs;
+    const notes = noteParts.join(" ");
+    if (!name || !company) {
+      error("Usage: partner-shortlist --add <name> <company> [role] [reach] [notes]");
+      process.exit(1);
+    }
+    mkdirSync2(join(homedir(), ".mergen"), { recursive: true });
+    let list = [];
+    try {
+      list = JSON.parse(readFileSync(listPath, "utf8"));
+    } catch {
+    }
+    list.push({ name, company, role, reach, notes, addedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    writeFileSync(listPath, JSON.stringify(list, null, 2) + "\n", "utf8");
+    success(`Added ${name} (${company}) to partner shortlist`);
+    return;
+  }
+  if (subArgs[0] === "--list") {
+    let list = [];
+    try {
+      list = JSON.parse(readFileSync(listPath, "utf8"));
+    } catch {
+    }
+    if (list.length === 0) {
+      log("No candidates yet. Add with: mergen-server partner-shortlist --add", "\u2139");
+      return;
+    }
+    const div2 = "\u2500".repeat(60);
+    console.log("\nMergen \u2014 Design-partner shortlist\n" + div2);
+    for (const c of list) {
+      console.log(`  ${c.name.padEnd(22)} ${c.company.padEnd(20)} ${c.role}`);
+      if (c.reach) console.log(`    Reach: ${c.reach}`);
+      if (c.notes) console.log(`    Notes: ${c.notes}`);
+    }
+    console.log(div2 + "\n");
+    return;
+  }
+  const W = 60;
+  const div = "\u2500".repeat(W);
+  console.log("\nMergen \u2014 Design-partner filter criteria");
+  console.log(div);
+  console.log("  The right first partner gives you a credible case study,");
+  console.log("  not a friendly pilot that never stresses the gate.\n");
+  console.log("  Required (all must be true):");
+  console.log("    [ ] Public postmortem published in last 12 months");
+  console.log("        (they already do blameless post-mortems \u2192 safety mindset)");
+  console.log("    [ ] 2\u20135 person SRE / platform team");
+  console.log("        (small enough for Mergen to matter, big enough to have incidents)");
+  console.log("    [ ] On PagerDuty (webhook integration = Day 1 incident coverage)");
+  console.log("    [ ] Someone with public reach (Twitter/X, blog, conference talk)");
+  console.log("        (their Day-30 quote is worth 10\xD7 paid ads)\n");
+  console.log("  Nice to have:");
+  console.log("    [ ] Already using an AI coding agent (Claude Code / Cursor / Copilot)");
+  console.log("    [ ] Compliance pressure (SOC 2, HIPAA, fintech) \u2014 AEG is mandatory for them");
+  console.log("    [ ] Recent infrastructure incident (motivation is high)\n");
+  console.log("  Disqualify if:");
+  console.log("    [ ] > 150 developers (sale requires VP Eng buy-in, wrong stage)");
+  console.log("    [ ] No PagerDuty / no incident workflow (Mergen has nothing to triage)");
+  console.log("    [ ] Solo developer (Layer 2+ features don't apply yet)\n");
+  console.log("  Day-30 pre-agreement (send before trial starts):");
+  console.log(`    "At Day 30 we'll run: mergen-server impact-report --slide"`);
+  console.log('    "We pre-agree these 5 numbers are the success criteria."');
+  console.log('    "No new metrics after the trial starts."\n');
+  console.log("  Commands:");
+  console.log("    mergen-server partner-shortlist --add <name> <company> [role] [reach] [notes]");
+  console.log("    mergen-server partner-shortlist --list");
+  console.log(div + "\n");
+}
+async function execCommand(args) {
+  let actor = "claude";
+  let service = "cli";
+  let allowOffline = false;
+  let dashDash = args.indexOf("--");
+  const flagArgs = dashDash >= 0 ? args.slice(0, dashDash) : args;
+  for (let i = 0; i < flagArgs.length; i++) {
+    if (flagArgs[i] === "--actor" && flagArgs[i + 1]) actor = flagArgs[++i];
+    else if (flagArgs[i] === "--service" && flagArgs[i + 1]) service = flagArgs[++i];
+    else if (flagArgs[i] === "--allow-offline") allowOffline = true;
+  }
+  const cmdParts = dashDash >= 0 ? args.slice(dashDash + 1) : args;
+  if (cmdParts.length === 0) {
+    error("Usage: mergen-server exec [--actor <name>] [--service <name>] [--allow-offline] -- <command> [args...]");
+    process.exit(1);
+  }
+  const fullCommand = cmdParts.join(" ");
+  const { evaluateViaGate } = await import("./gate.js");
+  let evaluation;
+  try {
+    evaluation = await evaluateViaGate(fullCommand);
+  } catch (err) {
+    error(`exec: gate evaluation request failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+    return;
+  }
+  if (evaluation.reachable) {
+    if (evaluation.isError) {
+      hr();
+      console.error("\u2B21 Mergen \u2014 BLOCKED\n");
+      console.error(evaluation.text);
+      hr();
+      process.exit(1);
+    }
+  } else if (!allowOffline) {
+    hr();
+    error("exec: no mergen-server is running \u2014 refusing to execute (fail closed).");
+    console.error("  Start it with: mergen-server start");
+    console.error("  Or explicitly accept reduced, local-only checks: mergen-server exec --allow-offline -- ...");
+    hr();
+    process.exit(1);
+  } else {
+    console.warn("\u2B21 Mergen \u2014 mergen-server not reachable, running with reduced local-only checks (--allow-offline)");
+    const {
+      evaluateEnterprisePolicy,
+      loadEnterprisePolicy,
+      DEFAULT_ENTERPRISE_POLICY: DEFAULT_POLICY,
+      _resetPolicyCacheForTesting: _resetPolicy
+    } = await import("../intelligence/enterprise-policy-engine.js");
+    const evalInput = { files: [], commands: [fullCommand], actor, service };
+    const savedPolicy = loadEnterprisePolicy();
+    _resetPolicy(DEFAULT_POLICY);
+    const defaultResult = evaluateEnterprisePolicy(evalInput);
+    _resetPolicy(savedPolicy);
+    const userResult = evaluateEnterprisePolicy(evalInput);
+    const verdictRank = (v) => v === "block" ? 2 : v === "warn" ? 1 : 0;
+    const result = verdictRank(defaultResult.verdict) >= verdictRank(userResult.verdict) ? defaultResult : userResult;
+    if (result.verdict === "block") {
+      hr();
+      console.error("\u2B21 Mergen \u2014 BLOCKED (offline check)\n");
+      console.error(`  Command : ${fullCommand}`);
+      console.error(`  Reason  : ${result.reasons[0] ?? "Destructive pattern matched"}`);
+      hr();
+      const { randomUUID } = await import("crypto");
+      const blunder = {
+        id: randomUUID(),
+        recordedAt: Date.now(),
+        type: "blunder",
+        blunderType: "pipeline_block",
+        command: fullCommand,
+        blockReason: result.reasons[0] ?? "Destructive pattern matched",
+        service,
+        actor
+      };
+      try {
+        const { appendFileSync, mkdirSync: mkdirSync2 } = await import("fs");
+        const { join: join2, dirname: dirname2 } = await import("path");
+        const { homedir: homedir2 } = await import("os");
+        const file = join2(homedir2(), ".mergen", "offline-blunders.jsonl");
+        mkdirSync2(dirname2(file), { recursive: true });
+        appendFileSync(file, JSON.stringify(blunder) + "\n", "utf8");
+      } catch {
+      }
+      process.exit(1);
+    }
+    if (result.verdict === "warn") {
+      console.warn(`\u2B21 Mergen \u2014 WARNING: ${result.reasons[0] ?? "Action requires review"}`);
+      console.warn("  Proceeding \u2014 but this action has been flagged for audit (offline mode: no HITL hold available).");
+    }
+  }
+  const { traceEnv } = await import("../intelligence/trace-context.js");
+  const { spawnSandboxed } = await import("../intelligence/sandbox.js");
+  const { child, sandboxed, backend } = await spawnSandboxed(cmdParts[0], cmdParts.slice(1), {
+    cwd: process.cwd(),
+    stdio: "inherit",
+    env: { ...process.env, ...traceEnv() }
+  });
+  let watcher = null;
+  if (backend !== "docker" && child.pid) {
+    const rootPid = child.pid;
+    const { watchDescendants, killTree } = await import("../intelligence/process-tree.js");
+    const { evaluateEnterprisePolicy } = await import("../intelligence/enterprise-policy-engine.js");
+    watcher = watchDescendants(rootPid, {
+      onSpawn: (proc) => {
+        const result = evaluateEnterprisePolicy({ files: [], commands: [proc.command], actor, service });
+        if (result.verdict !== "block") return;
+        console.error(
+          `
+\u2B21 Mergen \u2014 a spawned child process matched a destructive pattern; terminating the process tree (detected after the fact, not blocked pre-exec \u2014 see mergen-server docs on process-tree monitoring limits).`
+        );
+        console.error(`  pid=${proc.pid}  command=${proc.command}`);
+        void killTree(rootPid);
+        void (async () => {
+          const { getStores } = await import("../storage/store-registry.js");
+          await getStores().blunders.record({
+            blunderType: "pipeline_block",
+            command: proc.command,
+            blockReason: `Descendant process matched a destructive pattern (post-spawn detect-and-kill): ${result.reasons.join("; ")}`,
+            service,
+            tag: "process_tree_descendant",
+            actor,
+            pid: String(proc.pid),
+            confidenceScore: null,
+            triggeredRules: result.triggeredRules
+          });
+        })();
+      }
+    });
+  }
+  child.on("close", (code) => {
+    watcher?.stop();
+    process.exit(code ?? 0);
+  });
+  child.on("error", (err) => {
+    watcher?.stop();
+    error(`exec failed: ${err.message}`);
+    process.exit(1);
+  });
+}
+export {
+  demoCommand,
+  execCommand,
+  exportCommand,
+  exportRiskReportCommand,
+  impactReportCommand,
+  initCommand,
+  inviteCommand,
+  joinCommand,
+  partnerShortlistCommand
+};