@agent-native/core 0.91.2 → 0.92.0

package/corpus/templates/analytics/app/pages/monitoring/uptime/i18n.ts

@@ -117,7 +117,7 @@ const MESSAGES = {
     sectionResponseChecksHint:
       "Choose which responses count as healthy and add body, header, or latency assertions.",
     sectionAlerting: "Alerting",
-    sectionAlertingHint: "Pick the severity and where alerts are delivered.",
+    sectionAlertingHint: "Choose severity and where alerts go.",
     sectionAdvanced: "Advanced",
     sectionAdvancedHint:
       "Request method, timeout, cooldown, redirects, and pause.",
@@ -165,12 +165,24 @@ const MESSAGES = {
     severityWarning: "Warning",
     severityCritical: "Critical",
     fieldChannels: "Notify via",
-    channelInbox: "Inbox",
+    channelInbox: "In-app inbox",
+    channelInboxHint: "Bell notifications inside Analytics.",
     channelEmail: "Email",
+    channelEmailHint: "Send to specific addresses.",
     channelSlack: "Slack",
+    channelSlackHint: "Post to a Slack incoming webhook.",
     channelWebhook: "Webhook",
+    channelWebhookHint: "POST JSON to any HTTPS endpoint.",
     fieldEmailRecipients: "Email recipients",
     fieldEmailRecipientsPlaceholder: "alerts@example.com, oncall@example.com",
+    fieldSlackWebhookUrl: "Slack webhook URL",
+    fieldSlackWebhookUrlPlaceholder: "https://hooks.slack.com/services/T…/B…/…",
+    fieldSlackWebhookUrlHint:
+      "Paste a Slack Incoming Webhook URL. Leave blank to use the workspace default, if configured.",
+    fieldWebhookUrl: "Webhook URL",
+    fieldWebhookUrlPlaceholder: "https://example.com/hooks/uptime",
+    fieldWebhookUrlHint:
+      "Receives a JSON POST with severity, title, and body. Leave blank to use the workspace default, if configured.",
     fieldCooldown: "Alert cooldown (minutes)",
     fieldEnabled: "Enabled",
     fieldEnabledHint: "Run this monitor on its schedule.",
@@ -188,6 +200,9 @@ const MESSAGES = {
     urlRequired: "Enter an absolute http(s) URL.",
     urlInvalid: "Enter a valid http(s) URL (e.g. https://example.com).",
     channelRequired: "Select at least one alert channel.",
+    emailRecipientsRequired: "Add at least one email recipient.",
+    slackWebhookUrlInvalid: "Enter a valid Slack webhook http(s) URL.",
+    webhookUrlInvalid: "Enter a valid webhook http(s) URL.",
     classRequired: "Select at least one status class.",
     codesRequired: "Enter at least one status code.",
     saved: "Monitor saved.",

package/corpus/templates/analytics/app/pages/monitoring/uptime/types.ts

@@ -61,6 +61,8 @@ export interface MonitorSummary {
   severity: MonitorSeverity;
   channels: string[];
   emailRecipients: string[];
+  slackWebhookUrl: string | null;
+  webhookUrl: string | null;
   cooldownMinutes: number;
   enabled: boolean;
   lastStatus: MonitorStatus | null;
@@ -156,6 +158,8 @@ export interface SaveMonitorInput {
   severity?: MonitorSeverity;
   channels?: string[];
   emailRecipients?: string[];
+  slackWebhookUrl?: string | null;
+  webhookUrl?: string | null;
   cooldownMinutes?: number;
   enabled?: boolean;
 }

package/corpus/templates/analytics/app/pages/sessions/SessionDetailPage.tsx

@@ -156,6 +156,8 @@ type ReplayViewportDimensions = {
 
 const DEFAULT_PLAYER_WIDTH = 1024;
 const DEFAULT_PLAYER_HEIGHT = 640;
+const MIN_REPLAY_DISPLAY_ASPECT_RATIO = 0.45;
+const MAX_REPLAY_DISPLAY_ASPECT_RATIO = 3;
 const DEFAULT_SPEED = 2;
 const SPEED_OPTIONS = [0.5, 1, 2, 4, 8];
 const SKIP_STEP_MS = 5000;
@@ -166,15 +168,12 @@ const REPLAY_CHUNK_UNAVAILABLE_MESSAGE = "Session replay chunk is unavailable";
 const DEFAULT_DEVTOOLS_HEIGHT = 220;
 const MIN_STAGE_HEIGHT_PX = 240;
 const SCRUBBER_MARKER_LIMIT = 500;
-/** Reject Meta/resize frames that produce the ultra-wide ribbon letterbox.
- *  True 21:9 ultrawide is ~2.33; multi-monitor spans and corrupt frames are
- *  usually well above that and collapse the stage after fit-to-scale. */
-const MIN_REPLAY_VIEWPORT_WIDTH = 320;
-const MIN_REPLAY_VIEWPORT_HEIGHT = 240;
-const MAX_REPLAY_ASPECT_RATIO = 2.45;
-const MIN_REPLAY_ASPECT_RATIO = 0.5;
 const TIMELINE_MARKER_LIMIT = 300;
 const TIMELINE_FOLLOW_PAUSE_MS = 4000;
+/** Toast/snackbar noise only — keep insertStyleRules minimal like builder-internal. */
+const SUPPRESS_OVERLAYS_CSS = [
+  "[data-radix-popper-content-wrapper], .Toastify, [class*='toast'], [class*='Toast'], [class*='Snackbar'] { display: none !important; }",
+];
 const SESSION_REPLAY_CONSOLE_EVENT_TAG = "agent-native.console";
 const SESSION_REPLAY_NETWORK_EVENT_TAG = "agent-native.network";
 
@@ -506,10 +505,9 @@ function ReplayPlayer({
   const scrubbingRef = useRef(false);
   const scrubResumePlayingRef = useRef(false);
 
-  const playerWidth =
-    streamedDims?.width ?? initialDims?.width ?? DEFAULT_PLAYER_WIDTH;
-  const playerHeight =
-    streamedDims?.height ?? initialDims?.height ?? DEFAULT_PLAYER_HEIGHT;
+  const displayDims = clampReplayDisplayDimensions(streamedDims ?? initialDims);
+  const playerWidth = displayDims?.width ?? DEFAULT_PLAYER_WIDTH;
+  const playerHeight = displayDims?.height ?? DEFAULT_PLAYER_HEIGHT;
   const skipRanges = useMemo(() => buildIdleSkipRanges(events), [events]);
   const skipRangesRef = useLiveRef(skipRanges);
   const skipInactiveRef = useLiveRef(skipInactive);
@@ -695,33 +693,21 @@ function ReplayPlayer({
       if (cancelled || !stageRootRef.current) return;
 
       stageRootRef.current.innerHTML = "";
-      const frameDims = replayViewportDimensions(replayEvents);
-      const playbackEvents = sanitizeReplayViewportEvents(
-        replayEvents,
-        frameDims ?? {
-          width: DEFAULT_PLAYER_WIDTH,
-          height: DEFAULT_PLAYER_HEIGHT,
-        },
-      );
-      setStreamedDims(frameDims);
-      localReplayer = new Replayer(playbackEvents as any[], {
+      // Match builder-internal: pass events through untouched and let rrweb own
+      // iframe sizing via Meta / ViewportResize. Only use dimensions for CSS
+      // fit-to-stage scaling of the outer wrapper — never rewrite Meta or force
+      // iframe width/height (that mismatches the FullSnapshot DOM and blanks
+      // the stage).
+      setStreamedDims(replayViewportDimensions(replayEvents));
+      localReplayer = new Replayer(replayEvents as any[], {
         root: stageRootRef.current,
         speed: speedRef.current,
         skipInactive: false,
         showWarning: false,
         showDebug: false,
         triggerFocus: false,
-        // Subtle FullStory-style trail behind the visitor cursor. The canvas
-        // is resized alongside the iframe in applyReplayFrameDimensions.
-        mouseTail: {
-          strokeStyle: "rgba(59, 130, 246, 0.35)",
-          lineWidth: 2,
-          duration: 600,
-          lineCap: "round",
-        },
-        insertStyleRules: [
-          "[data-radix-popper-content-wrapper], .Toastify, [class*='toast'], [class*='Toast'] { display: none !important; }",
-        ],
+        mouseTail: false,
+        insertStyleRules: SUPPRESS_OVERLAYS_CSS,
       });
       replayerRef.current = localReplayer;
       const meta = localReplayer.getMetaData?.();
@@ -732,7 +718,6 @@ function ReplayPlayer({
         0,
         Number.isFinite(total) ? total : 0,
       );
-      applyReplayFrameDimensions(localReplayer, frameDims);
       localReplayer.on?.("finish", () => {
         setPlaying(false);
         const finalTime = Number(localReplayer.getCurrentTime?.() ?? total);
@@ -740,21 +725,20 @@ function ReplayPlayer({
       });
       localReplayer.on?.("resize", (payload: unknown) => {
         const dims = payload as { width?: unknown; height?: unknown };
-        const nextDims = normalizeReplayDimensions(dims.width, dims.height);
-        if (nextDims) {
-          applyReplayFrameDimensions(localReplayer, nextDims);
-          revealReplayFrame(localReplayer);
-          setStreamedDims(nextDims);
+        if (
+          typeof dims.width === "number" &&
+          typeof dims.height === "number" &&
+          Number.isFinite(dims.width) &&
+          Number.isFinite(dims.height) &&
+          dims.width > 0 &&
+          dims.height > 0
+        ) {
+          setStreamedDims({
+            width: Math.round(dims.width),
+            height: Math.round(dims.height),
+          });
         }
       });
-      localReplayer.on?.("fullsnapshot-rebuilded", () => {
-        applyReplayFrameDimensions(
-          localReplayer,
-          replayViewportAt(eventsRef.current, currentTimeRef.current) ??
-            frameDims,
-        );
-        revealReplayFrame(localReplayer);
-      });
       updateTime(startAt);
       setStatus("ready");
       try {
@@ -769,14 +753,6 @@ function ReplayPlayer({
         }
         setPlaying(false);
       }
-      window.requestAnimationFrame(() => {
-        applyReplayFrameDimensions(
-          localReplayer,
-          replayViewportAt(eventsRef.current, currentTimeRef.current) ??
-            frameDims,
-        );
-        revealReplayFrame(localReplayer);
-      });
     }
 
     void loadReplay().catch((loadError: any) => {
@@ -2177,9 +2153,8 @@ function hasPlayableReplayEvents(events: unknown[]): boolean {
 export function replayViewportDimensions(
   events: AnyReplayEvent[],
 ): ReplayViewportDimensions | null {
-  // Prefer the most recent sane Meta/ViewportResize frame. Early Meta events
-  // (or corrupt resize payloads) can report absurd aspect ratios that collapse
-  // the stage into an ultra-wide ribbon after fit-to-stage scaling.
+  // Latest Meta / ViewportResize for CSS fit-to-stage only. Never rewrite these
+  // into the event stream — rrweb must keep Meta in sync with the FullSnapshot.
   let best: ReplayViewportDimensions | null = null;
   for (const event of events) {
     const dims = dimensionsFromReplayEvent(event);
@@ -2188,22 +2163,6 @@ export function replayViewportDimensions(
   return best;
 }
 
-export function replayViewportAt(
-  events: AnyReplayEvent[],
-  currentTime: number,
-): ReplayViewportDimensions | null {
-  const startedAt = replayStartedAt(events);
-  let current: ReplayViewportDimensions | null = null;
-  for (const event of events) {
-    const dims = dimensionsFromReplayEvent(event);
-    if (!dims) continue;
-    const offset = Number(event.timestamp ?? 0) - startedAt;
-    if (offset <= currentTime + 50) current = dims;
-    else break;
-  }
-  return current ?? replayViewportDimensions(events);
-}
-
 function dimensionsFromReplayEvent(
   event: AnyReplayEvent,
 ): ReplayViewportDimensions | null {
@@ -2219,12 +2178,7 @@ function dimensionsFromReplayEvent(
   return null;
 }
 
-/**
- * Prefer a sane viewport for the stage. Returns null only when width/height
- * are missing or non-positive. Out-of-range aspect ratios are clamped rather
- * than rejected so genuine wide windows keep their height (and most of their
- * width) instead of collapsing to the default 1024×640 fallback.
- */
+/** Read raw positive finite dimensions; no aspect clamping. */
 export function normalizeReplayDimensions(
   width: unknown,
   height: unknown,
@@ -2239,28 +2193,30 @@ export function normalizeReplayDimensions(
   ) {
     return null;
   }
-  return clampReplayViewport(width, height);
+  return {
+    width: Math.round(width),
+    height: Math.round(height),
+  };
 }
 
-/**
- * Clamp Meta / ViewportResize dimensions into a displayable aspect range.
- * Multi-monitor spans and corrupt frames often report absurd widths; keep the
- * captured height and shrink width (or vice versa) so the DOM still roughly
- * matches the recorded layout.
- */
-export function clampReplayViewport(
-  width: number,
-  height: number,
-): ReplayViewportDimensions {
-  let nextWidth = Math.max(MIN_REPLAY_VIEWPORT_WIDTH, Math.round(width));
-  let nextHeight = Math.max(MIN_REPLAY_VIEWPORT_HEIGHT, Math.round(height));
-  const aspect = nextWidth / nextHeight;
-  if (aspect > MAX_REPLAY_ASPECT_RATIO) {
-    nextWidth = Math.round(nextHeight * MAX_REPLAY_ASPECT_RATIO);
-  } else if (aspect < MIN_REPLAY_ASPECT_RATIO) {
-    nextHeight = Math.round(nextWidth / MIN_REPLAY_ASPECT_RATIO);
+export function clampReplayDisplayDimensions(
+  dims: ReplayViewportDimensions | null,
+): ReplayViewportDimensions | null {
+  if (!dims) return null;
+  const aspect = dims.width / dims.height;
+  if (aspect > MAX_REPLAY_DISPLAY_ASPECT_RATIO) {
+    return {
+      width: Math.round(dims.height * MAX_REPLAY_DISPLAY_ASPECT_RATIO),
+      height: dims.height,
+    };
+  }
+  if (aspect < MIN_REPLAY_DISPLAY_ASPECT_RATIO) {
+    return {
+      width: dims.width,
+      height: Math.round(dims.width / MIN_REPLAY_DISPLAY_ASPECT_RATIO),
+    };
   }
-  return { width: nextWidth, height: nextHeight };
+  return dims;
 }
 
 export function filterReplayMarkers(
@@ -2284,98 +2240,6 @@ export function filterReplayMarkers(
   });
 }
 
-/**
- * Rewrite Meta / ViewportResize frames so rrweb never applies absurd aspect
- * ratios that collapse the stage into an ultra-wide ribbon. Prefer clamping
- * the captured dimensions (preserve height, shrink width) over replacing them
- * with the default fallback, which would misalign the recorded DOM.
- */
-export function sanitizeReplayViewportEvents(
-  events: AnyReplayEvent[],
-  fallback: ReplayViewportDimensions,
-): AnyReplayEvent[] {
-  return events.map((event) => {
-    if (event.type === RRWEB_EVENT_TYPE.Meta && isRecord(event.data)) {
-      return rewriteViewportEventData(event, event.data, fallback);
-    }
-    if (
-      event.type === RRWEB_EVENT_TYPE.IncrementalSnapshot &&
-      event.data?.source === INCREMENTAL_SOURCE.ViewportResize &&
-      isRecord(event.data)
-    ) {
-      return rewriteViewportEventData(event, event.data, fallback);
-    }
-    return event;
-  });
-}
-
-function rewriteViewportEventData(
-  event: AnyReplayEvent,
-  data: AnyRecord,
-  fallback: ReplayViewportDimensions,
-): AnyReplayEvent {
-  const width = data.width;
-  const height = data.height;
-  if (
-    typeof width === "number" &&
-    typeof height === "number" &&
-    Number.isFinite(width) &&
-    Number.isFinite(height) &&
-    width > 0 &&
-    height > 0
-  ) {
-    const clamped = clampReplayViewport(width, height);
-    if (
-      clamped.width === Math.round(width) &&
-      clamped.height === Math.round(height)
-    ) {
-      return event;
-    }
-    return {
-      ...event,
-      data: {
-        ...data,
-        width: clamped.width,
-        height: clamped.height,
-      },
-    };
-  }
-  return {
-    ...event,
-    data: {
-      ...data,
-      width: fallback.width,
-      height: fallback.height,
-    },
-  };
-}
-
-function applyReplayFrameDimensions(
-  replayer: any,
-  dims: ReplayViewportDimensions | null,
-) {
-  const width = dims?.width ?? DEFAULT_PLAYER_WIDTH;
-  const height = dims?.height ?? DEFAULT_PLAYER_HEIGHT;
-  const wrapper = replayer?.wrapper as HTMLElement | undefined;
-  const iframe = replayer?.iframe as HTMLIFrameElement | undefined;
-  const mouseTail = replayer?.mouseTail as HTMLCanvasElement | undefined;
-  for (const element of [wrapper, iframe]) {
-    if (!element) continue;
-    element.style.width = `${width}px`;
-    element.style.height = `${height}px`;
-  }
-  for (const element of [iframe, mouseTail]) {
-    if (!element) continue;
-    element.setAttribute("width", String(width));
-    element.setAttribute("height", String(height));
-  }
-}
-
-function revealReplayFrame(replayer: any) {
-  const iframe = replayer?.iframe as HTMLIFrameElement | undefined;
-  if (iframe) iframe.style.display = "inherit";
-}
-
 function replayStartedAt(events: AnyReplayEvent[]): number {
   const first = events.find((event) =>
     Number.isFinite(Number(event.timestamp)),

package/corpus/templates/analytics/changelog/2026-07-08-dashboard-tables-keep-their-size-while-loading.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Dashboard charts and tables keep their layout steady while loading.

package/corpus/templates/analytics/changelog/2026-07-08-monitoring-uptime-and-errors-tabs-now-clearly-show-which-view-is-active.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Monitoring Uptime and Errors tabs now clearly show which view is active.

package/corpus/templates/analytics/changelog/2026-07-08-session-replay-uses-stock-rrweb-sizing-again-so-recorded.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Session replay uses stock rrweb sizing again so recorded pages reassemble correctly instead of showing a blank stage

package/corpus/templates/analytics/changelog/2026-07-08-sidebar-dashboard-menus-now-open-above-the-dashboard-canvas.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Sidebar dashboard menus now open above the dashboard canvas

package/corpus/templates/analytics/changelog/2026-07-08-uptime-alerting-clarifies-in-app-inbox-vs-email-and-lets-you-paste-slack-or-webhook-urls-per-monitor.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-08
+---
+
+Uptime alerting clarifies in-app inbox vs email and lets you paste Slack or webhook URLs per monitor.

package/corpus/templates/analytics/docs/uptime-monitoring.md

@@ -60,10 +60,12 @@ Each check runs on the server (`server/lib/uptime-monitors.ts`):
 
 - On a transition **into failure**, it opens a `monitor_incidents` row (one per
   continuous failure streak) and calls `notifyWithDelivery` with a clear title
-  and body plus metadata
-  `{ kind: "uptime_monitor", monitorId, url, statusCode, latencyMs, failedAssertions }`.
-  The `inbox` channel is always included; `email`/`slack`/`webhook` are added
-  when configured, and email uses the monitor's `emailRecipients`.
+  and body plus safe inbox metadata
+  `{ kind: "uptime_monitor", monitorId, url, statusCode, latencyMs, failedAssertions, emailRecipients }`.
+  The `inbox` channel is the in-app bell; `email` uses the monitor's
+  `emailRecipients`; `slack` / `webhook` use the monitor's optional
+  delivery-only `slackWebhookUrl` / `webhookUrl` (falling back to workspace
+  `NOTIFICATIONS_SLACK_WEBHOOK_URL` / `NOTIFICATIONS_WEBHOOK_URL` when unset).
 - While an incident is open it will not re-alert. After an incident resolves,
   `cooldownMinutes` suppresses a fresh "down" alert for that window to prevent
   flapping.
@@ -119,13 +121,13 @@ have their schema.
 Every operation is an owner-scoped action, so the agent can create and triage
 monitors from chat exactly like the UI:
 
-| action              | method | what it does                                                                                                                                                        |
-| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `save-monitor`      | POST   | create or update a monitor (name, url, method, interval, timeout, expected status, assertions, redirects, severity, channels, email recipients, cooldown, enabled). |
-| `list-monitors`     | GET    | list monitors with latest status, latency, and 24h/7d uptime %.                                                                                                     |
-| `get-monitor`       | GET    | one monitor plus its recent check results and incidents.                                                                                                            |
-| `delete-monitor`    | POST   | delete a monitor and its results + incidents.                                                                                                                       |
-| `run-monitor-check` | POST   | run one check now, record it, and open/resolve incidents.                                                                                                           |
+| action              | method | what it does                                                                                                                                                                                     |
+| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `save-monitor`      | POST   | create or update a monitor (name, url, method, interval, timeout, expected status, assertions, redirects, severity, channels, email recipients, optional Slack/webhook URLs, cooldown, enabled). |
+| `list-monitors`     | GET    | list monitors with latest status, latency, and 24h/7d uptime %.                                                                                                                                  |
+| `get-monitor`       | GET    | one monitor plus its recent check results and incidents.                                                                                                                                         |
+| `delete-monitor`    | POST   | delete a monitor and its results + incidents.                                                                                                                                                    |
+| `run-monitor-check` | POST   | run one check now, record it, and open/resolve incidents.                                                                                                                                        |
 
 Example prompts:
 

package/corpus/templates/analytics/server/db/schema-monitoring.ts

@@ -70,6 +70,10 @@ export const monitors = table("monitors", {
   channels: text("channels").notNull().default('["inbox"]'),
   /** Email recipients as JSON array of addresses. */
   emailRecipients: text("email_recipients").notNull().default("[]"),
+  /** Optional per-monitor Slack incoming webhook URL (overrides workspace env). */
+  slackWebhookUrl: text("slack_webhook_url"),
+  /** Optional per-monitor generic webhook URL (overrides workspace env). */
+  webhookUrl: text("webhook_url"),
   /** Minutes to suppress repeat alerts while an incident is ongoing. */
   cooldownMinutes: integer("cooldown_minutes").notNull().default(15),
   enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),

package/corpus/templates/analytics/server/lib/uptime-monitors.ts

@@ -101,6 +101,8 @@ export interface MonitorInput {
   severity?: MonitorSeverity;
   channels?: string[];
   emailRecipients?: string[];
+  slackWebhookUrl?: string | null;
+  webhookUrl?: string | null;
   cooldownMinutes?: number;
   enabled?: boolean;
 }
@@ -120,6 +122,8 @@ export interface Monitor {
   severity: MonitorSeverity;
   channels: string[];
   emailRecipients: string[];
+  slackWebhookUrl: string | null;
+  webhookUrl: string | null;
   cooldownMinutes: number;
   enabled: boolean;
   lastStatus: MonitorStatus | null;
@@ -462,11 +466,50 @@ function normalizeEmailRecipients(recipients: string[] | undefined): string[] {
   return normalized;
 }
 
+function normalizeOptionalHttpUrl(
+  value: string | null | undefined,
+  label: string,
+): string | null {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed) return null;
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw badRequest(`${label} must be an absolute http(s) URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw badRequest(`${label} must be an absolute http(s) URL`);
+  }
+  return trimmed;
+}
+
 function ensureInboxChannel(channels: string[]): string[] {
   const normalized = channels.map((c) => c.trim()).filter(Boolean);
   return normalized.includes("inbox") ? normalized : ["inbox", ...normalized];
 }
 
+function monitorNotifyMetadata(monitor: Monitor): Record<string, unknown> {
+  return {
+    kind: "uptime_monitor",
+    monitorId: monitor.id,
+    monitorName: monitor.name,
+    url: monitor.url,
+    emailRecipients: monitor.emailRecipients,
+    requestedChannels: monitor.channels,
+  };
+}
+
+function monitorNotifyDeliveryMetadata(
+  monitor: Monitor,
+): Record<string, string> | undefined {
+  const delivery: Record<string, string> = {};
+  if (monitor.slackWebhookUrl)
+    delivery.slackWebhookUrl = monitor.slackWebhookUrl;
+  if (monitor.webhookUrl) delivery.webhookUrl = monitor.webhookUrl;
+  return Object.keys(delivery).length > 0 ? delivery : undefined;
+}
+
 // ---------------------------------------------------------------------------
 // Pure evaluation core (unit-tested)
 // ---------------------------------------------------------------------------
@@ -891,6 +934,8 @@ function rowToMonitor(row: any): Monitor {
     severity: row.severity === "warning" ? "warning" : "critical",
     channels: safeJsonParse<string[]>(row.channels, ["inbox"]),
     emailRecipients: safeJsonParse<string[]>(row.emailRecipients, []),
+    slackWebhookUrl: row.slackWebhookUrl?.trim() || null,
+    webhookUrl: row.webhookUrl?.trim() || null,
     cooldownMinutes: Number(row.cooldownMinutes ?? 15),
     enabled: row.enabled === true || row.enabled === 1,
     lastStatus: (row.lastStatus ?? null) as MonitorStatus | null,
@@ -1121,6 +1166,11 @@ export async function saveMonitor(
   const severity = input.severity === "warning" ? "warning" : "critical";
   const emailRecipients = normalizeEmailRecipients(input.emailRecipients);
   const channels = normalizeChannels(input.channels, emailRecipients);
+  const slackWebhookUrl = normalizeOptionalHttpUrl(
+    input.slackWebhookUrl,
+    "Slack webhook URL",
+  );
+  const webhookUrl = normalizeOptionalHttpUrl(input.webhookUrl, "Webhook URL");
   const cooldownMinutes = clampInt(input.cooldownMinutes ?? 15, 0, 24 * 60, 15);
   const enabled = input.enabled ?? true;
 
@@ -1138,6 +1188,8 @@ export async function saveMonitor(
     severity,
     channels: JSON.stringify(channels),
     emailRecipients: JSON.stringify(emailRecipients),
+    slackWebhookUrl,
+    webhookUrl,
     cooldownMinutes,
     enabled,
   };
@@ -1440,16 +1492,14 @@ async function notifyMonitorDown(monitor: Monitor, outcome: CheckOutcome) {
       body: `${host} is ${label}${detail}.${latency}`,
       channels: ensureInboxChannel(monitor.channels),
       metadata: {
-        kind: "uptime_monitor",
-        monitorId: monitor.id,
-        monitorName: monitor.name,
-        url: monitor.url,
+        ...monitorNotifyMetadata(monitor),
+        ...(monitorNotifyDeliveryMetadata(monitor)
+          ? { delivery: monitorNotifyDeliveryMetadata(monitor) }
+          : {}),
         status: outcome.status,
         statusCode: outcome.statusCode,
         latencyMs: outcome.latencyMs,
         failedAssertions: outcome.failedAssertions,
-        emailRecipients: monitor.emailRecipients,
-        requestedChannels: monitor.channels,
       },
     },
     { owner: monitor.ownerEmail },
@@ -1475,16 +1525,14 @@ async function notifyMonitorRecovered(
       body: `${host} is back up${downFor ? ` after ${downFor} of downtime` : ""}.${latency}`,
       channels: ensureInboxChannel(monitor.channels),
       metadata: {
-        kind: "uptime_monitor",
-        monitorId: monitor.id,
-        monitorName: monitor.name,
-        url: monitor.url,
+        ...monitorNotifyMetadata(monitor),
+        ...(monitorNotifyDeliveryMetadata(monitor)
+          ? { delivery: monitorNotifyDeliveryMetadata(monitor) }
+          : {}),
         status: "up",
         statusCode: outcome.statusCode,
         latencyMs: outcome.latencyMs,
         incidentId: incident.id,
-        emailRecipients: monitor.emailRecipients,
-        requestedChannels: monitor.channels,
       },
     },
     { owner: monitor.ownerEmail },

package/corpus/templates/analytics/server/plugins/db.ts

@@ -1114,6 +1114,16 @@ const runAnalyticsMigrations = runMigrations(
       name: "status-pages-scope-updated-idx",
       sql: `CREATE INDEX IF NOT EXISTS status_pages_scope_updated_idx ON status_pages (owner_email, org_id, updated_at)`,
     },
+    {
+      version: 106,
+      name: "uptime-monitors-slack-webhook-url",
+      sql: `ALTER TABLE monitors ADD COLUMN IF NOT EXISTS slack_webhook_url TEXT`,
+    },
+    {
+      version: 107,
+      name: "uptime-monitors-webhook-url",
+      sql: `ALTER TABLE monitors ADD COLUMN IF NOT EXISTS webhook_url TEXT`,
+    },
   ],
   { table: "analytics_migrations" },
 );