mergen-server 1.4.0

package/dist/index.js

@@ -0,0 +1,505 @@
+#!/usr/bin/env node
+import fs from "fs";
+import net from "net";
+import http from "http";
+import https from "https";
+import { randomUUID } from "crypto";
+import { createRequire } from "module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { lemonSqueezySetup } from "@lemonsqueezy/lemonsqueezy.js";
+import logger from "./sensor/logger.js";
+import { DATA_DIR, SECRET_FILE } from "./sensor/paths.js";
+import { setBufferSizeGetter, store, setStore } from "./sensor/buffer.js";
+import { wrapWithRedisPersistence, stopRedisStore } from "./sensor/redis-store.js";
+import { actionLedger } from "./sensor/action-ledger.js";
+import { startWatcher } from "./sensor/watcher.js";
+import { startDockerMonitor, startHeapMonitor, stopDockerMonitor } from "./sensor/docker-monitor.js";
+import { startDockerLogStream, stopDockerLogStream } from "./sensor/docker-log-stream.js";
+import { incidentStore } from "./sensor/incident-store.js";
+import { postmortemStore } from "./intelligence/postmortem-store.js";
+import { memoryStore } from "./datadog/memory-store.js";
+import { commitContextStore } from "./sensor/commit-context-store.js";
+import { agentContextStore as agentMemoryStore } from "./sensor/agent-context-store.js";
+import { complianceLedgerStore } from "./sensor/audit-log.js";
+import { stopAllProcessWatchers } from "./sensor/process-watcher.js";
+import { stopFileWatch } from "./sensor/fs-watcher.js";
+import { saveSession, loadSession } from "./sensor/session-persist.js";
+import { saveSessionToHistory } from "./sensor/session-history.js";
+import { syncMarkdownFilesFromDisk } from "./intelligence/postmortem-parser.js";
+import { initLicense, getActivePlanId, revalidateLicense } from "./intelligence/license.js";
+import { initUsage, flushOverageOnShutdown } from "./intelligence/usage.js";
+import { flushPendingRebuild } from "./intelligence/hypothesis-history.js";
+import { initTeam, broadcastToTeam } from "./intelligence/team.js";
+import { initTelemetry, maybeSendTelemetry } from "./intelligence/telemetry.js";
+import { getPlan } from "./intelligence/plans.js";
+import { registerTools, toolCallCounts } from "./intelligence/tools.js";
+import { createGuardedServer, loadBypasses, persistBypasses, setBypassSecret, denyStaleHoldsOnStartup, assertGateCoversRegisteredTools } from "./intelligence/tool-guard.js";
+import { setPolicySigningSecret, assertUnsignedPolicyFlagIsSafe } from "./intelligence/enterprise-policy-engine.js";
+import { setAgentTokenSecret } from "./intelligence/agent-identity.js";
+import { setBlunderHmacSecret } from "./sensor/agent-blunder-store.js";
+import { flushApprovals } from "./intelligence/execution-gate.js";
+import { registerResources } from "./intelligence/mcp-resources.js";
+import { registerPrompts } from "./intelligence/mcp-prompts.js";
+import { SYSTEM_PROMPT } from "./intelligence/prompts.js";
+import { registerTeamBroadcaster } from "./sensor/ingest.js";
+import { isCorpusSeeded, getRealVerdictCount } from "./__stubs__/calibration.js";
+import { startSlackDailyDigest } from "./intelligence/slack-digest.js";
+import { startSlackOverrideLoop } from "./intelligence/slack-override-loop.js";
+import { startGitAdrSync } from "./intelligence/git-adr-sync.js";
+import { startPolicySync } from "./intelligence/policy-sync.js";
+import { startShadowDigestCron } from "./intelligence/shadow-digest-cron.js";
+import { startDegradationWatcher } from "./intelligence/degradation-watcher.js";
+import { startHeartbeatMonitor, setHeartbeatAlertFn } from "./sensor/heartbeat-monitor.js";
+import { startGateHeartbeat } from "./sensor/gate-heartbeat.js";
+import { startK8sEventsPoller } from "./sensor/k8s-events.js";
+import { loadPlugins } from "./intelligence/detector-plugins.js";
+import { notify } from "./intelligence/notifications.js";
+import { serviceGraph } from "./sensor/service-graph.js";
+import { createStores } from "./storage/store-factory.js";
+import { setStores } from "./storage/store-registry.js";
+import { initCloudApiKeys } from "./sensor/cloud-auth.js";
+import { createApp } from "./app.js";
+import { checkForUpdates, formatUpdateMessage } from "./update-checker.js";
+import { loadCommunityCorpus } from "./seeds/community-corpus.js";
+const _require = createRequire(import.meta.url);
+const { version: SERVER_VERSION } = _require("../package.json");
+const PORT_RANGE_START = 3e3;
+const PORT_RANGE_END = 3010;
+const BIND_HOST = process.env.MERGEN_BIND ?? "127.0.0.1";
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const s = net.createServer();
+    s.once("error", () => resolve(false));
+    s.once("listening", () => s.close(() => resolve(true)));
+    s.listen(port, BIND_HOST);
+  });
+}
+async function findPort(start, end) {
+  for (let port = start; port <= end; port++) {
+    if (await isPortAvailable(port)) return port;
+    logger.warn(`port ${port} in use, trying next...`);
+  }
+  logger.error(`all ports ${start}\u2013${end} are in use; kill the conflicting process and restart`);
+  process.exit(1);
+}
+function validateConfig() {
+  const CLOUD_MODE = process.env.MERGEN_CLOUD_MODE === "true";
+  const AUTOPILOT = process.env.MERGEN_AUTOPILOT === "true";
+  const TEAM_MODE = BIND_HOST !== "127.0.0.1";
+  if (CLOUD_MODE) {
+    if (!process.env.MERGEN_PG_URL) {
+      logger.error(
+        "FATAL: MERGEN_CLOUD_MODE=true but MERGEN_PG_URL is not set. Cloud mode requires a Postgres connection for durable storage. Set MERGEN_PG_URL=postgres://user:pass@host:5432/mergen and restart."
+      );
+      process.exit(1);
+    }
+    if (!process.env.MERGEN_REDIS_URL) {
+      logger.error(
+        "FATAL: MERGEN_CLOUD_MODE=true but MERGEN_REDIS_URL is not set. Cloud mode requires Redis for BullMQ job queues and distributed state. Set MERGEN_REDIS_URL=redis://host:6379 and restart."
+      );
+      process.exit(1);
+    }
+  }
+  if (AUTOPILOT && !process.env.MERGEN_PAGERDUTY_SECRET) {
+    logger.error(
+      "FATAL: MERGEN_AUTOPILOT=true but MERGEN_PAGERDUTY_SECRET is not set. Without webhook signature verification any caller can trigger autonomous execution. Set MERGEN_PAGERDUTY_SECRET to the signing secret from your PagerDuty webhook config, then restart."
+    );
+    process.exit(1);
+  }
+  if (TEAM_MODE && !process.env.MERGEN_SECRET) {
+    logger.error(
+      "FATAL: MERGEN_BIND is not 127.0.0.1 (team mode) but MERGEN_SECRET is not set. The /ingest endpoint would accept events from any network caller. Generate a secret with: openssl rand -hex 32  then set MERGEN_SECRET=<value> and restart."
+    );
+    process.exit(1);
+  }
+  if (!process.env.MERGEN_SLACK_BOT_TOKEN) {
+    logger.warn(
+      "startup: MERGEN_SLACK_BOT_TOKEN not set \u2014 incident Slack alerts and thread replies are disabled. Set it to your Slack bot token (xoxb-...) to enable autonomous incident notifications."
+    );
+  }
+  if (process.env.MERGEN_SLACK_BOT_TOKEN && !process.env.MERGEN_SLACK_SIGNING_SECRET) {
+    logger.warn(
+      "startup: MERGEN_SLACK_BOT_TOKEN is set but MERGEN_SLACK_SIGNING_SECRET is missing \u2014 the /slack/actions endpoint will reject all requests until the signing secret is configured. Set MERGEN_SLACK_SIGNING_SECRET to the HMAC secret from your Slack app configuration."
+    );
+  }
+  if (CLOUD_MODE && !process.env.MERGEN_PAGERDUTY_SECRET) {
+    logger.error(
+      "FATAL: MERGEN_CLOUD_MODE=true but MERGEN_PAGERDUTY_SECRET is not set. In cloud mode the server is network-reachable and an unsigned webhook can trigger autonomous execution. Set MERGEN_PAGERDUTY_SECRET to the signing secret from your PagerDuty webhook config, then restart."
+    );
+    process.exit(1);
+  } else if (!AUTOPILOT && !process.env.MERGEN_PAGERDUTY_SECRET) {
+    logger.warn(
+      "startup: MERGEN_PAGERDUTY_SECRET not set \u2014 PagerDuty webhook signature verification is disabled. Diagnosis-only mode is active so no commands will execute, but set the secret before enabling autopilot."
+    );
+  }
+  if (CLOUD_MODE && !process.env.MERGEN_TLS_CERT) {
+    logger.warn(
+      "startup: MERGEN_CLOUD_MODE=true but MERGEN_TLS_CERT / MERGEN_TLS_KEY are not set \u2014 server will start in plain HTTP. Set TLS certificates for secure cloud deployments."
+    );
+  }
+  if (!process.env.MERGEN_SECRET) {
+    logger.warn(
+      "startup: MERGEN_SECRET not set \u2014 /ingest endpoint accepts events from any local process. Set MERGEN_SECRET=<random-string> to restrict ingest to authenticated sources."
+    );
+  }
+  if (process.env.MERGEN_POLICY_URL && !process.env.MERGEN_POLICY_URL.startsWith("https://")) {
+    logger.error(
+      "FATAL: MERGEN_POLICY_URL must use HTTPS (got a plain HTTP URL). A plain HTTP policy URL allows MITM injection of permissive policy rules that disable safety gates. Update MERGEN_POLICY_URL to an https:// address and restart."
+    );
+    process.exit(1);
+  }
+  if (TEAM_MODE && !process.env.MERGEN_PUBLIC_URL) {
+    logger.warn(
+      "startup: MERGEN_BIND is not 127.0.0.1 (team mode) but MERGEN_PUBLIC_URL is not set. HITL webhook approve/deny links will point to http://127.0.0.1 \u2014 unreachable from Slack or external callers. Set MERGEN_PUBLIC_URL=https://your-server.example.com so Slack can POST the approve/deny callback."
+    );
+  }
+  if (AUTOPILOT && process.env.MERGEN_SHADOW_MODE === void 0) {
+    logger.warn(
+      "startup: MERGEN_AUTOPILOT=true but MERGEN_SHADOW_MODE is not set \u2014 defaulting to SHADOW MODE. Mergen will diagnose incidents and post Slack alerts but will NOT execute commands. Review GET /shadow-report to build trust, then set MERGEN_SHADOW_MODE=false to enable live execution."
+    );
+  }
+  const enabled = [];
+  if (AUTOPILOT) enabled.push("autopilot");
+  if (process.env.MERGEN_SHADOW_MODE === "true") enabled.push("shadow-mode");
+  if (process.env.MERGEN_DOCKER_MONITOR === "true") enabled.push("docker-monitor");
+  if (process.env.MERGEN_DOCKER_LOGS === "true") enabled.push("docker-logs");
+  if (process.env.MERGEN_K8S_NAMESPACE) enabled.push(`k8s(${process.env.MERGEN_K8S_NAMESPACE})`);
+  if (process.env.MERGEN_REDIS_URL) enabled.push("redis");
+  if (process.env.DD_API_KEY) enabled.push("datadog");
+  if (enabled.length > 0) logger.info({ enabled }, "startup: optional features enabled");
+}
+async function main() {
+  validateConfig();
+  const lsApiKey = process.env.LS_API_KEY;
+  if (lsApiKey) lemonSqueezySetup({ apiKey: lsApiKey });
+  let localSecret;
+  try {
+    fs.mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
+    if (fs.existsSync(SECRET_FILE)) {
+      localSecret = fs.readFileSync(SECRET_FILE, "utf8").trim();
+    } else {
+      localSecret = randomUUID();
+      fs.writeFileSync(SECRET_FILE, localSecret, { encoding: "utf8", mode: 384 });
+    }
+  } catch (err) {
+    logger.warn({ err }, "secret: could not read/write secret file, generating ephemeral secret");
+    localSecret = randomUUID();
+  }
+  await initLicense();
+  await initUsage();
+  setInterval(() => {
+    void revalidateLicense();
+  }, 24 * 60 * 60 * 1e3).unref();
+  await initTeam();
+  await initTelemetry();
+  if (process.env.MERGEN_CLOUD_MODE === "true") {
+    const { runMigrations } = await import("./storage/pg/pg-migrations.js");
+    await runMigrations();
+    logger.info("startup: Postgres migrations applied");
+  }
+  const stores = await createStores();
+  setStores(stores);
+  await stores.events.init();
+  await stores.incidents.init();
+  await initCloudApiKeys();
+  setInterval(() => stores.events.pruneOld().catch(() => {
+  }), 6e4).unref();
+  await postmortemStore.init();
+  void syncMarkdownFilesFromDisk().catch((err) => logger.warn({ err }, "startup: markdown sync failed"));
+  await complianceLedgerStore.init();
+  try {
+    const staleCount = postmortemStore.countUnverifiedAutonomous();
+    if (staleCount > 0) {
+      logger.warn(
+        `startup: ${staleCount} postmortem${staleCount !== 1 ? "s" : ""} with resolved_autonomously=1 and causally_correct=0 found in corpus \u2014 likely written before the causal-verification fix. check_fix_history and runbook verified_fixes will show conservative (low) success rates until new causally-verified resolutions are recorded. These rows expire from the 90-day retention window automatically.`
+      );
+    }
+  } catch {
+  }
+  await memoryStore.init();
+  await commitContextStore.init();
+  await agentMemoryStore.init();
+  await actionLedger.init();
+  serviceGraph.loadPersisted();
+  const { hydrateGateAnalytics } = await import("./intelligence/gate-analytics.js");
+  await hydrateGateAnalytics();
+  assertUnsignedPolicyFlagIsSafe();
+  setBypassSecret(localSecret);
+  const policySigningSecret = process.env.MERGEN_POLICY_SIGNING_SECRET || localSecret;
+  if (!process.env.MERGEN_POLICY_SIGNING_SECRET) {
+    logger.warn(
+      "startup: MERGEN_POLICY_SIGNING_SECRET not set \u2014 enterprise-policy.json is signed with the same on-disk secret (~/.mergen/secret) used for admin API auth. Anything with local filesystem access can read that file and forge a valid policy signature. Set MERGEN_POLICY_SIGNING_SECRET to a value supplied only via the environment (never written to disk) for production/team deployments."
+    );
+  }
+  setPolicySigningSecret(policySigningSecret);
+  const agentTokenSecret = process.env.MERGEN_AGENT_TOKEN_SECRET || localSecret;
+  if (!process.env.MERGEN_AGENT_TOKEN_SECRET) {
+    logger.warn(
+      "startup: MERGEN_AGENT_TOKEN_SECRET not set \u2014 agent identity tokens are signed with the same on-disk secret (~/.mergen/secret) used for admin API auth. Set MERGEN_AGENT_TOKEN_SECRET to a value supplied only via the environment for production/team deployments."
+    );
+  }
+  setAgentTokenSecret(agentTokenSecret);
+  setBlunderHmacSecret(process.env.MERGEN_AUDIT_SECRET || localSecret);
+  if (!process.env.MERGEN_OIDC_SIGNING_KEY) {
+    logger.warn(
+      "startup: MERGEN_OIDC_SIGNING_KEY not set \u2014 the OIDC federation signing key (used for GCP/Azure ephemeral credential brokering) is generated once and persisted in plaintext at ~/.mergen/oidc-signing-key.json. Anything with local filesystem access can read it and mint its own valid federation tokens. Set MERGEN_OIDC_SIGNING_KEY to a PEM-encoded PKCS8 private key supplied only via the environment for production/team deployments using GCP or Azure credential brokering."
+    );
+  }
+  loadBypasses();
+  denyStaleHoldsOnStartup();
+  loadCommunityCorpus();
+  setBufferSizeGetter(() => getPlan(getActivePlanId()).bufferSize);
+  await loadPlugins();
+  setHeartbeatAlertFn((name, description) => {
+    const pid = randomUUID();
+    incidentStore.upsert(pid, {
+      status: "open",
+      hypothesis: `Heartbeat missed: ${name}`,
+      tag: "heartbeat_missed",
+      confidence: 1
+    });
+    void notify(pid, `\u23F0 *Heartbeat Missed* \u2014 \`${name}\`
+${description}`, {
+      priority: "high",
+      tags: ["warning"]
+    });
+  });
+  startHeartbeatMonitor();
+  startGateHeartbeat();
+  startK8sEventsPoller();
+  const savedEvents = loadSession();
+  if (savedEvents && savedEvents.length > 0) {
+    store.rehydrate(savedEvents);
+    logger.info({ count: savedEvents.length }, "session rehydrated from disk");
+  }
+  if (process.env.MERGEN_REDIS_URL) {
+    const redisStore = await wrapWithRedisPersistence(store);
+    if (redisStore !== store) setStore(redisStore);
+  }
+  setInterval(() => saveSession(store.serialize()), 1e4).unref();
+  registerTeamBroadcaster(broadcastToTeam);
+  const port = await findPort(PORT_RANGE_START, PORT_RANGE_END);
+  const app = createApp({ serverVersion: SERVER_VERSION, localSecret, port, bindHost: BIND_HOST });
+  const tlsCert = process.env.MERGEN_TLS_CERT;
+  const tlsKey = process.env.MERGEN_TLS_KEY;
+  let httpServer;
+  if (tlsCert && tlsKey) {
+    try {
+      const cert = fs.readFileSync(tlsCert);
+      const key = fs.readFileSync(tlsKey);
+      httpServer = https.createServer({ cert, key }, app).listen(port, BIND_HOST, () => {
+        logger.info({ port, host: BIND_HOST }, `HTTPS ingest listening on https://${BIND_HOST}:${port}`);
+      });
+    } catch (err) {
+      if (BIND_HOST !== "127.0.0.1") {
+        logger.error(
+          { err },
+          "TLS: failed to read cert/key files \u2014 refusing to start without TLS on a network-accessible interface. Fix the cert/key paths, or set MERGEN_BIND=127.0.0.1 for local-only mode."
+        );
+        process.exit(1);
+      }
+      logger.error({ err }, "TLS: failed to read cert/key files \u2014 falling back to plain HTTP (local-only mode, 127.0.0.1 only)");
+      httpServer = http.createServer(app).listen(port, BIND_HOST, () => {
+        logger.info({ port, host: BIND_HOST }, `HTTP ingest listening on http://${BIND_HOST}:${port}`);
+      });
+    }
+  } else {
+    httpServer = app.listen(port, BIND_HOST, () => {
+      logger.info({ port, host: BIND_HOST }, `HTTP ingest listening on http://${BIND_HOST}:${port}`);
+    });
+  }
+  if (await isPortAvailable(4318)) {
+    const otlpApp = createApp({ serverVersion: SERVER_VERSION, localSecret, port: 4318, bindHost: BIND_HOST });
+    otlpApp.listen(4318, BIND_HOST, () => {
+      logger.info("OTLP HTTP receiver listening on http://127.0.0.1:4318");
+    });
+  } else {
+    logger.warn("port 4318 in use \u2014 OTLP receiver not started on dedicated port (still available on main port)");
+  }
+  const mcp = new McpServer(
+    { name: "mergen", version: SERVER_VERSION },
+    { instructions: SYSTEM_PROMPT }
+  );
+  const guardedMcp = createGuardedServer(mcp, port);
+  registerTools(guardedMcp);
+  registerResources(mcp);
+  registerPrompts(mcp);
+  await assertGateCoversRegisteredTools(guardedMcp);
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  logger.info("MCP server ready (stdio transport)");
+  checkForUpdates(SERVER_VERSION).then((latestVersion) => {
+    if (latestVersion) {
+      console.error(formatUpdateMessage(SERVER_VERSION, latestVersion));
+    }
+  }).catch(() => {
+  });
+  const telemetryTick = () => {
+    void maybeSendTelemetry({
+      serverVersion: SERVER_VERSION,
+      nodeVersion: process.versions.node.split(".")[0],
+      planId: getActivePlanId(),
+      toolCallCounts,
+      bufferedEvents: store.size()
+    });
+  };
+  setTimeout(telemetryTick, 6e4).unref();
+  setInterval(telemetryTick, 60 * 60 * 1e3).unref();
+  if (isCorpusSeeded()) {
+    const realCount = getRealVerdictCount();
+    console.error(
+      `
+\u26A0  CALIBRATION WARM-UP \u2014 Running on synthetic priors (${realCount} real verdicts recorded).
+   Confidence scores will reflect your production environment after 10 real verdicts.
+   Record verdicts via POST /feedback or the Slack verdict buttons.
+`
+    );
+  }
+  startShadowDigestCron();
+  try {
+    const { startPolicySuggesterCron } = await import("./intelligence/policy-suggester.js");
+    startPolicySuggesterCron();
+  } catch (err) {
+    logger.error({ err }, "startup: policy suggester cron failed to start");
+  }
+  if (process.env.MERGEN_SLACK_DIGEST === "true") {
+    try {
+      startSlackDailyDigest();
+    } catch (err) {
+      logger.error({ err }, "startup: startSlackDailyDigest failed \u2014 Slack digest disabled");
+    }
+  }
+  if (process.env.MERGEN_GIT_ADR_SYNC === "true") {
+    try {
+      startGitAdrSync();
+    } catch (err) {
+      logger.error({ err }, "startup: startGitAdrSync failed \u2014 ADR sync disabled");
+    }
+  }
+  if (process.env.MERGEN_POLICY_URL) {
+    try {
+      startPolicySync({
+        url: process.env.MERGEN_POLICY_URL,
+        mergeMode: process.env.MERGEN_POLICY_MERGE ?? "replace"
+      });
+    } catch (err) {
+      logger.error({ err }, "startup: startPolicySync failed \u2014 remote policy sync disabled");
+    }
+  }
+  if (process.env.MERGEN_SLACK_OVERRIDE_LOOP === "true") {
+    try {
+      startSlackOverrideLoop();
+    } catch (err) {
+      logger.error({ err }, "startup: startSlackOverrideLoop failed \u2014 override loop disabled");
+    }
+  }
+  if (process.env.MERGEN_AUTO_CORPUS_PROPOSE !== "false") {
+    const { proposeRulesFromCorpus } = await import("./intelligence/corpus-to-policy.js");
+    const runProposalScan = () => {
+      try {
+        proposeRulesFromCorpus();
+      } catch (err) {
+        logger.error({ err }, "corpus-propose: scan failed");
+      }
+    };
+    runProposalScan();
+    setInterval(runProposalScan, 6 * 60 * 60 * 1e3).unref();
+    logger.info("startup: corpus\u2192proposal bridge enabled (default on; MERGEN_AUTO_CORPUS_PROPOSE=false to disable)");
+  }
+  try {
+    startDegradationWatcher();
+  } catch (err) {
+    logger.error({ err }, "startup: startDegradationWatcher failed \u2014 degradation watcher disabled");
+  }
+  if ((process.env.MERGEN_CLOUD_MODE === "true" || process.env.MERGEN_BULLMQ === "true") && process.env.MERGEN_REDIS_URL) {
+    const { startWorkers } = await import("./workers/worker-registry.js");
+    await startWorkers();
+  }
+  startWatcher();
+  if (process.env.MERGEN_DOCKER_MONITOR === "true") startDockerMonitor();
+  if (process.env.MERGEN_DOCKER_LOGS === "true") void startDockerLogStream();
+  startHeapMonitor();
+  if (process.env.MERGEN_AUTO_WATCH !== "false") {
+    const net2 = await import("net");
+    const DEV_PORTS = [8080, 8e3, 3001, 4e3, 5e3, 8888, 9e3];
+    const portsWithServices = await Promise.all(
+      DEV_PORTS.map(
+        (p) => new Promise((resolve) => {
+          const s = new net2.Socket();
+          s.setTimeout(200);
+          s.once("connect", () => {
+            s.destroy();
+            resolve(p);
+          });
+          s.once("timeout", () => {
+            s.destroy();
+            resolve(null);
+          });
+          s.once("error", () => {
+            s.destroy();
+            resolve(null);
+          });
+          s.connect(p, "127.0.0.1");
+        })
+      )
+    );
+    const runningPorts = portsWithServices.filter((p) => p !== null);
+    if (runningPorts.length > 0) {
+      logger.info({ ports: runningPorts }, "auto-watch: detected dev servers");
+      const autoAttach = process.env.MERGEN_AUTO_ATTACH_PORTS;
+      if (autoAttach) {
+        const { startProcessWatcher } = await import("./sensor/process-watcher.js");
+        for (const portStr of autoAttach.split(",")) {
+          const p = parseInt(portStr.trim(), 10);
+          if (runningPorts.includes(p)) {
+            logger.info({ port: p }, `auto-watch: attaching to port ${p}`);
+          }
+        }
+      } else {
+        logger.info(
+          { ports: runningPorts, hint: `Run: mergen-server watch <your-start-command>` },
+          'auto-watch: dev servers detected \u2014 run "mergen-server watch <cmd>" to stream their logs'
+        );
+      }
+    }
+  }
+  function shutdown(signal) {
+    logger.info({ signal }, "shutting down");
+    const events = store.serialize();
+    saveSessionToHistory(events, `shutdown-${signal.toLowerCase()}`);
+    saveSession(events);
+    serviceGraph.flushSync();
+    flushApprovals();
+    persistBypasses();
+    actionLedger.flush();
+    Promise.all([flushOverageOnShutdown(), flushPendingRebuild()]).finally(() => {
+      const workerShutdown = (process.env.MERGEN_CLOUD_MODE === "true" || process.env.MERGEN_BULLMQ === "true") && process.env.MERGEN_REDIS_URL ? import("./workers/worker-registry.js").then(({ stopWorkers }) => stopWorkers()).catch(() => {
+      }) : Promise.resolve();
+      const pgShutdown = process.env.MERGEN_CLOUD_MODE === "true" ? import("./storage/pg/pg-client.js").then(({ closeSql }) => closeSql()).catch(() => {
+      }) : Promise.resolve();
+      void workerShutdown.finally(() => void pgShutdown.finally(() => {
+        stopDockerMonitor();
+        stopDockerLogStream();
+        stopAllProcessWatchers();
+        stopFileWatch();
+        stopRedisStore();
+        httpServer.close(() => {
+          logger.info("HTTP server closed");
+          process.exit(0);
+        });
+      }));
+      const _hardExit = setTimeout(() => {
+        logger.error("shutdown: graceful shutdown timed out after 30s \u2014 forcing exit");
+        process.exit(1);
+      }, 3e4);
+      _hardExit.unref();
+    });
+  }
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+main().catch((err) => {
+  logger.error({ err }, "fatal startup error");
+  process.exit(1);
+});

package/dist/intelligence/action-risk.js

@@ -0,0 +1,132 @@
+const RESTART_PATTERNS = [
+  /\bpm2\s+(restart|reload|gracefulReload)\b/i,
+  /\bkubectl\s+rollout\s+restart\b/i,
+  /\bsystemctl\s+(restart|reload|try-restart)\b/i,
+  /\bservice\s+\S+\s+(restart|reload)\b/i,
+  /\bdocker\s+(restart|stop\s+.*&&\s*docker\s+start)\b/i,
+  /\bsupervisorctl\s+(restart|reload|reread|update)\b/i,
+  /\bnginx\s+-s\s+(reload|reopen)\b/i,
+  /\bapache2ctl\s+graceful\b/i,
+  /\bkill\s+-(?:HUP|1)\b/i,
+  /\bpkill\s+-(?:HUP|1)\b/i,
+  /\bheroku\s+ps:restart\b/i,
+  /\bflyctl\s+machine\s+restart\b/i,
+  /\brailway\s+redeploy\b/i,
+  /\bgunicorn\s+.*--reload\b/i,
+  /\bunicorn_rails\s+.*-s\s+HUP\b/i
+];
+const DEPLOY_PATTERNS = [
+  ...RESTART_PATTERNS,
+  /\bkubectl\s+rollout\s+undo\b/i,
+  /\bkubectl\s+set\s+image\b/i,
+  /\bkubectl\s+set\s+env\b/i,
+  /\bhelm\s+(upgrade|rollback)\b/i,
+  /\bnpm\s+install\s+\S+@\S+/i,
+  /\bpip\s+install\s+\S+==\S+/i,
+  /\bpip\s+install\s+--upgrade\s+\S+/i,
+  /\byarn\s+add\s+\S+@\S+/i,
+  /\bgem\s+install\s+\S+\s+-v\s+\S+/i,
+  /\bgit\s+checkout\s+\S+\s+--\s+\S+/i,
+  /\bgit\s+revert\s+[a-f0-9]{7}/i,
+  /\baws\s+ecs\s+update-service\b/i,
+  /\bgcloud\s+(app|run)\s+deploy\b/i,
+  /\bgc\s+(app|run)\s+deploy\b/i,
+  /\baz\s+(webapp|containerapp)\s+(restart|update)\b/i,
+  /\bdocker-compose\s+(restart|up\s+--force-recreate)\b/i
+];
+const RISK_TIER_ORDER = {
+  restart: 0,
+  deploy: 1,
+  full: 2
+};
+const LEVEL_ORDER = {
+  restarts: 0,
+  deploys: 1,
+  full: 2
+};
+function classifyCommandRisk(command) {
+  if (RESTART_PATTERNS.some((p) => p.test(command))) return "restart";
+  if (DEPLOY_PATTERNS.some((p) => p.test(command))) return "deploy";
+  return "full";
+}
+function autopilotLevelPermits(command, level) {
+  const risk = classifyCommandRisk(command);
+  return RISK_TIER_ORDER[risk] <= LEVEL_ORDER[level];
+}
+function getAutopilotLevel() {
+  const raw = process.env.MERGEN_AUTOPILOT_LEVEL;
+  if (raw === "restarts" || raw === "deploys" || raw === "full") return raw;
+  return "full";
+}
+function autopilotLevelDescription(level) {
+  switch (level) {
+    case "restarts":
+      return "service restarts and reloads only";
+    case "deploys":
+      return "restarts, rollbacks, and dependency pins";
+    case "full":
+      return "all commands";
+  }
+}
+function analyzeSemanticRisk(command, context) {
+  const lower = command.toLowerCase();
+  const isDBPoolResize = (lower.includes("pool") || lower.includes("max_connections") || lower.includes("db_pool")) && (lower.includes("set") || lower.includes("env") || lower.includes("export") || lower.includes("scale"));
+  if (isDBPoolResize) {
+    const day = context?.service_time?.dayOfWeek ?? (/* @__PURE__ */ new Date()).getUTCDay();
+    const hour = context?.service_time?.hourOfDay ?? (/* @__PURE__ */ new Date()).getUTCHours();
+    if (day === 5 && hour >= 20 && hour <= 24) {
+      return {
+        risk: "high",
+        blocked: true,
+        reason: "Semantic Safety: Database pool resize is unsafe during Friday 20-24 UTC settlement window."
+      };
+    }
+  }
+  const isDestructiveSql = (lower.includes("drop") || lower.includes("truncate")) && (lower.includes("table") || lower.includes("database") || lower.includes("schema"));
+  const isDestructiveFs = lower.includes("rm -rf") && lower.includes("/");
+  const isDestructiveInfra = /terraform\s+destroy|kubectl\s+delete\s+(namespace|cluster)|aws.*delete-cluster/i.test(lower);
+  if (isDestructiveSql || isDestructiveFs || isDestructiveInfra) {
+    let reason;
+    if (isDestructiveSql) {
+      const op = lower.includes("truncate") ? "TRUNCATE" : "DROP";
+      reason = `Blocked: \`${op} TABLE/DATABASE\` is irreversible. Use a reversible migration instead \u2014 rename the table (\`ALTER TABLE ... RENAME TO ..._deprecated\`) or add a soft-delete column, then drop in a separate PR after verifying no references remain.`;
+    } else if (isDestructiveFs) {
+      const match = command.match(/rm\s+-rf\s+(\S+)/i);
+      const path = match?.[1] ?? "/...";
+      reason = `Blocked: \`rm -rf ${path}\` permanently deletes files. Move to a timestamped archive path first (\`mv ${path} ${path}.bak-$(date +%s)\`), verify the archive is correct, then delete.`;
+    } else {
+      const match = command.match(/terraform\s+destroy|kubectl\s+delete\s+\S+|aws\s+\S+delete-cluster\S*/i);
+      const cmd = match?.[0] ?? "infra destroy command";
+      reason = `Blocked: \`${cmd}\` destroys live infrastructure. Use \`terraform plan -destroy\` first to preview blast radius, then require explicit human approval via HITL before executing.`;
+    }
+    return { risk: "high", blocked: true, reason };
+  }
+  const isScale = lower.includes("scale") || lower.includes("replicas") || lower.includes("resize");
+  if (isScale) {
+    return {
+      risk: "medium",
+      blocked: false,
+      reason: "Semantic Safety: Service scaling in progress."
+    };
+  }
+  const tier = classifyCommandRisk(command);
+  if (tier === "deploy") {
+    return {
+      risk: "medium",
+      blocked: false,
+      reason: null
+    };
+  }
+  return {
+    risk: "low",
+    blocked: false,
+    reason: null
+  };
+}
+export {
+  analyzeSemanticRisk,
+  autopilotLevelDescription,
+  autopilotLevelPermits,
+  classifyCommandRisk,
+  getAutopilotLevel
+};

package/dist/intelligence/activity-feed.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "crypto";
+const FEED_SIZE = 200;
+const _feed = [];
+const _sseClients = /* @__PURE__ */ new Set();
+function recordActivity(event) {
+  const full = { id: randomUUID(), timestamp: Date.now(), ...event };
+  _feed.push(full);
+  if (_feed.length > FEED_SIZE) _feed.shift();
+  for (const res of _sseClients) {
+    try {
+      res.write(`data: ${JSON.stringify(full)}
+
+`);
+    } catch {
+      _sseClients.delete(res);
+    }
+  }
+}
+function getRecentActivity(limit = 50) {
+  return _feed.slice(-Math.min(limit, FEED_SIZE)).reverse();
+}
+function subscribeToActivity(res) {
+  _sseClients.add(res);
+  const recent = _feed.slice(-20);
+  for (const ev of recent) {
+    try {
+      res.write(`data: ${JSON.stringify(ev)}
+
+`);
+    } catch {
+      break;
+    }
+  }
+  return () => _sseClients.delete(res);
+}
+export {
+  getRecentActivity,
+  recordActivity,
+  subscribeToActivity
+};