@debugbundle/mcp 1.4.0 → 1.5.0

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",
@@ -19048,6 +19156,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 +20393,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 +20799,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 +20826,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 +21119,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,12 +22048,257 @@ 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
+// ../../packages/storage/src/availability-check-schema-migrations.ts
+var import_node_crypto3 = require("node:crypto");
+function defineAvailabilityCheckStorageSchemaMigration(input) {
+  return {
+    ...input,
+    checksum: (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(input)).digest("hex")
+  };
+}
+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 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,
+          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,
+          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,
+          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()
+        )
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_method_check
+      `,
+      `
+        ALTER TABLE availability_checks
+        ADD CONSTRAINT availability_checks_method_check
+        CHECK (method IN ('GET', 'HEAD'))
+      `,
+      `
+        ALTER TABLE availability_checks
+        DROP CONSTRAINT IF EXISTS availability_checks_expected_status_min_check
+      `,
+      `
+        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_crypto3.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
+  return (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
 }
 function defineStorageSchemaMigration(input) {
   return {
@@ -22457,15 +23127,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 +24353,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 +24387,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 +25018,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 +25427,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 +27211,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 +27398,7 @@ function createProjectMcpTools(api) {
         }
         return { projects: await api.listProjects(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async create_project(input) {
@@ -26543,7 +27413,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.createProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async update_project(input) {
@@ -26563,7 +27433,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.updateProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async delete_project(input) {
@@ -26575,7 +27445,7 @@ function createProjectMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     }
   };
@@ -26782,7 +27652,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 +27842,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidents.incidents.map((incident) => attachSourceToRecord(incident, "cloud"))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident(input) {
@@ -27007,7 +27877,7 @@ function createRetrievalMcpTools(api) {
           )
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident_context(input) {
@@ -27036,7 +27906,7 @@ function createRetrievalMcpTools(api) {
           "cloud"
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incident(input) {
@@ -27081,7 +27951,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incidents(input) {
@@ -27142,7 +28012,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incident(input) {
@@ -27187,7 +28057,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incidents(input) {
@@ -27248,7 +28118,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_bundle(input) {
@@ -27279,7 +28149,7 @@ function createRetrievalMcpTools(api) {
           }
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_logs(input) {
@@ -27299,7 +28169,7 @@ function createRetrievalMcpTools(api) {
         }
         return await api.getLogs(requestInput);
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_reproduction(input) {
@@ -27330,14 +28200,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 +28228,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 +28250,7 @@ async function runJsonCommand2(command) {
     const result = await command();
     return parseJsonOutput2(result.output);
   } catch {
-    mapMcpError14();
+    mapMcpError15();
   }
 }
 function createSetupMcpTools(commands) {
@@ -27439,7 +28309,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 +28326,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async get_slack_connect_url(input) {
@@ -27469,7 +28339,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async test_slack_destination(input) {
@@ -27482,7 +28352,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async delete_slack_destination(input) {
@@ -27495,14 +28365,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 +28393,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listProjectTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_project_token(input) {
@@ -27538,7 +28408,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_project_token(input) {
@@ -27551,7 +28421,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async list_member_tokens(input) {
@@ -27566,7 +28436,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listMemberTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_member_token(input) {
@@ -27578,7 +28448,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_member_token(input) {
@@ -27590,14 +28460,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 +28488,7 @@ function createWebhookMcpTools(api) {
           webhooks: await api.listWebhooks(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async create_webhook(input) {
@@ -27639,7 +28509,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.createWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async update_webhook(input) {
@@ -27665,7 +28535,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.updateWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async delete_webhook(input) {
@@ -27678,7 +28548,7 @@ function createWebhookMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async test_webhook(input) {
@@ -27695,7 +28565,7 @@ function createWebhookMcpTools(api) {
           delivery: await api.testWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async list_webhook_deliveries(input) {
@@ -27712,7 +28582,7 @@ function createWebhookMcpTools(api) {
           deliveries: await api.listWebhookDeliveries(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async retry_webhook_delivery(input) {
@@ -27724,14 +28594,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 +28619,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async create_weekly_report_channel(input) {
@@ -27765,7 +28635,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async update_weekly_report_channel(input) {
@@ -27780,7 +28650,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async delete_weekly_report_channel(input) {
@@ -27792,7 +28662,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     }
   };
@@ -27861,6 +28731,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 +30031,7 @@ var zodToJsonSchema = (schema, options) => {
 var package_default = {
   name: "@debugbundle/mcp",
   mcpName: "com.debugbundle/mcp",
-  version: "1.4.0",
+  version: "1.5.0",
   private: false,
   description: "Model Context Protocol server for DebugBundle",
   license: "AGPL-3.0-only",
@@ -29196,6 +30067,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 +30974,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",