mergen-server 1.4.0

package/dist/intelligence/slack.js

@@ -0,0 +1,900 @@
+import https from "https";
+import crypto from "crypto";
+import { memoryStore } from "../datadog/memory-store.js";
+import { recordVerdict } from "./calibration.js";
+import { getRoutingForService } from "./slack-routing.js";
+import { generateFeedbackToken } from "../sensor/feedback-token.js";
+import { approveExecution, denyExecution } from "./execution-gate.js";
+import { executeRemediation } from "./autonomy.js";
+import { updateShadowReasonByPid } from "./shadow-log.js";
+import { getStores } from "../storage/store-registry.js";
+import logger from "../sensor/logger.js";
+const WEBHOOK = process.env.MERGEN_SLACK_WEBHOOK ?? "";
+const BOT_TOKEN = process.env.MERGEN_SLACK_BOT_TOKEN ?? "";
+const SLACK_CHANNEL = process.env.MERGEN_SLACK_CHANNEL ?? "";
+const _threadByPid = /* @__PURE__ */ new Map();
+function getThread(pid) {
+  return _threadByPid.get(pid);
+}
+async function _slackApiGetOnce(path) {
+  if (!BOT_TOKEN) return null;
+  return new Promise((resolve) => {
+    try {
+      const req = https.request(
+        {
+          hostname: "slack.com",
+          path,
+          method: "GET",
+          headers: { "Authorization": `Bearer ${BOT_TOKEN}` }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk.toString();
+          });
+          res.on("end", () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        logger.warn({ err, path }, "slack: GET request failed");
+        resolve(null);
+      });
+      req.end();
+    } catch (err) {
+      logger.warn({ err, path }, "slack: GET request failed");
+      resolve(null);
+    }
+  });
+}
+async function _slackApiGet(path, maxAttempts = 3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await _slackApiGetOnce(path);
+    if (!result || result.ok !== false) return result;
+    if (result.error && SLACK_NON_RETRYABLE.has(result.error)) {
+      logger.warn({ path, error: result.error }, "slack: permanent GET error \u2014 not retrying");
+      return result;
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, 500 * attempt));
+    }
+  }
+  return null;
+}
+async function fetchSlackThread(threadUrl) {
+  if (!BOT_TOKEN) return null;
+  const match = threadUrl.match(/\/archives\/([A-Z0-9]+)\/p(\d{16})/);
+  if (!match) {
+    logger.warn({ threadUrl }, "slack: could not parse thread URL");
+    return null;
+  }
+  const channel = match[1];
+  const rawTs = match[2];
+  const ts = `${rawTs.slice(0, 10)}.${rawTs.slice(10)}`;
+  const allMessages = [];
+  let cursor;
+  const MAX_PAGES = 5;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const qs = new URLSearchParams({ channel, ts, limit: "100" });
+    if (cursor) qs.set("cursor", cursor);
+    const result = await _slackApiGet(`/api/conversations.replies?${qs.toString()}`);
+    if (!result?.ok || !Array.isArray(result.messages)) {
+      logger.warn({ channel, ts, error: result?.error, page }, "slack: conversations.replies failed");
+      if (page === 0) return null;
+      break;
+    }
+    allMessages.push(...result.messages);
+    if (!result.has_more || !result.response_metadata?.next_cursor) break;
+    cursor = result.response_metadata.next_cursor;
+  }
+  const lines = allMessages.map((msg) => {
+    const time = msg.ts ? new Date(parseFloat(msg.ts) * 1e3).toISOString().slice(11, 16) : "??:??";
+    const user = msg.username ?? msg.bot_profile?.name ?? msg.user ?? "unknown";
+    const text = (msg.text ?? "").slice(0, 500);
+    return `[${time}] @${user}: ${text}`;
+  });
+  return lines.join("\n");
+}
+const _channelIdCache = /* @__PURE__ */ new Map();
+async function _resolveChannelId(nameOrId) {
+  if (!BOT_TOKEN) return null;
+  if (/^[CG][A-Z0-9]{6,}$/i.test(nameOrId)) return nameOrId;
+  const clean = nameOrId.replace(/^#/, "").toLowerCase();
+  if (_channelIdCache.has(clean)) return _channelIdCache.get(clean);
+  let cursor;
+  for (let page = 0; page < 3; page++) {
+    const qs = new URLSearchParams({
+      limit: "200",
+      types: "public_channel,private_channel",
+      exclude_archived: "true",
+      ...cursor ? { cursor } : {}
+    });
+    const result = await _slackApiGet(`/api/conversations.list?${qs.toString()}`);
+    if (!result?.ok || !Array.isArray(result.channels)) break;
+    for (const ch of result.channels) {
+      if (ch.name && ch.id) _channelIdCache.set(ch.name.toLowerCase(), ch.id);
+    }
+    if (!result.response_metadata?.next_cursor) break;
+    cursor = result.response_metadata.next_cursor;
+  }
+  return _channelIdCache.get(clean) ?? null;
+}
+async function fetchIncidentChannelContext(firedAt, windowMs = 20 * 60 * 1e3) {
+  if (!BOT_TOKEN || !SLACK_CHANNEL) return null;
+  const channelId = await _resolveChannelId(SLACK_CHANNEL);
+  if (!channelId) {
+    logger.warn({ channel: SLACK_CHANNEL }, "slack: could not resolve channel ID for context fetch");
+    return null;
+  }
+  const oldest = String((firedAt - 5 * 60 * 1e3) / 1e3);
+  const latest = String((firedAt + windowMs) / 1e3);
+  const qs = new URLSearchParams({ channel: channelId, oldest, latest, limit: "50", inclusive: "true" });
+  const result = await _slackApiGet(`/api/conversations.history?${qs.toString()}`);
+  if (!result?.ok || !Array.isArray(result.messages) || result.messages.length === 0) {
+    if (result?.error) logger.debug({ error: result.error, channel: channelId }, "slack: conversations.history returned error");
+    return null;
+  }
+  const lines = result.messages.map((msg) => {
+    const time = msg.ts ? new Date(parseFloat(msg.ts) * 1e3).toISOString().slice(11, 16) : "??:??";
+    const user = msg.username ?? msg.bot_profile?.name ?? msg.user ?? "unknown";
+    const text = (msg.text ?? "").slice(0, 500);
+    return `[${time}] @${user}: ${text}`;
+  });
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+const SLACK_NON_RETRYABLE = /* @__PURE__ */ new Set([
+  "ratelimited",
+  // handled separately (exponential back-off needed)
+  "channel_not_found",
+  "not_in_channel",
+  "invalid_auth",
+  "token_revoked",
+  "account_inactive",
+  "no_permission"
+]);
+async function _slackApiOnce(path, payload) {
+  if (!BOT_TOKEN) return null;
+  const body = JSON.stringify(payload);
+  return new Promise((resolve) => {
+    try {
+      const req = https.request(
+        {
+          hostname: "slack.com",
+          path,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${BOT_TOKEN}`,
+            "Content-Length": Buffer.byteLength(body)
+          }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk.toString();
+          });
+          res.on("end", () => {
+            try {
+              const parsed = JSON.parse(data);
+              if (!parsed.ok) {
+                logger.warn({ error: parsed.error, path }, "slack: Web API call failed");
+              }
+              resolve(parsed);
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("error", (err) => {
+        logger.warn({ err, path }, "slack: Web API request failed");
+        resolve(null);
+      });
+      req.write(body);
+      req.end();
+    } catch (err) {
+      logger.warn({ err, path }, "slack: failed to post via Web API");
+      resolve(null);
+    }
+  });
+}
+async function _slackApi(path, payload, maxAttempts = 3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await _slackApiOnce(path, payload);
+    if (result?.ok) return result;
+    if (result?.error && SLACK_NON_RETRYABLE.has(result.error)) {
+      logger.warn({ path, error: result.error }, "slack: permanent error \u2014 not retrying");
+      return result;
+    }
+    if (attempt < maxAttempts) {
+      const delayMs = 500 * attempt;
+      logger.debug({ path, attempt, delayMs }, "slack: retrying after transient failure");
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  return null;
+}
+async function _postWebApi(channel, payload, threadTs) {
+  const result = await _slackApi("/api/chat.postMessage", { channel, thread_ts: threadTs, ...payload });
+  return result?.ok && result.ts ? { ts: result.ts } : null;
+}
+async function _openOverrideModal(triggerId, pid) {
+  const view = {
+    type: "modal",
+    callback_id: "override_modal",
+    private_metadata: pid,
+    title: { type: "plain_text", text: "Override Mergen" },
+    submit: { type: "plain_text", text: "Submit Override" },
+    close: { type: "plain_text", text: "Cancel" },
+    blocks: [
+      {
+        type: "input",
+        block_id: "reason_block",
+        element: {
+          type: "static_select",
+          action_id: "reason_select",
+          placeholder: { type: "plain_text", text: "Select a reason..." },
+          options: [
+            { text: { type: "plain_text", text: "Too risky for production" }, value: "too_risky" },
+            { text: { type: "plain_text", text: "Fix is incorrect" }, value: "fix_incorrect" },
+            { text: { type: "plain_text", text: "False positive diagnosis" }, value: "false_positive" },
+            { text: { type: "plain_text", text: "Other / Need manual review" }, value: "other" }
+          ]
+        },
+        label: { type: "plain_text", text: "Why are you overriding this action?" }
+      }
+    ]
+  };
+  await _slackApi("/api/views.open", { trigger_id: triggerId, view });
+}
+async function _openEditCommandModal(triggerId, pid, command) {
+  const view = {
+    type: "modal",
+    callback_id: "edit_command_modal",
+    private_metadata: pid,
+    title: { type: "plain_text", text: "Edit and Execute" },
+    submit: { type: "plain_text", text: "Approve & Run" },
+    close: { type: "plain_text", text: "Cancel" },
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: "Modify the proposed command below before executing it on the target system."
+        }
+      },
+      {
+        type: "input",
+        block_id: "command_block",
+        element: {
+          type: "plain_text_input",
+          action_id: "command_input",
+          initial_value: command,
+          multiline: true
+        },
+        label: { type: "plain_text", text: "Command to Execute" }
+      }
+    ]
+  };
+  await _slackApi("/api/views.open", { trigger_id: triggerId, view });
+}
+async function postThreadReply(pid, text) {
+  const thread = _threadByPid.get(pid);
+  if (!thread) {
+    logger.debug({ pid }, "slack: no thread found for pid \u2014 cannot reply");
+    return false;
+  }
+  const result = await _postWebApi(thread.channel, { text }, thread.ts);
+  return result !== null;
+}
+async function postSimpleWebhookNotification(service, text) {
+  const webhook = _webhookForService(service);
+  if (!webhook) {
+    logger.debug({ service }, "slack: no webhook URL configured for service \u2014 cannot send webhook notification");
+    return;
+  }
+  const payload = JSON.stringify({
+    text,
+    username: "Mergen",
+    icon_emoji: ":robot_face:"
+  });
+  await _postWebhook(payload, webhook);
+}
+async function postThreadBlocks(pid, blocks) {
+  const thread = _threadByPid.get(pid);
+  if (!thread) {
+    logger.debug({ pid }, "slack: no thread for blocks post");
+    return false;
+  }
+  const result = await _postWebApi(thread.channel, { blocks }, thread.ts);
+  return result !== null;
+}
+async function postApprovalRequest(pid, command, tier, remediationConfidence, blastRadius) {
+  const pct = Math.round(remediationConfidence * 100);
+  const tierBadge = tier === "restart" ? "\u{1F504} restart" : tier === "deploy" ? "\u{1F680} deploy" : "\u26A1 full";
+  const blastLines = [];
+  if (blastRadius) {
+    const dt = blastRadius.estimatedDowntimeMs !== null ? `~${Math.round(blastRadius.estimatedDowntimeMs / 1e3)}s` : "unknown";
+    const rev = blastRadius.reversible ? "\u2705 Yes" : "\u274C No";
+    const data = blastRadius.dataAtRisk ? "\u26A0\uFE0F Yes" : "\u274C No";
+    blastLines.push(
+      ``,
+      `*Blast Radius* _(${blastRadius.modelConfidence} model confidence)_`,
+      `\u2022 Scope: \`${blastRadius.scope}\`${blastRadius.affectedResources.length > 0 ? ` \xB7 Resource: \`${blastRadius.affectedResources[0]}\`` : ""}`,
+      `\u2022 Downtime: ${dt} \xB7 Recoverable: ${rev}`,
+      blastRadius.rollbackCommand ? `\u2022 Rollback: \`${blastRadius.rollbackCommand}\`${blastRadius.rollbackLatencyMs ? ` (~${Math.round(blastRadius.rollbackLatencyMs / 1e3)}s)` : ""}` : `\u2022 Rollback: _not available_`,
+      `\u2022 Data at risk: ${data}`
+    );
+  }
+  return postThreadBlocks(pid, [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `\u{1F510} *Mergen Autopilot \u2014 Approval Required*`,
+          `Risk tier: *${tierBadge}* \xB7 Remediation confidence: *${pct}%*`,
+          ``,
+          `*Command to execute:*`,
+          `\`\`\`${command}\`\`\``,
+          ...blastLines,
+          ``,
+          `_Approval window: 15 min. No action = auto-expire._`
+        ].join("\n")
+      }
+    },
+    {
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          action_id: `execute_fix_${pid}`,
+          text: { type: "plain_text", text: "\u2705 Execute", emoji: true },
+          value: JSON.stringify({ pid, command }),
+          style: "primary"
+        },
+        {
+          type: "button",
+          action_id: `edit_fix_trigger_${pid}`,
+          text: { type: "plain_text", text: "\u270F\uFE0F Edit & Execute", emoji: true },
+          value: JSON.stringify({ pid, command })
+        },
+        {
+          type: "button",
+          action_id: `deny_fix_${pid}`,
+          text: { type: "plain_text", text: "\u274C Deny", emoji: true },
+          value: JSON.stringify({ pid }),
+          style: "danger"
+        }
+      ]
+    }
+  ]);
+}
+const SIGNING_SECRET = process.env.MERGEN_SLACK_SIGNING_SECRET ?? "";
+const COOLDOWN = 5 * 60 * 1e3;
+const MIN_CONFIDENCE = 0.75;
+const isInteractive = !!BOT_TOKEN && !!SIGNING_SECRET;
+const _lastAlertAt = /* @__PURE__ */ new Map();
+function _webhookForService(service) {
+  if (service) {
+    const rule = getRoutingForService(service);
+    if (rule?.webhook) return rule.webhook;
+  }
+  return WEBHOOK;
+}
+function _minConfidenceForService(service) {
+  if (service) {
+    const rule = getRoutingForService(service);
+    if (typeof rule?.minConfidence === "number") return rule.minConfidence;
+  }
+  return MIN_CONFIDENCE;
+}
+function shouldAlert(hyp, service) {
+  const webhook = _webhookForService(service);
+  if (!webhook) return false;
+  if ((hyp.confidenceScore ?? 0) < _minConfidenceForService(service)) return false;
+  const last = _lastAlertAt.get(hyp.tag) ?? 0;
+  return Date.now() - last > COOLDOWN;
+}
+async function postSlackAlert(hyp, context = {}) {
+  const webhook = _webhookForService(context.service);
+  if (!webhook || !shouldAlert(hyp, context.service)) return;
+  _lastAlertAt.set(hyp.tag, Date.now());
+  const routingRule = context.service ? getRoutingForService(context.service) : null;
+  const escalate = routingRule?.escalateAt != null && routingRule.oncallMention && (hyp.confidenceScore ?? 0) >= routingRule.escalateAt;
+  const pct = Math.round((hyp.confidenceScore ?? 0) * 100);
+  const color = pct >= 85 ? "#d32f2f" : "#f57c00";
+  const metaParts = [];
+  if (context.sha) metaParts.push(`Commit: \`${context.sha.slice(0, 7)}\``);
+  if (context.branch) metaParts.push(`Branch: \`${context.branch}\``);
+  if (context.environment) metaParts.push(`Env: \`${context.environment}\``);
+  if (context.owners?.length) metaParts.push(`Owners: ${context.owners.join(" ")}`);
+  const blocks = [
+    {
+      type: "header",
+      text: { type: "plain_text", text: `\u{1F534} Mergen Causal Alert`, emoji: true }
+    },
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `*${hyp.summary}*` }
+    },
+    ...metaParts.length ? [{
+      type: "section",
+      text: { type: "mrkdwn", text: metaParts.join("  |  ") }
+    }] : [],
+    ...hyp.fixHint ? [{
+      type: "section",
+      text: { type: "mrkdwn", text: `\u{1F4A1} *Fix:* ${hyp.fixHint}` }
+    }] : [],
+    ...hyp.evidence?.length ? [{
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Evidence:*
+${hyp.evidence.slice(0, 3).map((e) => `\u2022 ${e}`).join("\n")}`
+      }
+    }] : [],
+    ...escalate && routingRule?.oncallMention ? [{
+      type: "section",
+      text: { type: "mrkdwn", text: `\u{1F6A8} *Escalation:* ${routingRule.oncallMention} \u2014 confidence above threshold` }
+    }] : [],
+    {
+      type: "context",
+      elements: [{ type: "mrkdwn", text: `Detector: \`${hyp.tag}\`${context.service ? ` \xB7 ${context.service}` : ""} \xB7 Mergen` }]
+    },
+    // Action buttons — feedback + dashboard link
+    {
+      type: "actions",
+      elements: [
+        ...context.dashboardUrl ? [{
+          type: "button",
+          text: { type: "plain_text", text: "\u{1F5C2} View Timeline", emoji: true },
+          url: context.dashboardUrl,
+          style: "primary"
+        }] : [],
+        // Feedback buttons: interactive if bot token is set, link-based otherwise
+        ...hyp.pid ? isInteractive ? [
+          {
+            type: "button",
+            action_id: `shadow_approve_${hyp.pid}`,
+            text: { type: "plain_text", text: "\u2705 Approve Fix", emoji: true },
+            value: JSON.stringify({ pid: hyp.pid, verdict: "would-approve" }),
+            style: "primary"
+          },
+          {
+            type: "button",
+            action_id: `shadow_override_${hyp.pid}`,
+            text: { type: "plain_text", text: "\u270B Override", emoji: true },
+            value: JSON.stringify({ pid: hyp.pid, verdict: "would-override" }),
+            style: "danger"
+          }
+        ] : context.dashboardUrl ? [
+          {
+            type: "button",
+            text: { type: "plain_text", text: "\u2705 Approve Fix", emoji: true },
+            url: `${context.dashboardUrl}/feedback?pid=${encodeURIComponent(hyp.pid)}&verdict=would-approve`
+          },
+          {
+            type: "button",
+            text: { type: "plain_text", text: "\u270B Override", emoji: true },
+            url: `${context.dashboardUrl}/feedback?pid=${encodeURIComponent(hyp.pid)}&verdict=would-override`
+          }
+        ] : [] : []
+      ]
+    }
+  ];
+  const payload = JSON.stringify({ attachments: [{ color, blocks }] });
+  return _postWebhook(payload, webhook);
+}
+async function postIncidentAlert(opts) {
+  const webhook = _webhookForService(opts.service);
+  const channel = getRoutingForService(opts.service)?.channel ?? SLACK_CHANNEL;
+  if (!webhook && !(BOT_TOKEN && channel)) return;
+  const routingRule = getRoutingForService(opts.service);
+  const { alertTitle, service, firedAt, incidentId, pdUrl, blame, blastRadius, dashboardUrl } = opts;
+  const ageMin = Math.round((Date.now() - firedAt) / 6e4);
+  const ageTxt = ageMin < 2 ? "just now" : `${ageMin}m ago`;
+  const blocks = [
+    {
+      type: "header",
+      text: { type: "plain_text", text: `\u{1F6A8} Production Incident \u2014 ${service}`, emoji: true }
+    },
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `*${alertTitle}*
+Fired *${ageTxt}*${pdUrl ? `  |  <${pdUrl}|PagerDuty>` : ""}` }
+    }
+  ];
+  if (blame?.topCandidate) {
+    const sha8 = blame.topCandidate.sha.slice(0, 8);
+    const pct = Math.round(blame.confidence * 100);
+    const label = blame.confidenceLabel;
+    const color2 = label === "HIGH" ? "\u2705" : label === "MEDIUM" ? "\u26A0\uFE0F" : "\u2753";
+    const signals = [blame.signals.timing, blame.signals.shaMatch, blame.signals.fileOverlap].filter((s) => s.available && s.score > 0).map((s) => `\u2022 ${s.detail.slice(0, 80)}`);
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `*${color2} Causal Attribution \u2014 ${pct}% [${label}]*`,
+          `Deploy \`${sha8}\` \u2022 ${blame.topCandidate.environment}`,
+          ...signals.slice(0, 3),
+          blame.lowConfidence ? "_\u26A0\uFE0F Below confidence threshold \u2014 manual investigation recommended_" : ""
+        ].filter(Boolean).join("\n")
+      }
+    });
+  } else {
+    blocks.push({
+      type: "section",
+      text: { type: "mrkdwn", text: "_Attribution pending \u2014 no deploy events found. Post deployments to `/deployments` or connect CI._" }
+    });
+  }
+  if (blastRadius && blastRadius.errorCount > 0) {
+    const sessions = blastRadius.affectedSessions > 0 ? `*${blastRadius.affectedSessions}* session${blastRadius.affectedSessions !== 1 ? "s" : ""} affected` : `*${blastRadius.errorCount}* error events`;
+    const users = blastRadius.affectedUsers > 0 ? ` (${blastRadius.affectedUsers} authenticated users)` : "";
+    const browsers = Object.entries(blastRadius.browserSegments).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([b, n]) => `${b}: ${n}`).join(" | ");
+    const durationTxt = blastRadius.durationMs ? ` \u2022 Active *${_fmtDuration(blastRadius.durationMs)}*` : "";
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `*\u{1F4CA} Blast Radius*`,
+          `${sessions}${users}${durationTxt}`,
+          browsers ? `Browsers: ${browsers}` : ""
+        ].filter(Boolean).join("\n")
+      }
+    });
+  }
+  const actions = [];
+  if (dashboardUrl) {
+    actions.push({
+      type: "button",
+      text: { type: "plain_text", text: "\u{1F5C2} War Room", emoji: true },
+      url: `${dashboardUrl}#war-room`,
+      style: "primary"
+    });
+  }
+  if (incidentId != null && blame?.topCandidate && isInteractive) {
+    actions.push(
+      {
+        type: "button",
+        action_id: `inc_attr_correct_${incidentId}`,
+        text: { type: "plain_text", text: "\u2705 Attribution Correct", emoji: true },
+        value: String(incidentId),
+        style: "primary"
+      },
+      {
+        type: "button",
+        action_id: `inc_attr_wrong_${incidentId}`,
+        text: { type: "plain_text", text: "\u274C Wrong", emoji: true },
+        value: String(incidentId),
+        style: "danger"
+      }
+    );
+  } else if (incidentId != null && blame?.topCandidate && dashboardUrl) {
+    const tokenCorrect = generateFeedbackToken(incidentId, 1);
+    const tokenWrong = generateFeedbackToken(incidentId, 0);
+    actions.push(
+      {
+        type: "button",
+        text: { type: "plain_text", text: "\u2705 Attribution Correct", emoji: true },
+        url: `${dashboardUrl}/attribution-feedback?id=${incidentId}&correct=1&token=${tokenCorrect}`
+      },
+      {
+        type: "button",
+        text: { type: "plain_text", text: "\u274C Wrong", emoji: true },
+        url: `${dashboardUrl}/attribution-feedback?id=${incidentId}&correct=0&token=${tokenWrong}`
+      }
+    );
+  }
+  if (actions.length > 0) {
+    blocks.push({ type: "actions", elements: actions });
+  }
+  if (routingRule?.escalateAt != null && routingRule.oncallMention) {
+    blocks.push({
+      type: "section",
+      text: { type: "mrkdwn", text: `\u{1F6A8} ${routingRule.oncallMention} \u2014 production incident requires attention` }
+    });
+  }
+  const briefLink = opts.pid ? `  \xB7  <${dashboardUrl ?? "http://127.0.0.1:3000"}/incidents/${opts.pid}/brief|View brief>` : "";
+  blocks.push({
+    type: "context",
+    elements: [{ type: "mrkdwn", text: `Mergen \xB7 ${service} \xB7 <${dashboardUrl ?? "http://127.0.0.1:3000"}/dashboard|Dashboard>${briefLink}` }]
+  });
+  const color = blame?.confidenceLabel === "HIGH" ? "#d32f2f" : blame?.confidenceLabel === "MEDIUM" ? "#f57c00" : "#64748b";
+  if (BOT_TOKEN && channel) {
+    const result = await _postWebApi(channel, { attachments: [{ color, blocks }] });
+    if (result?.ts && opts.pid) {
+      _threadByPid.set(opts.pid, { channel, ts: result.ts });
+      logger.info({ pid: opts.pid, ts: result.ts, channel }, "slack: thread registered for autonomous replies");
+    }
+    return;
+  }
+  return _postWebhook(JSON.stringify({ attachments: [{ color, blocks }] }), webhook);
+}
+function _fmtDuration(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m`;
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
+function _postWebhook(payload, webhookUrl = WEBHOOK) {
+  return new Promise((resolve) => {
+    try {
+      const url = new URL(webhookUrl);
+      const req = https.request(
+        {
+          hostname: url.hostname,
+          path: url.pathname + url.search,
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) }
+        },
+        (res) => {
+          res.resume();
+          resolve();
+        }
+      );
+      req.on("error", (err) => {
+        logger.warn({ err }, "slack: webhook post failed");
+        resolve();
+      });
+      req.write(payload);
+      req.end();
+    } catch (err) {
+      logger.warn({ err }, "slack: failed to post");
+      resolve();
+    }
+  });
+}
+function verifySlackSignature(req) {
+  if (!SIGNING_SECRET) return false;
+  try {
+    const ts = req.headers["x-slack-request-timestamp"];
+    const sig = req.headers["x-slack-signature"];
+    if (!ts || !sig) return false;
+    if (Math.abs(Date.now() / 1e3 - Number(ts)) > 300) return false;
+    const body = req.rawBody?.toString("utf8") ?? "";
+    const hmac = crypto.createHmac("sha256", SIGNING_SECRET);
+    const computed = "v0=" + hmac.update(`v0:${ts}:${body}`).digest("hex");
+    return crypto.timingSafeEqual(Buffer.from(computed), Buffer.from(sig));
+  } catch {
+    return false;
+  }
+}
+async function handleSlackActions(req, res) {
+  if (!verifySlackSignature(req)) {
+    res.status(401).send("Unauthorized");
+    return;
+  }
+  try {
+    const body = req.body;
+    const payload = JSON.parse(body.payload ?? "{}");
+    if (payload.type === "view_submission" && payload.view?.callback_id === "edit_command_modal") {
+      const pid = payload.view.private_metadata;
+      const values = payload.view.state.values;
+      const commandBlock = values["command_block"];
+      const commandInput = commandBlock ? commandBlock["command_input"] : null;
+      const modifiedCommand = commandInput?.value ?? "";
+      if (!modifiedCommand.trim()) {
+        res.status(200).json({
+          response_action: "errors",
+          errors: { command_block: "Command cannot be empty." }
+        });
+        return;
+      }
+      const userId = payload.user?.id ?? "slack-user";
+      const record = approveExecution(pid);
+      if (record) {
+        logger.info({ pid, originalCommand: record.command, modifiedCommand, userId }, "slack: fix execution approved with edits");
+        void postThreadReply(pid, `\u2699\uFE0F _Fix approved with edits by <@${userId}> \u2014 executing\u2026_
+\`${modifiedCommand}\``);
+        void executeRemediation(modifiedCommand, { cwd: record.cwd, actor: userId }).then((result) => {
+          if (result.blocked) {
+            void postThreadReply(pid, `\u{1F6AB} *Fix blocked by safety filter:* ${result.blockReason}`);
+            updateShadowReasonByPid(pid, "blocked-by-safety-filter");
+          } else if (!result.ok) {
+            void postThreadReply(pid, `\u274C *Fix command failed* (exit ${result.exitCode})
+${result.stderr.slice(0, 500)}`);
+            updateShadowReasonByPid(pid, "executed-failure");
+          } else {
+            void postThreadReply(pid, `\u2705 *Fix executed* (${result.durationMs}ms)`);
+            updateShadowReasonByPid(pid, "executed");
+          }
+        });
+      }
+      res.status(200).send("");
+      return;
+    }
+    if (payload.type === "view_submission" && payload.view?.callback_id === "override_modal") {
+      const rawMeta = payload.view.private_metadata;
+      const values = payload.view.state.values;
+      const reasonBlock = values["reason_block"];
+      const reasonSelect = reasonBlock ? reasonBlock["reason_select"] : null;
+      const selectedReason = reasonSelect?.selected_option?.value ?? "other";
+      const REASON_MAP = {
+        too_risky: "on-call-discretion",
+        fix_incorrect: "wrong-fix",
+        false_positive: "wrong-diagnosis",
+        other: "other"
+      };
+      const corpusReason = REASON_MAP[selectedReason] ?? "other";
+      if (rawMeta.startsWith("shadow:")) {
+        const shadowId = rawMeta.slice(7);
+        const result = await getStores().shadowLog.recordShadowVerdict(shadowId, "would-override", {
+          overrideReason: corpusReason,
+          note: selectedReason,
+          actor: "slack-user"
+        });
+        if (result.found) recordVerdict(result.entry.pid, "wrong", selectedReason);
+        logger.info({ shadowId, reason: corpusReason }, "slack: digest override modal submitted");
+      } else {
+        const pid = rawMeta;
+        await getStores().overrides.recordOverride({
+          incidentTag: pid,
+          proposedCommand: "unknown",
+          overrideReason: corpusReason,
+          service: "unknown",
+          environment: process.env.NODE_ENV ?? "production",
+          actor: "slack-user"
+        });
+        recordVerdict(pid, "wrong", selectedReason);
+        logger.info({ pid, reason: corpusReason }, "slack: override persisted to corpus");
+      }
+      res.status(200).send("");
+      return;
+    }
+    for (const action of payload.actions ?? []) {
+      if (action.action_id.startsWith("shadow_approve_")) {
+        try {
+          const { pid, verdict } = JSON.parse(action.value);
+          recordVerdict(pid, "correct");
+          logger.info({ pid, verdict }, "slack: shadow approval submitted");
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to parse action value");
+        }
+      }
+      if (action.action_id.startsWith("shadow_override_") && payload.trigger_id) {
+        try {
+          const { pid } = JSON.parse(action.value);
+          await _openOverrideModal(payload.trigger_id, pid);
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to open override modal");
+        }
+      }
+      if (action.action_id.startsWith("digest_approve_")) {
+        try {
+          const { id } = JSON.parse(action.value);
+          const result = await getStores().shadowLog.recordShadowVerdict(id, "would-approve", {});
+          if (result.found) recordVerdict(result.entry.pid, "correct");
+          logger.info({ id }, "slack: digest approval recorded");
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to record digest approval");
+        }
+      }
+      if (action.action_id.startsWith("digest_override_")) {
+        try {
+          const { id } = JSON.parse(action.value);
+          if (payload.trigger_id) {
+            await _openOverrideModal(payload.trigger_id, `shadow:${id}`);
+          } else {
+            const result = await getStores().shadowLog.recordShadowVerdict(id, "would-override", { overrideReason: "on-call-discretion" });
+            if (result.found) recordVerdict(result.entry.pid, "wrong");
+            logger.info({ id }, "slack: digest override recorded (no trigger_id \u2014 no modal)");
+          }
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to record digest override");
+        }
+      }
+      if (action.action_id.startsWith("feedback_")) {
+        try {
+          const { pid, verdict } = JSON.parse(action.value);
+          recordVerdict(pid, verdict);
+          logger.info({ pid, verdict }, "slack: feedback submitted via button");
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to parse action value");
+        }
+      }
+      if (action.action_id.startsWith("inc_attr_correct_") || action.action_id.startsWith("inc_attr_wrong_")) {
+        const correct = action.action_id.startsWith("inc_attr_correct_");
+        const id = parseInt(action.value, 10);
+        if (!isNaN(id)) {
+          memoryStore.recordAttributionFeedback(id, correct ? 1 : 0);
+          logger.info({ id, correct }, "slack: attribution feedback via button");
+        }
+      }
+      if (action.action_id.startsWith("execute_fix_")) {
+        try {
+          const { pid } = JSON.parse(action.value);
+          const userId = payload.user?.id ?? "slack-user";
+          const record = approveExecution(pid);
+          if (record) {
+            logger.info({ pid, command: record.command, userId }, "slack: fix execution approved");
+            void postThreadReply(pid, `\u2699\uFE0F _Fix approved by <@${userId}> \u2014 executing\u2026_
+\`${record.command}\``);
+            void executeRemediation(record.command, { cwd: record.cwd, actor: userId }).then((result) => {
+              if (result.blocked) {
+                void postThreadReply(pid, `\u{1F6AB} *Fix blocked by safety filter:* ${result.blockReason}`);
+                updateShadowReasonByPid(pid, "blocked-by-safety-filter");
+              } else if (!result.ok) {
+                void postThreadReply(pid, `\u274C *Fix command failed* (exit ${result.exitCode})
+${result.stderr.slice(0, 500)}`);
+                updateShadowReasonByPid(pid, "executed-failure");
+              } else {
+                void postThreadReply(pid, `\u2705 *Fix executed* (${result.durationMs}ms)`);
+                updateShadowReasonByPid(pid, "executed");
+              }
+            });
+          }
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to handle execute_fix action");
+        }
+      }
+      if (action.action_id.startsWith("edit_fix_trigger_") && payload.trigger_id) {
+        try {
+          const { pid, command } = JSON.parse(action.value);
+          await _openEditCommandModal(payload.trigger_id, pid, command);
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to open edit command modal");
+        }
+      }
+      if (action.action_id.startsWith("deny_fix_")) {
+        try {
+          const { pid } = JSON.parse(action.value);
+          const userId = payload.user?.id ?? "slack-user";
+          if (denyExecution(pid)) {
+            recordVerdict(pid, "wrong", "denied via Slack");
+            void postThreadReply(pid, `\u{1F6AB} _Fix execution denied by <@${userId}>._`);
+            logger.info({ pid, userId }, "slack: fix execution denied");
+            updateShadowReasonByPid(pid, "denied");
+          }
+        } catch (err) {
+          logger.warn({ err, action }, "slack: failed to handle deny_fix action");
+        }
+      }
+    }
+    res.status(200).send("");
+  } catch (err) {
+    logger.warn({ err }, "slack: actions handler error");
+    res.status(200).send("");
+  }
+}
+async function handleFeedbackLink(req, res) {
+  const { pid, verdict } = req.query;
+  if (!pid || !verdict) {
+    res.status(400).send("Missing pid or verdict");
+    return;
+  }
+  try {
+    recordVerdict(pid, verdict);
+    logger.info({ pid, verdict }, "feedback submitted via link");
+    res.send(`<!DOCTYPE html><html><head><title>Mergen Feedback</title></head><body style="font-family:system-ui;text-align:center;padding:60px">
+      <h2>${verdict === "correct" ? "\u2705" : "\u274C"} Feedback recorded</h2>
+      <p style="color:#666">Thank you. Mergen's accuracy will improve over time.</p>
+      <p style="margin-top:20px"><a href="/dashboard">Back to dashboard</a></p>
+    </body></html>`);
+  } catch (err) {
+    logger.warn({ err, pid, verdict }, "feedback link handler error");
+    res.status(500).send("Error recording feedback");
+  }
+}
+export {
+  fetchIncidentChannelContext,
+  fetchSlackThread,
+  getThread,
+  handleFeedbackLink,
+  handleSlackActions,
+  isInteractive,
+  postApprovalRequest,
+  postIncidentAlert,
+  postSimpleWebhookNotification,
+  postSlackAlert,
+  postThreadBlocks,
+  postThreadReply,
+  shouldAlert,
+  verifySlackSignature
+};