@debugbundle/mcp 1.4.0 → 1.5.1

package/dist/main.cjs

@@ -16484,6 +16484,113 @@ function createWeeklyReportApi(client) {
 var import_promises2 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 
+// ../../packages/shared-types/src/tier-capabilities.ts
+var TIER_CAPABILITIES = {
+  free: {
+    remote_probes: false,
+    github_automation: false,
+    slack_integration: false,
+    cloud_improvement_bundles: false,
+    shared_dashboards: false,
+    member_invites: false,
+    included_capacity_units: 1,
+    max_members: 1,
+    ingestion_rate_per_min: 1e3,
+    retrieval_rate_per_min: 100,
+    bundle_retention_days: 7,
+    raw_event_retention_days: 7,
+    // Allowance buckets (account-level pool, not per capacity unit)
+    monthly_bundle_requests: 100,
+    monthly_raw_ingested_events: 750,
+    retained_bundle_cap: 50,
+    monthly_remote_activations: 0,
+    monthly_alert_deliveries: 25,
+    monthly_webhook_deliveries: 100,
+    availability_checks_per_project: 1,
+    availability_check_min_interval_seconds: 300
+  },
+  solo: {
+    remote_probes: true,
+    github_automation: true,
+    slack_integration: false,
+    cloud_improvement_bundles: true,
+    shared_dashboards: false,
+    member_invites: false,
+    included_capacity_units: 3,
+    max_members: 1,
+    ingestion_rate_per_min: 5e3,
+    retrieval_rate_per_min: 300,
+    bundle_retention_days: 30,
+    raw_event_retention_days: 14,
+    // Per-unit allowance (multiply by included and purchased capacity units)
+    monthly_bundle_requests: 250,
+    monthly_raw_ingested_events: 3500,
+    retained_bundle_cap: 150,
+    monthly_remote_activations: 25,
+    monthly_alert_deliveries: 75,
+    monthly_webhook_deliveries: 250,
+    availability_checks_per_project: 5,
+    availability_check_min_interval_seconds: 60
+  },
+  team: {
+    remote_probes: true,
+    github_automation: true,
+    slack_integration: true,
+    cloud_improvement_bundles: true,
+    shared_dashboards: true,
+    member_invites: true,
+    included_capacity_units: 15,
+    max_members: 1e3,
+    ingestion_rate_per_min: 1e4,
+    retrieval_rate_per_min: 500,
+    bundle_retention_days: 90,
+    raw_event_retention_days: 30,
+    // Per-unit allowance (multiply by included and purchased capacity units)
+    monthly_bundle_requests: 1e3,
+    monthly_raw_ingested_events: 1e4,
+    retained_bundle_cap: 400,
+    monthly_remote_activations: 50,
+    monthly_alert_deliveries: 300,
+    monthly_webhook_deliveries: 1e3,
+    availability_checks_per_project: 25,
+    availability_check_min_interval_seconds: 30
+  }
+};
+var SELFHOST_CAPABILITIES = {
+  remote_probes: true,
+  github_automation: true,
+  slack_integration: true,
+  cloud_improvement_bundles: true,
+  shared_dashboards: true,
+  member_invites: true,
+  included_capacity_units: 1e6,
+  max_members: 1e3,
+  ingestion_rate_per_min: 1e6,
+  retrieval_rate_per_min: 1e5,
+  bundle_retention_days: 36500,
+  raw_event_retention_days: 36500,
+  monthly_bundle_requests: 1e9,
+  monthly_raw_ingested_events: 1e9,
+  retained_bundle_cap: 1e6,
+  monthly_remote_activations: 1e6,
+  monthly_alert_deliveries: 1e6,
+  monthly_webhook_deliveries: 1e6,
+  availability_checks_per_project: 1e6,
+  availability_check_min_interval_seconds: 30
+};
+function isSelfHostMode() {
+  return typeof process !== "undefined" && process.env["SELFHOST_MODE"] === "true";
+}
+function getTierCapabilities(plan) {
+  if (isSelfHostMode()) {
+    return SELFHOST_CAPABILITIES;
+  }
+  if (plan !== void 0 && plan in TIER_CAPABILITIES) {
+    return TIER_CAPABILITIES[plan];
+  }
+  return TIER_CAPABILITIES.free;
+}
+
 // ../../packages/shared-types/src/capture-policy.ts
 var EventClassValues = [
   "incident_signal",
@@ -16729,6 +16836,7 @@ function isRouteOnlyExternalProbe(normalizedRoute) {
     "/__debug__/render_panel",
     "/actuator",
     "/autodiscover/autodiscover.json",
+    "/containers/json",
     "/developmentserver/metadatauploader",
     "/cpanel",
     "/favicon.ico",
@@ -17841,8 +17949,10 @@ function buildSkill() {
     "name: debugbundle",
     "description: >-",
     "  Investigate runtime incidents, inspect debug bundles, generate reproductions,",
-    "  and run improvement analysis using the DebugBundle CLI and local project scaffold.",
-    "  Use when the user reports a bug, runtime failure, or asks about production incidents.",
+    "  run improvement analysis, and inspect operational controls using the DebugBundle",
+    "  CLI and local project scaffold. Use when the user reports a bug, runtime",
+    "  failure, production incident, endpoint downtime, health-check issue, missing",
+    "  notification, webhook delivery failure, probe request, or noisy incident.",
     "metadata:",
     "  author: debugbundle",
     '  version: "1.0"',
@@ -17880,6 +17990,24 @@ function buildSkill() {
     "4. Apply the narrowest fix, then validate it with the repository test workflow from `.debugbundle/profile.json`.",
     "5. When the fix is confirmed, or when the incident was intentionally generated for smoke, verification, or dogfooding, resolve it with `debugbundle resolve <incident-id> [incident-id ...]` or MCP `resolve_incident` / `resolve_incidents` so the open queue stays actionable.",
     "",
+    "## Investigation Controls",
+    "",
+    "Use these controls when the user's issue is about observability behavior, notification delivery, targeted evidence gathering, or event noise rather than only application code.",
+    "",
+    "- Availability checks: use hosted health checks for endpoint downtime, public reachability, or project Health tab issues. These are DebugBundle-run external `GET`/`HEAD` checks, not SDK events from the customer app.",
+    "- Probes: inspect active probes with `debugbundle probe list <project-id> --json` or MCP `list_active_probes` before activating more probes. Activate probes only when targeted runtime evidence is needed and the user has asked for investigation.",
+    "- Capture policy and rules: inspect policy/rules before suppressing noisy incidents. Prefer `debugbundle capture-rule suggest <incident-id> --json` and narrow capture-policy path rules over broad drops or demotions.",
+    "- Alerts and webhooks: when the user reports missing, duplicate, or failed notifications, inspect alert config, webhook config, and webhook delivery history before changing application code.",
+    "",
+    "## Availability Checks",
+    "",
+    "- Start with `debugbundle health checks list --project-id <id> --json` or MCP `list_health_checks` to inspect saved checks and plan limits.",
+    "- For a failing check, inspect `debugbundle health checks results <check-id> --project-id <id> --json` and `debugbundle health checks daily-rollups <check-id> --project-id <id> --json` before changing code.",
+    "- Use `debugbundle health checks test --project-id <id> --url <url> --json` or MCP `test_health_check` before creating or updating a saved check. Tests are side-effect-free: no incidents, retained history rows, or counters.",
+    "- Create, update, delete, enable, or disable checks only when the user explicitly asks to change monitoring.",
+    "- Availability incidents reuse the normal incident lifecycle. If a check opened an incident, fetch the incident context, bundle, and reproduction before proposing a fix, then resolve only after the endpoint recovers or the intentional verification incident has served its purpose.",
+    "- Do not configure private, localhost, metadata-service, credentialed, or state-mutating targets. V1 health-check targets must be external `http`/`https` URLs on safe ports.",
+    "",
     "## Incident Hygiene",
     "",
     "- Treat `open` as actionable work, not historical record.",
@@ -17896,6 +18024,25 @@ function buildSkill() {
     "- Scope frontend noise by structured evidence such as service, environment, `browser_event_kind`, `browser_event_opaque`, `client_kind`, `bot_family`, and message fields. Do not broadly demote generic `Unhandled promise rejection` incidents without bot-scoped or otherwise narrow evidence.",
     "- For expected or intentionally promoted 4xx responses on known routes, use capture-policy client-error path rules instead of promoting all client errors: `debugbundle capture-policy set --client-error-path-rule <status=/path/*@GET>`.",
     "",
+    "## Notification Delivery",
+    "",
+    "When notification or automation delivery is the reported failure, inspect configuration and delivery records before changing incident logic.",
+    "",
+    "- Alerts route incident notifications to configured channels. Start with `debugbundle alert list --project-id <id> --json` and confirm condition, severity, service, cooldown, channel, and enabled state.",
+    "- Webhooks deliver signed lifecycle events to external systems. Start with `debugbundle webhook list --project-id <id> --json`, then inspect `debugbundle webhook deliveries <webhook-id> --project-id <id> --json` before retrying or testing.",
+    "- Webhook tests and retries are side-effecting delivery actions. Use them only when validating a destination or replaying an explicit failed delivery.",
+    "",
+    "## Full Documentation",
+    "",
+    "- CLI: `https://debugbundle.com/docs/cli`",
+    "- MCP tools: `https://debugbundle.com/docs/mcp/tools`",
+    "- Availability checks: `https://debugbundle.com/docs/availability-checks`",
+    "- Probes: `https://debugbundle.com/docs/probes`",
+    "- Capture policy and rules: `https://debugbundle.com/docs/capture-policy`",
+    "- Alerts: `https://debugbundle.com/docs/alerts` and `https://debugbundle.com/docs/cli/alerts`",
+    "- Webhooks: `https://debugbundle.com/docs/webhooks` and `https://debugbundle.com/docs/cli/webhooks`",
+    "- API ingestion: `https://debugbundle.com/docs/api/ingestion`",
+    "",
     "## Profile Validation",
     "",
     "Use this task after setup or whenever architecture changes make the static profile stale.",
@@ -17973,6 +18120,56 @@ function buildCliReference() {
     "",
     "Use capture-rule suggestions for repeated operational noise after inspecting an incident bundle. Use capture-policy client-error path rules for route-scoped 4xx incidents instead of promoting all client errors.",
     "",
+    "## Probes",
+    "",
+    "- `debugbundle probe activate <project-id> --label-pattern <pattern> [--service <name>] [--environment <name>] [--ttl-seconds <n>] [--trigger-ttl-seconds <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle probe list <project-id> [--auth-file <path>] [--json]`",
+    "- `debugbundle probe deactivate <project-id> <activation-id> [--auth-file <path>] [--json]`",
+    "",
+    "Use probes for targeted evidence gathering when bundle context is insufficient. Prefer narrow label patterns, scoped service/environment values, and explicit TTLs.",
+    "",
+    "## Notifications",
+    "",
+    "- `debugbundle alert list --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle alert create --project-id <id> --channel <channel> --condition <condition> [--service-id <id>] [--severity-min <level>] [--cooldown <seconds>] --config-json <json> [--is-enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle alert update <alert-id> --project-id <id> [--service-id <id|null>] [--channel <channel>] [--condition <condition>] [--severity-min <level|null>] [--cooldown <seconds>] [--config-json <json|null>] [--is-enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle alert delete <alert-id> --project-id <id> [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook list --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook create --project-id <id> --url <url> --event <event[,event]> [--environment <env[,env]>] [--service <svc[,svc]>] [--severity-min <level>] [--bundle-type <type[,type]>] [--verification <true|false>] [--is-enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook update <webhook-id> --project-id <id> [--url <url>] [--event <event[,event]>] [--environment <env[,env]>] [--service <svc[,svc]>] [--severity-min <level>] [--bundle-type <type[,type]>] [--verification <true|false>] [--is-enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook delete <webhook-id> --project-id <id> [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook test <webhook-id> --project-id <id> [--event <verification.passed|verification.failed>] [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook deliveries <webhook-id> --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle webhook retry <webhook-id> <delivery-id> --project-id <id> [--auth-file <path>] [--json]`",
+    "",
+    "Use alert commands for notification routing and webhook commands for signed event delivery, delivery history, synthetic tests, and manual retries.",
+    "",
+    "## Availability Checks",
+    "",
+    "- `debugbundle health checks list --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks get <check-id> --project-id <id> [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks create --project-id <id> --name <name> --url <url> --interval-seconds <n> [--method <GET|HEAD>] [--expected-status-min <code>] [--expected-status-max <code>] [--timeout-ms <n>] [--failure-threshold <n>] [--recovery-threshold <n>] [--environment <name>] [--service <name|null>] [--enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks update <check-id> --project-id <id> [--name <name>] [--url <url>] [--method <GET|HEAD>] [--expected-status-min <code>] [--expected-status-max <code>] [--timeout-ms <n>] [--interval-seconds <n>] [--failure-threshold <n>] [--recovery-threshold <n>] [--environment <name>] [--service <name|null>] [--enabled <true|false>] [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks delete <check-id> --project-id <id> [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks test --project-id <id> --url <url> [--method <GET|HEAD>] [--expected-status-min <code>] [--expected-status-max <code>] [--timeout-ms <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks results <check-id> --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "- `debugbundle health checks daily-rollups <check-id> --project-id <id> [--limit <n>] [--auth-file <path>] [--json]`",
+    "",
+    "Use availability-check commands for hosted endpoint reachability. Prefer `test` before saving a new target. `test` is side-effect-free and does not create incidents or retained history. Saved checks remain visible after downgrade, but checks beyond current count or interval limits pause until the project becomes eligible again.",
+    "",
+    "## Documentation URLs",
+    "",
+    "- CLI overview: `https://debugbundle.com/docs/cli`",
+    "- Cloud workflow: `https://debugbundle.com/docs/cli/cloud-workflow`",
+    "- API overview: `https://debugbundle.com/docs/api`",
+    "- API ingestion: `https://debugbundle.com/docs/api/ingestion`",
+    "- Alerts: `https://debugbundle.com/docs/alerts` and `https://debugbundle.com/docs/cli/alerts`",
+    "- Webhooks: `https://debugbundle.com/docs/webhooks`, `https://debugbundle.com/docs/cli/webhooks`, and `https://debugbundle.com/docs/api/webhooks`",
+    "- Probes: `https://debugbundle.com/docs/probes` and `https://debugbundle.com/docs/api/probes`",
+    "- Capture policy and rules: `https://debugbundle.com/docs/capture-policy`",
+    "- Availability checks: `https://debugbundle.com/docs/availability-checks`",
+    "- MCP tool catalog: `https://debugbundle.com/docs/mcp/tools`",
+    "",
     "## Operational Paths",
     "",
     "- `.debugbundle/profile.json` \u2014 committed project map and agent validation state",
@@ -17994,7 +18191,7 @@ function buildCliReference() {
     "",
     "```bash",
     "debugbundle incidents --status open --json",
-    "debugbundle resolve <incident-id>",
+    "debugbundle resolve <incident-id> [incident-id ...]",
     "debugbundle incidents --status open --json",
     "```",
     "",
@@ -18039,6 +18236,45 @@ function buildMcpReference() {
     "",
     "Use these tools for repeated low-value operational noise only after inspecting incident evidence. Keep frontend suppression scoped by structured browser and client signals, and use path-scoped capture policy for known 4xx routes.",
     "",
+    "## Probe Tools",
+    "",
+    "- `activate_probe` \u2014 activate a remote probe pattern with optional service/environment scope and TTL.",
+    "- `list_active_probes` \u2014 list active probe activations for a project.",
+    "- `deactivate_probe` \u2014 deactivate one active probe.",
+    "",
+    "Use probes for targeted evidence gathering when incident bundles do not contain enough runtime context.",
+    "",
+    "## Notification Tools",
+    "",
+    "- `list_alerts`, `create_alert`, `update_alert`, `delete_alert` \u2014 manage incident alert rules.",
+    "- `list_webhooks`, `create_webhook`, `update_webhook`, `delete_webhook` \u2014 manage signed webhook destinations.",
+    "- `test_webhook`, `list_webhook_deliveries` \u2014 validate webhook delivery and inspect delivery history.",
+    "",
+    "Use these tools when the reported problem is missing, duplicate, delayed, disabled, or failed notification delivery.",
+    "",
+    "## Availability Check Tools",
+    "",
+    "- `list_health_checks` \u2014 list hosted health checks and plan limits for a project.",
+    "- `get_health_check` \u2014 fetch one hosted health check by id.",
+    "- `test_health_check` \u2014 run a side-effect-free target test without opening incidents or writing retained history.",
+    "- `create_health_check`, `update_health_check`, `delete_health_check` \u2014 manage saved hosted health checks when the user explicitly asks to change monitoring.",
+    "- `list_health_check_results` \u2014 inspect recent raw executions for one check.",
+    "- `list_health_check_daily_rollups` \u2014 inspect retained per-day status history for one check.",
+    "",
+    "Use these tools for endpoint downtime, public reachability, and project Health tab issues. Start with list/results/rollups, use `test_health_check` before saving target changes, and inspect the linked normal incident bundle when failures crossed the configured threshold.",
+    "",
+    "## Documentation URLs",
+    "",
+    "- MCP overview: `https://debugbundle.com/docs/mcp`",
+    "- MCP workflows: `https://debugbundle.com/docs/mcp/workflows`",
+    "- MCP tools: `https://debugbundle.com/docs/mcp/tools`",
+    "- Availability checks: `https://debugbundle.com/docs/availability-checks`",
+    "- Probes: `https://debugbundle.com/docs/probes`",
+    "- Capture policy and rules: `https://debugbundle.com/docs/capture-policy`",
+    "- Alerts: `https://debugbundle.com/docs/alerts`",
+    "- Webhooks: `https://debugbundle.com/docs/webhooks`",
+    "- API ingestion: `https://debugbundle.com/docs/api/ingestion`",
+    "",
     "## Smoke-Test Cleanup Recipe",
     "",
     '1. Call `list_incidents` with `status: "open"`.',
@@ -18173,6 +18409,15 @@ function buildSkillEvals() {
             "Use capture-policy path rules for known route-scoped 4xx incidents."
           ]
         },
+        {
+          name: "operational_controls_guidance",
+          prompt: "The user reports missing webhook deliveries and asks whether probes or alerts are available. Confirm the skill points the agent to the relevant operational controls and docs.",
+          expected_behavior: [
+            "Inspect alert and webhook configuration plus webhook delivery history before changing application code.",
+            "Use probes for targeted evidence gathering with narrow scope and TTL.",
+            "Point to the full CLI, MCP, alerts, webhooks, probes, capture policy, availability checks, and ingestion documentation URLs."
+          ]
+        },
         {
           name: "artifact_path_discovery",
           prompt: "The user reports an unknown local runtime error. Confirm the skill tells the agent which DebugBundle paths and commands to inspect first.",
@@ -19048,6 +19293,189 @@ function createProbeApi(httpClient) {
   };
 }
 
+// ../cli/src/health-check-commands.ts
+var HealthCheckApiError = class extends Error {
+  status;
+  code;
+  constructor(status, code) {
+    super(`health_check_api_error: ${status}:${code}`);
+    this.name = "HealthCheckApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function toApiError6(status, body) {
+  if (typeof body === "object" && body !== null && "error" in body && typeof body.error === "string") {
+    return new HealthCheckApiError(status, body.error);
+  }
+  return new HealthCheckApiError(status, "unknown_error");
+}
+function buildCreateRequestBody(input) {
+  const body = {
+    name: input.name,
+    url: input.url,
+    method: input.method,
+    expected_status_min: input.expectedStatusMin,
+    expected_status_max: input.expectedStatusMax,
+    timeout_ms: input.timeoutMs,
+    interval_seconds: input.intervalSeconds,
+    failure_threshold: input.failureThreshold,
+    recovery_threshold: input.recoveryThreshold,
+    enabled: input.enabled
+  };
+  if (input.environment !== void 0) {
+    body["environment"] = input.environment;
+  }
+  if (input.serviceName !== void 0) {
+    body["service_name"] = input.serviceName;
+  }
+  return body;
+}
+function buildUpdateRequestBody(input) {
+  const body = {};
+  if (input.name !== void 0) {
+    body["name"] = input.name;
+  }
+  if (input.url !== void 0) {
+    body["url"] = input.url;
+  }
+  if (input.method !== void 0) {
+    body["method"] = input.method;
+  }
+  if (input.expectedStatusMin !== void 0) {
+    body["expected_status_min"] = input.expectedStatusMin;
+  }
+  if (input.expectedStatusMax !== void 0) {
+    body["expected_status_max"] = input.expectedStatusMax;
+  }
+  if (input.timeoutMs !== void 0) {
+    body["timeout_ms"] = input.timeoutMs;
+  }
+  if (input.intervalSeconds !== void 0) {
+    body["interval_seconds"] = input.intervalSeconds;
+  }
+  if (input.failureThreshold !== void 0) {
+    body["failure_threshold"] = input.failureThreshold;
+  }
+  if (input.recoveryThreshold !== void 0) {
+    body["recovery_threshold"] = input.recoveryThreshold;
+  }
+  if (input.environment !== void 0) {
+    body["environment"] = input.environment;
+  }
+  if (input.serviceName !== void 0) {
+    body["service_name"] = input.serviceName;
+  }
+  if (input.enabled !== void 0) {
+    body["enabled"] = input.enabled;
+  }
+  return body;
+}
+function createHealthCheckApi(httpClient) {
+  return {
+    async listHealthChecks(input) {
+      const limit = input.limit ?? 100;
+      const response = await httpClient.request({
+        method: "GET",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks?limit=${encodeURIComponent(String(limit))}`,
+        bearerToken: input.bearerToken
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async getHealthCheck(input) {
+      const response = await httpClient.request({
+        method: "GET",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/${encodeURIComponent(input.checkId)}`,
+        bearerToken: input.bearerToken
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async createHealthCheck(input) {
+      const response = await httpClient.request({
+        method: "POST",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks`,
+        bearerToken: input.bearerToken,
+        body: buildCreateRequestBody(input)
+      });
+      if (response.status !== 201) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async updateHealthCheck(input) {
+      const response = await httpClient.request({
+        method: "PATCH",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/${encodeURIComponent(input.checkId)}`,
+        bearerToken: input.bearerToken,
+        body: buildUpdateRequestBody(input)
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async deleteHealthCheck(input) {
+      const response = await httpClient.request({
+        method: "DELETE",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/${encodeURIComponent(input.checkId)}`,
+        bearerToken: input.bearerToken
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async testHealthCheck(input) {
+      const response = await httpClient.request({
+        method: "POST",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/test`,
+        bearerToken: input.bearerToken,
+        body: {
+          url: input.url,
+          method: input.method,
+          expected_status_min: input.expectedStatusMin,
+          expected_status_max: input.expectedStatusMax,
+          timeout_ms: input.timeoutMs
+        }
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async listHealthCheckResults(input) {
+      const limit = input.limit ?? 20;
+      const response = await httpClient.request({
+        method: "GET",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/${encodeURIComponent(input.checkId)}/results?limit=${encodeURIComponent(String(limit))}`,
+        bearerToken: input.bearerToken
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    },
+    async listHealthCheckDailyRollups(input) {
+      const limit = input.limit ?? 30;
+      const response = await httpClient.request({
+        method: "GET",
+        path: `/v1/projects/${encodeURIComponent(input.projectId)}/availability-checks/${encodeURIComponent(input.checkId)}/daily-rollups?limit=${encodeURIComponent(String(limit))}`,
+        bearerToken: input.bearerToken
+      });
+      if (response.status !== 200) {
+        throw toApiError6(response.status, response.body);
+      }
+      return response.body;
+    }
+  };
+}
+
 // ../cli/src/doctor-command.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_path4 = require("node:path");
@@ -20102,7 +20530,7 @@ async function doctorCommand(input, dependencies = {}) {
 }
 
 // ../cli/src/verify-command.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_promises7 = require("node:fs/promises");
 var import_node_path9 = require("node:path");
 
@@ -20508,6 +20936,16 @@ var DEFAULT_SESSION_LIFETIME_MS = 1e3 * 60 * 60 * 24 * 7;
 var DEFAULT_EMAIL_AUTH_CODE_LIFETIME_MS = 1e3 * 60 * 10;
 var DEFAULT_GITHUB_OAUTH_STATE_LIFETIME_MS = 1e3 * 60 * 10;
 
+// ../../packages/storage/src/availability-check-store-helpers.ts
+var TIER_CAPABILITIES_SQL = {
+  free_limit: getTierCapabilities("free").availability_checks_per_project,
+  solo_limit: getTierCapabilities("solo").availability_checks_per_project,
+  team_limit: getTierCapabilities("team").availability_checks_per_project,
+  free_interval: getTierCapabilities("free").availability_check_min_interval_seconds,
+  solo_interval: getTierCapabilities("solo").availability_check_min_interval_seconds,
+  team_interval: getTierCapabilities("team").availability_check_min_interval_seconds
+};
+
 // ../../packages/storage/src/auth-rate-limiter.ts
 var import_ioredis = __toESM(require_built3(), 1);
 
@@ -20525,8 +20963,131 @@ var import_ioredis3 = __toESM(require_built3(), 1);
 var import_ioredis4 = __toESM(require_built3(), 1);
 var DEFAULT_PROCESSING_TIMEOUT_MS = 5 * 60 * 1e3;
 
-// ../../packages/storage/src/schema-migrations.ts
-var import_node_crypto3 = require("node:crypto");
+// ../../packages/storage/src/availability-check-bootstrap-statements.ts
+var AVAILABILITY_CHECK_BOOTSTRAP_STATEMENTS = [
+  `
+    CREATE TABLE availability_checks (
+      id uuid PRIMARY KEY,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      created_by_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+      name text NOT NULL,
+      url text NOT NULL,
+      method text NOT NULL CHECK (method IN ('GET', 'HEAD')),
+      expected_status_min integer NOT NULL DEFAULT 200 CHECK (expected_status_min BETWEEN 100 AND 599),
+      expected_status_max integer NOT NULL DEFAULT 399 CHECK (expected_status_max BETWEEN 100 AND 599),
+      timeout_ms integer NOT NULL DEFAULT 5000 CHECK (timeout_ms BETWEEN 500 AND 5000),
+      interval_seconds integer NOT NULL CHECK (interval_seconds >= 30),
+      failure_threshold integer NOT NULL DEFAULT 3 CHECK (failure_threshold BETWEEN 1 AND 10),
+      recovery_threshold integer NOT NULL DEFAULT 2 CHECK (recovery_threshold BETWEEN 1 AND 10),
+      environment text NOT NULL DEFAULT 'production',
+      service_name text,
+      enabled boolean NOT NULL DEFAULT true,
+      status text NOT NULL DEFAULT 'unknown' CHECK (status IN ('unknown', 'passing', 'failing')),
+      consecutive_failures integer NOT NULL DEFAULT 0,
+      consecutive_successes integer NOT NULL DEFAULT 0,
+      linked_incident_id uuid REFERENCES incidents(id) ON DELETE SET NULL,
+      last_checked_at timestamptz,
+      next_check_at timestamptz,
+      claimed_at timestamptz,
+      last_result_status text CHECK (
+        last_result_status IS NULL OR last_result_status IN (
+          'success',
+          'http_status_mismatch',
+          'timeout',
+          'dns_error',
+          'tls_error',
+          'connection_error',
+          'redirect_blocked',
+          'security_blocked',
+          'internal_error'
+        )
+      ),
+      last_result_http_status integer,
+      last_result_error_kind text,
+      last_result_error_message text,
+      last_result_duration_ms integer,
+      deleted_at timestamptz,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `,
+  `
+    CREATE INDEX availability_checks_project_created_idx
+    ON availability_checks (project_id, created_at DESC)
+  `,
+  `
+    CREATE INDEX availability_checks_due_idx
+    ON availability_checks (next_check_at, project_id)
+  `,
+  `
+    CREATE INDEX availability_checks_claimed_idx
+    ON availability_checks (claimed_at)
+  `,
+  `
+    CREATE TABLE availability_check_results (
+      id uuid PRIMARY KEY,
+      check_id uuid NOT NULL REFERENCES availability_checks(id) ON DELETE CASCADE,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      started_at timestamptz NOT NULL,
+      completed_at timestamptz NOT NULL,
+      duration_ms integer NOT NULL,
+      status text NOT NULL CHECK (
+        status IN (
+          'success',
+          'http_status_mismatch',
+          'timeout',
+          'dns_error',
+          'tls_error',
+          'connection_error',
+          'redirect_blocked',
+          'security_blocked',
+          'internal_error'
+        )
+      ),
+      http_status integer,
+      error_kind text,
+      error_message text,
+      redirect_count integer NOT NULL DEFAULT 0,
+      checked_url_host text NOT NULL,
+      checked_url_path text NOT NULL,
+      final_url text NOT NULL,
+      created_at timestamptz NOT NULL DEFAULT now()
+    )
+  `,
+  `
+    CREATE INDEX availability_check_results_check_started_idx
+    ON availability_check_results (check_id, started_at DESC)
+  `,
+  `
+    CREATE INDEX availability_check_results_project_started_idx
+    ON availability_check_results (project_id, started_at DESC)
+  `,
+  `
+    CREATE TABLE availability_check_daily_rollups (
+      id uuid PRIMARY KEY,
+      check_id uuid NOT NULL REFERENCES availability_checks(id) ON DELETE CASCADE,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      day date NOT NULL,
+      state text NOT NULL CHECK (state IN ('unknown', 'operational', 'degraded', 'down', 'paused')),
+      total_checks integer NOT NULL DEFAULT 0,
+      successful_checks integer NOT NULL DEFAULT 0,
+      failed_checks integer NOT NULL DEFAULT 0,
+      degraded_checks integer NOT NULL DEFAULT 0,
+      avg_duration_ms integer,
+      first_checked_at timestamptz,
+      last_checked_at timestamptz,
+      downtime_seconds integer NOT NULL DEFAULT 0,
+      incident_ids uuid[] NOT NULL DEFAULT '{}'::uuid[],
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      UNIQUE (check_id, day)
+    )
+  `,
+  `
+    CREATE INDEX availability_check_daily_rollups_project_day_idx
+    ON availability_check_daily_rollups (project_id, day DESC)
+  `
+];
 
 // ../../packages/storage/src/storage-bootstrap-statements.ts
 var STORAGE_BOOTSTRAP_STATEMENTS = [
@@ -20695,6 +21256,7 @@ var STORAGE_BOOTSTRAP_STATEMENTS = [
       user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
       organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
       session_token_hash text UNIQUE NOT NULL,
+      auth_method text CHECK (auth_method IS NULL OR auth_method IN ('email_code', 'github_oauth')),
       created_at timestamptz NOT NULL DEFAULT now(),
       expires_at timestamptz NOT NULL,
       revoked_at timestamptz
@@ -21623,80 +22185,325 @@ var STORAGE_BOOTSTRAP_STATEMENTS = [
   `
 ];
 
+// ../../packages/storage/src/storage-bootstrap-all-statements.ts
+var STORAGE_BOOTSTRAP_STATEMENTS2 = [
+  ...STORAGE_BOOTSTRAP_STATEMENTS,
+  ...AVAILABILITY_CHECK_BOOTSTRAP_STATEMENTS
+];
+
 // ../../packages/storage/src/migrations.ts
-var STORAGE_BOOTSTRAP_SQL = STORAGE_BOOTSTRAP_STATEMENTS.join(";\n\n");
+var STORAGE_BOOTSTRAP_SQL = STORAGE_BOOTSTRAP_STATEMENTS2.join(";\n\n");
 
-// ../../packages/storage/src/schema-migrations.ts
-function computeMigrationChecksum(input) {
-  return (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
-}
-function defineStorageSchemaMigration(input) {
+// ../../packages/storage/src/availability-check-schema-migrations.ts
+var import_node_crypto3 = require("node:crypto");
+function defineAvailabilityCheckStorageSchemaMigration(input) {
   return {
     ...input,
-    checksum: computeMigrationChecksum(input)
+    checksum: (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(input)).digest("hex")
   };
 }
-var STORAGE_SCHEMA_MIGRATIONS = [
-  defineStorageSchemaMigration({
-    id: "202605050001_add_auth_suspension_columns",
-    description: "Add organization and membership suspension timestamps used by auth gates.",
-    statements: [
-      "ALTER TABLE organizations ADD COLUMN IF NOT EXISTS suspended_at timestamptz",
-      "ALTER TABLE organization_members ADD COLUMN IF NOT EXISTS suspended_at timestamptz"
-    ]
-  }),
-  defineStorageSchemaMigration({
-    id: "202605120001_add_github_device_authorizations",
-    description: "Add persisted GitHub CLI bootstrap state for device-flow login.",
+var AVAILABILITY_CHECK_STORAGE_SCHEMA_MIGRATIONS = [
+  defineAvailabilityCheckStorageSchemaMigration({
+    id: "202606150001_add_availability_checks",
+    description: "Add project-scoped availability checks, result history, and daily rollups.",
     statements: [
       `
-        CREATE TABLE IF NOT EXISTS github_device_authorizations (
+        CREATE TABLE IF NOT EXISTS availability_checks (
           id uuid PRIMARY KEY,
-          device_code text NOT NULL UNIQUE,
-          user_code text NOT NULL,
-          verification_uri text NOT NULL,
+          project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+          created_by_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+          name text NOT NULL,
+          url text NOT NULL,
+          method text NOT NULL,
+          expected_status_min integer NOT NULL DEFAULT 200,
+          expected_status_max integer NOT NULL DEFAULT 399,
+          timeout_ms integer NOT NULL DEFAULT 5000,
           interval_seconds integer NOT NULL,
-          expires_at timestamptz NOT NULL,
-          accepted_terms_at timestamptz,
-          created_at timestamptz NOT NULL DEFAULT now(),
-          completed_at timestamptz,
+          failure_threshold integer NOT NULL DEFAULT 3,
+          recovery_threshold integer NOT NULL DEFAULT 2,
+          environment text NOT NULL DEFAULT 'production',
+          service_name text,
+          enabled boolean NOT NULL DEFAULT true,
+          status text NOT NULL DEFAULT 'unknown',
+          consecutive_failures integer NOT NULL DEFAULT 0,
+          consecutive_successes integer NOT NULL DEFAULT 0,
+          linked_incident_id uuid REFERENCES incidents(id) ON DELETE SET NULL,
+          last_checked_at timestamptz,
+          next_check_at timestamptz,
           claimed_at timestamptz,
-          terminal_error text,
-          user_id uuid REFERENCES users(id) ON DELETE SET NULL,
-          organization_id uuid REFERENCES organizations(id) ON DELETE SET NULL
+          last_result_status text,
+          last_result_http_status integer,
+          last_result_error_kind text,
+          last_result_error_message text,
+          last_result_duration_ms integer,
+          deleted_at timestamptz,
+          created_at timestamptz NOT NULL DEFAULT now(),
+          updated_at timestamptz NOT NULL DEFAULT now()
         )
       `,
       `
-        CREATE INDEX IF NOT EXISTS github_device_authorizations_user_code_idx
-        ON github_device_authorizations (user_code, created_at DESC)
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_method_check
       `,
       `
-        CREATE INDEX IF NOT EXISTS github_device_authorizations_expires_at_idx
-        ON github_device_authorizations (expires_at)
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_method_check
+        CHECK (method IN ('GET', 'HEAD'))
+      `,
       `
-    ]
-  }),
-  defineStorageSchemaMigration({
-    id: "202605130001_allow_synthetic_webhook_test_deliveries_without_incident_fk",
-    description: "Allow webhook test deliveries to persist without requiring a backing incidents row.",
-    statements: ["ALTER TABLE webhook_deliveries ALTER COLUMN incident_id DROP NOT NULL"]
-  }),
-  defineStorageSchemaMigration({
-    id: "202605130002_add_slack_destinations",
-    description: "Add reusable encrypted Slack alert destinations scoped to organizations.",
-    statements: [
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_expected_status_min_check
+      `,
       `
-        CREATE TABLE IF NOT EXISTS slack_destinations (
-          id uuid PRIMARY KEY,
-          organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
-          slack_team_id text NOT NULL,
-          slack_team_name text,
-          slack_channel_id text NOT NULL,
-          slack_channel_name text,
-          webhook_url_ciphertext text NOT NULL,
-          installed_by_member_id uuid REFERENCES users(id) ON DELETE SET NULL,
-          is_active boolean NOT NULL DEFAULT true,
-          created_at timestamptz NOT NULL DEFAULT now(),
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_expected_status_min_check
+        CHECK (expected_status_min BETWEEN 100 AND 599)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_expected_status_max_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_expected_status_max_check
+        CHECK (expected_status_max BETWEEN 100 AND 599)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_timeout_ms_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_timeout_ms_check
+        CHECK (timeout_ms BETWEEN 500 AND 5000)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_interval_seconds_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_interval_seconds_check
+        CHECK (interval_seconds >= 30)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_failure_threshold_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_failure_threshold_check
+        CHECK (failure_threshold BETWEEN 1 AND 10)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_recovery_threshold_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_recovery_threshold_check
+        CHECK (recovery_threshold BETWEEN 1 AND 10)
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_status_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_status_check
+        CHECK (status IN ('unknown', 'passing', 'failing'))
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_last_result_status_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_last_result_status_check
+        CHECK (
+          last_result_status IS NULL OR last_result_status IN (
+            'success',
+            'http_status_mismatch',
+            'timeout',
+            'dns_error',
+            'tls_error',
+            'connection_error',
+            'redirect_blocked',
+            'security_blocked',
+            'internal_error'
+          )
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_checks_project_created_idx
+        ON availability_checks (project_id, created_at DESC)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_checks_due_idx
+        ON availability_checks (next_check_at, project_id)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_checks_claimed_idx
+        ON availability_checks (claimed_at)
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS availability_check_results (
+          id uuid PRIMARY KEY,
+          check_id uuid NOT NULL REFERENCES availability_checks(id) ON DELETE CASCADE,
+          project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+          started_at timestamptz NOT NULL,
+          completed_at timestamptz NOT NULL,
+          duration_ms integer NOT NULL,
+          status text NOT NULL,
+          http_status integer,
+          error_kind text,
+          error_message text,
+          redirect_count integer NOT NULL DEFAULT 0,
+          checked_url_host text NOT NULL,
+          checked_url_path text NOT NULL,
+          final_url text NOT NULL,
+          created_at timestamptz NOT NULL DEFAULT now()
+        )
+      `,
+      `
+        ALTER TABLE availability_check_results
+        DROP CONSTRAINT IF EXISTS availability_check_results_status_check
+      `,
+      `
+        ALTER TABLE availability_check_results
+        ADD CONSTRAINT availability_check_results_status_check
+        CHECK (
+          status IN (
+            'success',
+            'http_status_mismatch',
+            'timeout',
+            'dns_error',
+            'tls_error',
+            'connection_error',
+            'redirect_blocked',
+            'security_blocked',
+            'internal_error'
+          )
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_check_results_check_started_idx
+        ON availability_check_results (check_id, started_at DESC)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_check_results_project_started_idx
+        ON availability_check_results (project_id, started_at DESC)
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS availability_check_daily_rollups (
+          id uuid PRIMARY KEY,
+          check_id uuid NOT NULL REFERENCES availability_checks(id) ON DELETE CASCADE,
+          project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+          day date NOT NULL,
+          state text NOT NULL,
+          total_checks integer NOT NULL DEFAULT 0,
+          successful_checks integer NOT NULL DEFAULT 0,
+          failed_checks integer NOT NULL DEFAULT 0,
+          degraded_checks integer NOT NULL DEFAULT 0,
+          avg_duration_ms integer,
+          first_checked_at timestamptz,
+          last_checked_at timestamptz,
+          downtime_seconds integer NOT NULL DEFAULT 0,
+          incident_ids uuid[] NOT NULL DEFAULT '{}'::uuid[],
+          created_at timestamptz NOT NULL DEFAULT now(),
+          updated_at timestamptz NOT NULL DEFAULT now(),
+          UNIQUE (check_id, day)
+        )
+      `,
+      `
+        ALTER TABLE availability_check_daily_rollups
+        DROP CONSTRAINT IF EXISTS availability_check_daily_rollups_state_check
+      `,
+      `
+        ALTER TABLE availability_check_daily_rollups
+        ADD CONSTRAINT availability_check_daily_rollups_state_check
+        CHECK (state IN ('unknown', 'operational', 'degraded', 'down', 'paused'))
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS availability_check_daily_rollups_project_day_idx
+        ON availability_check_daily_rollups (project_id, day DESC)
+      `
+    ]
+  })
+];
+
+// ../../packages/storage/src/schema-migrations-catalog.ts
+var import_node_crypto4 = require("node:crypto");
+function computeMigrationChecksum(input) {
+  return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
+}
+function defineStorageSchemaMigration(input) {
+  return {
+    ...input,
+    checksum: computeMigrationChecksum(input)
+  };
+}
+var STORAGE_SCHEMA_MIGRATIONS = [
+  defineStorageSchemaMigration({
+    id: "202605050001_add_auth_suspension_columns",
+    description: "Add organization and membership suspension timestamps used by auth gates.",
+    statements: [
+      "ALTER TABLE organizations ADD COLUMN IF NOT EXISTS suspended_at timestamptz",
+      "ALTER TABLE organization_members ADD COLUMN IF NOT EXISTS suspended_at timestamptz"
+    ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202605120001_add_github_device_authorizations",
+    description: "Add persisted GitHub CLI bootstrap state for device-flow login.",
+    statements: [
+      `
+        CREATE TABLE IF NOT EXISTS github_device_authorizations (
+          id uuid PRIMARY KEY,
+          device_code text NOT NULL UNIQUE,
+          user_code text NOT NULL,
+          verification_uri text NOT NULL,
+          interval_seconds integer NOT NULL,
+          expires_at timestamptz NOT NULL,
+          accepted_terms_at timestamptz,
+          created_at timestamptz NOT NULL DEFAULT now(),
+          completed_at timestamptz,
+          claimed_at timestamptz,
+          terminal_error text,
+          user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+          organization_id uuid REFERENCES organizations(id) ON DELETE SET NULL
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS github_device_authorizations_user_code_idx
+        ON github_device_authorizations (user_code, created_at DESC)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS github_device_authorizations_expires_at_idx
+        ON github_device_authorizations (expires_at)
+      `
+    ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202605130001_allow_synthetic_webhook_test_deliveries_without_incident_fk",
+    description: "Allow webhook test deliveries to persist without requiring a backing incidents row.",
+    statements: ["ALTER TABLE webhook_deliveries ALTER COLUMN incident_id DROP NOT NULL"]
+  }),
+  defineStorageSchemaMigration({
+    id: "202605130002_add_slack_destinations",
+    description: "Add reusable encrypted Slack alert destinations scoped to organizations.",
+    statements: [
+      `
+        CREATE TABLE IF NOT EXISTS slack_destinations (
+          id uuid PRIMARY KEY,
+          organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+          slack_team_id text NOT NULL,
+          slack_team_name text,
+          slack_channel_id text NOT NULL,
+          slack_channel_name text,
+          webhook_url_ciphertext text NOT NULL,
+          installed_by_member_id uuid REFERENCES users(id) ON DELETE SET NULL,
+          is_active boolean NOT NULL DEFAULT true,
+          created_at timestamptz NOT NULL DEFAULT now(),
           updated_at timestamptz NOT NULL DEFAULT now(),
           UNIQUE (organization_id, slack_team_id, slack_channel_id)
         )
@@ -22457,15 +23264,47 @@ var STORAGE_SCHEMA_MIGRATIONS = [
         ON account_payment_provider_events (provider, provider_event_id)
       `
     ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202606120001_add_session_auth_method",
+    description: "Track the auth method used to create each browser session.",
+    statements: [
+      "ALTER TABLE sessions ADD COLUMN IF NOT EXISTS auth_method text",
+      "ALTER TABLE sessions DROP CONSTRAINT IF EXISTS sessions_auth_method_check",
+      `
+        ALTER TABLE sessions
+        ADD CONSTRAINT sessions_auth_method_check
+        CHECK (auth_method IS NULL OR auth_method IN ('email_code', 'github_oauth'))
+      `
+    ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202606130001_retire_expired_project_invites",
+    description: "Retire already-expired project invites so re-inviting the same email is unblocked.",
+    statements: [
+      `
+        UPDATE project_invites
+        SET canceled_at = expires_at
+        WHERE accepted_at IS NULL
+          AND canceled_at IS NULL
+          AND expires_at <= now()
+      `
+    ]
   })
 ];
 
+// ../../packages/storage/src/schema-migrations.ts
+var STORAGE_SCHEMA_MIGRATIONS2 = [
+  ...STORAGE_SCHEMA_MIGRATIONS,
+  ...AVAILABILITY_CHECK_STORAGE_SCHEMA_MIGRATIONS
+];
+
 // ../cli/src/ingest-command.ts
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 var import_node_path7 = require("node:path");
 
 // ../cli/src/process-command.ts
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var import_promises5 = require("node:fs/promises");
 var import_node_path6 = require("node:path");
 
@@ -23651,7 +24490,7 @@ function mergeAggregateGroup(aggregates) {
   });
 }
 function hashIdentifier(parts, prefix, length) {
-  const digest = (0, import_node_crypto4.createHash)("sha256").update(parts.join("\0")).digest("hex");
+  const digest = (0, import_node_crypto5.createHash)("sha256").update(parts.join("\0")).digest("hex");
   return `${prefix}_${digest.slice(0, length)}`;
 }
 function deriveIncidentId(projectId, serviceName, environment, incidentFingerprint) {
@@ -23685,7 +24524,7 @@ function stableJson3(value) {
   return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson3(record[key])}`).join(",")}}`;
 }
 function buildRequestAnomalyFingerprint(input) {
-  return (0, import_node_crypto4.createHash)("sha256").update(
+  return (0, import_node_crypto5.createHash)("sha256").update(
     stableJson3({
       kind: "request_status_anomaly",
       project_id: input.projectId,
@@ -24316,7 +25155,7 @@ function buildEventFileName(events, filePath) {
     const candidate = Date.parse(event.occurred_at);
     return Number.isFinite(candidate) && candidate > latest ? candidate : latest;
   }, 0);
-  const digest = (0, import_node_crypto5.createHash)("sha256").update([filePath, ...events.map((event) => event.event_id)].join("\0")).digest("hex").slice(0, 8);
+  const digest = (0, import_node_crypto6.createHash)("sha256").update([filePath, ...events.map((event) => event.event_id)].join("\0")).digest("hex").slice(0, 8);
   return `${lastOccurredAt}-${digest}-${slugify(events[0]?.service.name ?? (0, import_node_path7.basename)(filePath))}.events.json`;
 }
 async function readProfile(rootDirectory, readFile) {
@@ -24725,7 +25564,7 @@ function cloudVerificationRunId(now) {
   return now.toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
 }
 function defaultCloudVerificationSuffix() {
-  return (0, import_node_crypto6.randomUUID)().replace(/-/g, "").slice(0, 12);
+  return (0, import_node_crypto7.randomUUID)().replace(/-/g, "").slice(0, 12);
 }
 function normalizeCloudVerificationSuffix(suffix) {
   const normalized = suffix.toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, 12);
@@ -26509,8 +27348,176 @@ function createProbeMcpTools(api) {
   };
 }
 
-// src/project-tools.ts
+// src/health-check-tools.ts
 function mapMcpError11(error) {
+  if (error instanceof HealthCheckApiError) {
+    throw new Error(`mcp_tool_error:${error.code}`);
+  }
+  throw new Error("mcp_tool_error:unknown_error");
+}
+function createHealthCheckMcpTools(api) {
+  return {
+    async list_health_checks(input) {
+      try {
+        const requestInput = {
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"])
+        };
+        if (typeof input["limit"] === "number") {
+          requestInput.limit = input["limit"];
+        }
+        return await api.listHealthChecks(requestInput);
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async get_health_check(input) {
+      try {
+        return await api.getHealthCheck({
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          checkId: String(input["checkId"])
+        });
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async create_health_check(input) {
+      try {
+        const requestInput = {
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          name: String(input["name"]),
+          url: String(input["url"]),
+          method: input["method"] === "HEAD" ? "HEAD" : "GET",
+          expectedStatusMin: typeof input["expectedStatusMin"] === "number" ? input["expectedStatusMin"] : 200,
+          expectedStatusMax: typeof input["expectedStatusMax"] === "number" ? input["expectedStatusMax"] : 399,
+          timeoutMs: typeof input["timeoutMs"] === "number" ? input["timeoutMs"] : 5e3,
+          intervalSeconds: Number(input["intervalSeconds"]),
+          failureThreshold: typeof input["failureThreshold"] === "number" ? input["failureThreshold"] : 3,
+          recoveryThreshold: typeof input["recoveryThreshold"] === "number" ? input["recoveryThreshold"] : 2,
+          enabled: typeof input["enabled"] === "boolean" ? input["enabled"] : true
+        };
+        if (typeof input["environment"] === "string") {
+          requestInput.environment = input["environment"];
+        }
+        if (typeof input["serviceName"] === "string" || input["serviceName"] === null) {
+          requestInput.serviceName = input["serviceName"];
+        }
+        return await api.createHealthCheck(requestInput);
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async update_health_check(input) {
+      try {
+        const requestInput = {
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          checkId: String(input["checkId"])
+        };
+        if (typeof input["name"] === "string") {
+          requestInput.name = input["name"];
+        }
+        if (typeof input["url"] === "string") {
+          requestInput.url = input["url"];
+        }
+        if (input["method"] === "GET" || input["method"] === "HEAD") {
+          requestInput.method = input["method"];
+        }
+        if (typeof input["expectedStatusMin"] === "number") {
+          requestInput.expectedStatusMin = input["expectedStatusMin"];
+        }
+        if (typeof input["expectedStatusMax"] === "number") {
+          requestInput.expectedStatusMax = input["expectedStatusMax"];
+        }
+        if (typeof input["timeoutMs"] === "number") {
+          requestInput.timeoutMs = input["timeoutMs"];
+        }
+        if (typeof input["intervalSeconds"] === "number") {
+          requestInput.intervalSeconds = input["intervalSeconds"];
+        }
+        if (typeof input["failureThreshold"] === "number") {
+          requestInput.failureThreshold = input["failureThreshold"];
+        }
+        if (typeof input["recoveryThreshold"] === "number") {
+          requestInput.recoveryThreshold = input["recoveryThreshold"];
+        }
+        if (typeof input["environment"] === "string") {
+          requestInput.environment = input["environment"];
+        }
+        if (typeof input["serviceName"] === "string" || input["serviceName"] === null) {
+          requestInput.serviceName = input["serviceName"];
+        }
+        if (typeof input["enabled"] === "boolean") {
+          requestInput.enabled = input["enabled"];
+        }
+        return await api.updateHealthCheck(requestInput);
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async delete_health_check(input) {
+      try {
+        return await api.deleteHealthCheck({
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          checkId: String(input["checkId"])
+        });
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async test_health_check(input) {
+      try {
+        return await api.testHealthCheck({
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          url: String(input["url"]),
+          method: input["method"] === "HEAD" ? "HEAD" : "GET",
+          expectedStatusMin: typeof input["expectedStatusMin"] === "number" ? input["expectedStatusMin"] : 200,
+          expectedStatusMax: typeof input["expectedStatusMax"] === "number" ? input["expectedStatusMax"] : 399,
+          timeoutMs: typeof input["timeoutMs"] === "number" ? input["timeoutMs"] : 5e3
+        });
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async list_health_check_results(input) {
+      try {
+        const requestInput = {
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          checkId: String(input["checkId"])
+        };
+        if (typeof input["limit"] === "number") {
+          requestInput.limit = input["limit"];
+        }
+        return await api.listHealthCheckResults(requestInput);
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    },
+    async list_health_check_daily_rollups(input) {
+      try {
+        const requestInput = {
+          bearerToken: String(input["bearerToken"]),
+          projectId: String(input["projectId"]),
+          checkId: String(input["checkId"])
+        };
+        if (typeof input["limit"] === "number") {
+          requestInput.limit = input["limit"];
+        }
+        return await api.listHealthCheckDailyRollups(requestInput);
+      } catch (error) {
+        mapMcpError11(error);
+      }
+    }
+  };
+}
+
+// src/project-tools.ts
+function mapMcpError12(error) {
   if (error instanceof ProjectManagementApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -26528,7 +27535,7 @@ function createProjectMcpTools(api) {
         }
         return { projects: await api.listProjects(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async create_project(input) {
@@ -26543,7 +27550,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.createProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async update_project(input) {
@@ -26563,7 +27570,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.updateProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async delete_project(input) {
@@ -26575,7 +27582,7 @@ function createProjectMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     }
   };
@@ -26782,7 +27789,7 @@ async function persistCloudArtifact(directoryPath, fileName, payload, dependenci
 }
 
 // src/retrieval-tools.ts
-function mapMcpError12(error) {
+function mapMcpError13(error) {
   if (error instanceof RetrievalApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -26972,7 +27979,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidents.incidents.map((incident) => attachSourceToRecord(incident, "cloud"))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident(input) {
@@ -27007,7 +28014,7 @@ function createRetrievalMcpTools(api) {
           )
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident_context(input) {
@@ -27036,7 +28043,7 @@ function createRetrievalMcpTools(api) {
           "cloud"
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incident(input) {
@@ -27081,7 +28088,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incidents(input) {
@@ -27142,7 +28149,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incident(input) {
@@ -27187,7 +28194,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incidents(input) {
@@ -27248,7 +28255,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_bundle(input) {
@@ -27279,7 +28286,7 @@ function createRetrievalMcpTools(api) {
           }
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_logs(input) {
@@ -27299,7 +28306,7 @@ function createRetrievalMcpTools(api) {
         }
         return await api.getLogs(requestInput);
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_reproduction(input) {
@@ -27330,14 +28337,14 @@ function createRetrievalMcpTools(api) {
           }
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     }
   };
 }
 
 // src/services-tools.ts
-function mapMcpError13(error) {
+function mapMcpError14(error) {
   if (error instanceof RetrievalApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -27358,14 +28365,14 @@ function createServicesMcpTools(api) {
           services: await api.listServices(requestInput)
         };
       } catch (error) {
-        mapMcpError13(error);
+        mapMcpError14(error);
       }
     }
   };
 }
 
 // src/setup-tools.ts
-function mapMcpError14() {
+function mapMcpError15() {
   throw new Error("mcp_tool_error:unknown_error");
 }
 function parseJsonOutput2(output) {
@@ -27380,7 +28387,7 @@ async function runJsonCommand2(command) {
     const result = await command();
     return parseJsonOutput2(result.output);
   } catch {
-    mapMcpError14();
+    mapMcpError15();
   }
 }
 function createSetupMcpTools(commands) {
@@ -27439,7 +28446,7 @@ function createSetupMcpTools(commands) {
 }
 
 // src/slack-tools.ts
-function mapMcpError15(error) {
+function mapMcpError16(error) {
   if (error instanceof SlackApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -27456,7 +28463,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async get_slack_connect_url(input) {
@@ -27469,7 +28476,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async test_slack_destination(input) {
@@ -27482,7 +28489,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async delete_slack_destination(input) {
@@ -27495,14 +28502,14 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     }
   };
 }
 
 // src/token-tools.ts
-function mapMcpError16(error) {
+function mapMcpError17(error) {
   if (error instanceof TokenManagementApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -27523,7 +28530,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listProjectTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_project_token(input) {
@@ -27538,7 +28545,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_project_token(input) {
@@ -27551,7 +28558,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async list_member_tokens(input) {
@@ -27566,7 +28573,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listMemberTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_member_token(input) {
@@ -27578,7 +28585,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_member_token(input) {
@@ -27590,14 +28597,14 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     }
   };
 }
 
 // src/webhook-tools.ts
-function mapMcpError17(error) {
+function mapMcpError18(error) {
   if (error instanceof WebhookApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -27618,7 +28625,7 @@ function createWebhookMcpTools(api) {
           webhooks: await api.listWebhooks(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async create_webhook(input) {
@@ -27639,7 +28646,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.createWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async update_webhook(input) {
@@ -27665,7 +28672,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.updateWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async delete_webhook(input) {
@@ -27678,7 +28685,7 @@ function createWebhookMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async test_webhook(input) {
@@ -27695,7 +28702,7 @@ function createWebhookMcpTools(api) {
           delivery: await api.testWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async list_webhook_deliveries(input) {
@@ -27712,7 +28719,7 @@ function createWebhookMcpTools(api) {
           deliveries: await api.listWebhookDeliveries(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async retry_webhook_delivery(input) {
@@ -27724,14 +28731,14 @@ function createWebhookMcpTools(api) {
           deliveryId: String(input["deliveryId"])
         });
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     }
   };
 }
 
 // src/weekly-report-tools.ts
-function mapMcpError18(error) {
+function mapMcpError19(error) {
   if (error instanceof WeeklyReportApiError) {
     throw new Error(`mcp_tool_error:${error.code}`);
   }
@@ -27749,7 +28756,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async create_weekly_report_channel(input) {
@@ -27765,7 +28772,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async update_weekly_report_channel(input) {
@@ -27780,7 +28787,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async delete_weekly_report_channel(input) {
@@ -27792,7 +28799,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     }
   };
@@ -27861,6 +28868,7 @@ async function createDefaultMcpTools(input = {}) {
       ...createCapturePolicyMcpTools(createCapturePolicyApi(httpClient)),
       ...createImprovementSettingsMcpTools(createImprovementSettingsApi(httpClient)),
       ...createProbeMcpTools(createProbeApi(httpClient)),
+      ...createHealthCheckMcpTools(createHealthCheckApi(httpClient)),
       ...createBillingMcpTools(createBillingApi(httpClient)),
       ...createMemberMcpTools(createMemberApi(httpClient)),
       ...createGitHubMcpTools(createGitHubManagementApi(httpClient))
@@ -29160,7 +30168,7 @@ var zodToJsonSchema = (schema, options) => {
 var package_default = {
   name: "@debugbundle/mcp",
   mcpName: "com.debugbundle/mcp",
-  version: "1.4.0",
+  version: "1.5.1",
   private: false,
   description: "Model Context Protocol server for DebugBundle",
   license: "AGPL-3.0-only",
@@ -29196,6 +30204,156 @@ var package_default = {
   }
 };
 
+// src/health-check-tool-catalog.ts
+var HEALTH_CHECK_MCP_TOOL_CATALOG = [
+  {
+    name: "list_health_checks",
+    group: "health_checks",
+    description: "List hosted health checks for a project.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      limit: external_exports.number().optional()
+    })
+  },
+  {
+    name: "get_health_check",
+    group: "health_checks",
+    description: "Get one hosted health check by id.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      checkId: external_exports.string()
+    })
+  },
+  {
+    name: "create_health_check",
+    group: "health_checks",
+    description: "Create a hosted health check for a project.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      name: external_exports.string(),
+      url: external_exports.string(),
+      method: external_exports.enum(["GET", "HEAD"]).optional(),
+      expectedStatusMin: external_exports.number().optional(),
+      expectedStatusMax: external_exports.number().optional(),
+      timeoutMs: external_exports.number().optional(),
+      intervalSeconds: external_exports.number(),
+      failureThreshold: external_exports.number().optional(),
+      recoveryThreshold: external_exports.number().optional(),
+      environment: external_exports.string().optional(),
+      serviceName: external_exports.string().nullable().optional(),
+      enabled: external_exports.boolean().optional()
+    })
+  },
+  {
+    name: "update_health_check",
+    group: "health_checks",
+    description: "Update a hosted health check.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      checkId: external_exports.string(),
+      name: external_exports.string().optional(),
+      url: external_exports.string().optional(),
+      method: external_exports.enum(["GET", "HEAD"]).optional(),
+      expectedStatusMin: external_exports.number().optional(),
+      expectedStatusMax: external_exports.number().optional(),
+      timeoutMs: external_exports.number().optional(),
+      intervalSeconds: external_exports.number().optional(),
+      failureThreshold: external_exports.number().optional(),
+      recoveryThreshold: external_exports.number().optional(),
+      environment: external_exports.string().optional(),
+      serviceName: external_exports.string().nullable().optional(),
+      enabled: external_exports.boolean().optional()
+    })
+  },
+  {
+    name: "delete_health_check",
+    group: "health_checks",
+    description: "Delete a hosted health check.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      checkId: external_exports.string()
+    })
+  },
+  {
+    name: "test_health_check",
+    group: "health_checks",
+    description: "Run a side-effect-free test for a hosted health-check target.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      url: external_exports.string(),
+      method: external_exports.enum(["GET", "HEAD"]).optional(),
+      expectedStatusMin: external_exports.number().optional(),
+      expectedStatusMax: external_exports.number().optional(),
+      timeoutMs: external_exports.number().optional()
+    })
+  },
+  {
+    name: "list_health_check_results",
+    group: "health_checks",
+    description: "List recent execution results for one hosted health check.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      checkId: external_exports.string(),
+      limit: external_exports.number().optional()
+    })
+  },
+  {
+    name: "list_health_check_daily_rollups",
+    group: "health_checks",
+    description: "List retained per-day history for one hosted health check.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      checkId: external_exports.string(),
+      limit: external_exports.number().optional()
+    })
+  }
+];
+
+// src/probe-tool-catalog.ts
+var PROBE_MCP_TOOL_CATALOG = [
+  {
+    name: "activate_probe",
+    group: "probes",
+    description: "Activate a remote probe on a project.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      labelPattern: external_exports.string(),
+      service: external_exports.string().optional(),
+      environment: external_exports.string().optional(),
+      ttlSeconds: external_exports.number().optional(),
+      triggerTtlSeconds: external_exports.number().optional()
+    })
+  },
+  {
+    name: "list_active_probes",
+    group: "probes",
+    description: "List active probe activations for a project.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string()
+    })
+  },
+  {
+    name: "deactivate_probe",
+    group: "probes",
+    description: "Deactivate a probe activation.",
+    inputSchema: external_exports.object({
+      bearerToken: external_exports.string(),
+      projectId: external_exports.string(),
+      activationId: external_exports.string()
+    })
+  }
+];
+
 // src/tool-catalog.ts
 var jsonObjectSchema = external_exports.record(external_exports.unknown());
 var optionalBearerTokenSchema = external_exports.string().optional();
@@ -29953,39 +31111,8 @@ var MCP_TOOL_CATALOG = [
       })
     })
   },
-  {
-    name: "activate_probe",
-    group: "probes",
-    description: "Activate a remote probe on a project.",
-    inputSchema: external_exports.object({
-      bearerToken: external_exports.string(),
-      projectId: external_exports.string(),
-      labelPattern: external_exports.string(),
-      service: external_exports.string().optional(),
-      environment: external_exports.string().optional(),
-      ttlSeconds: external_exports.number().optional(),
-      triggerTtlSeconds: external_exports.number().optional()
-    })
-  },
-  {
-    name: "list_active_probes",
-    group: "probes",
-    description: "List active probe activations for a project.",
-    inputSchema: external_exports.object({
-      bearerToken: external_exports.string(),
-      projectId: external_exports.string()
-    })
-  },
-  {
-    name: "deactivate_probe",
-    group: "probes",
-    description: "Deactivate a probe activation.",
-    inputSchema: external_exports.object({
-      bearerToken: external_exports.string(),
-      projectId: external_exports.string(),
-      activationId: external_exports.string()
-    })
-  },
+  ...PROBE_MCP_TOOL_CATALOG,
+  ...HEALTH_CHECK_MCP_TOOL_CATALOG,
   {
     name: "get_billing_summary",
     group: "billing",