@debugbundle/mcp 1.3.0 → 1.5.0

package/dist/main.cjs

@@ -15090,6 +15090,10 @@ function createGitHubManagementApi(client) {
 
 // ../../packages/project-management-client/src/index.ts
 var ProjectMetricsSchema = external_exports.object({
+  open_incidents: external_exports.number().int().nonnegative().default(0),
+  regressed_incidents: external_exports.number().int().nonnegative().default(0),
+  opened_incidents_today: external_exports.number().int().nonnegative().default(0),
+  opened_incidents_month: external_exports.number().int().nonnegative().default(0),
   monthly_bundle_requests: external_exports.number().int().nonnegative(),
   monthly_raw_ingested_events: external_exports.number().int().nonnegative(),
   retained_bundles: external_exports.number().int().nonnegative(),
@@ -15485,6 +15489,9 @@ function createRetrievalApi(client) {
       if (input.severity !== void 0) {
         query.set("severity", input.severity);
       }
+      if (input.firstSeenAfter !== void 0) {
+        query.set("first_seen_after", input.firstSeenAfter);
+      }
       if (input.cursor !== void 0) {
         query.set("cursor", input.cursor);
       }
@@ -16477,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",
@@ -16722,6 +16836,7 @@ function isRouteOnlyExternalProbe(normalizedRoute) {
     "/__debug__/render_panel",
     "/actuator",
     "/autodiscover/autodiscover.json",
+    "/containers/json",
     "/developmentserver/metadatauploader",
     "/cpanel",
     "/favicon.ico",
@@ -19041,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");
@@ -20095,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");
 
@@ -20126,6 +20424,88 @@ var DebugbundleNdjsonStructuredEntrySchema = external_exports.object({
   service: external_exports.string().min(1)
 });
 
+// ../../packages/storage/src/account-analytics-store.ts
+var ACCOUNT_METRIC_KEYS = [
+  "account_created",
+  "account_deleted",
+  "project_created",
+  "project_deleted",
+  "raw_events_accepted",
+  "raw_events_rejected",
+  "events_rejected_malformed",
+  "events_rejected_rate_limited",
+  "events_rejected_quota",
+  "events_rejected_capture_policy",
+  "events_rejected_capture_rule",
+  "billable_events_counted",
+  "incident_signal_events_counted",
+  "context_signal_events_counted",
+  "operational_signal_events_counted",
+  "local_verification_events_accepted",
+  "cloud_verification_events_accepted",
+  "incidents_opened",
+  "incidents_resolved",
+  "incidents_reopened",
+  "incidents_regressed",
+  "incident_occurrences",
+  "incident_occurrences_high_severity",
+  "incident_occurrences_critical_severity",
+  "incidents_auto_detected_spiking",
+  "failure_bundles_created",
+  "failure_bundles_updated",
+  "failure_bundle_generations_failed",
+  "improvement_bundles_created",
+  "improvement_bundles_updated",
+  "improvement_bundle_generations_failed",
+  "reproductions_created",
+  "reproductions_failed",
+  "retention_bundle_owners_rotated",
+  "improvements_opened",
+  "improvements_resolved",
+  "improvements_reopened",
+  "improvements_snoozed",
+  "recurring_incident_improvements_opened",
+  "post_deploy_regression_improvements_opened",
+  "slow_request_improvements_opened",
+  "request_failure_improvements_opened",
+  "warning_log_improvements_opened",
+  "alert_deliveries_created",
+  "alert_deliveries_delivered",
+  "alert_deliveries_failed",
+  "alert_email_digests_sent",
+  "operational_emails_sent",
+  "weekly_reports_sent",
+  "weekly_reports_failed",
+  "webhook_deliveries_created",
+  "webhook_deliveries_delivered",
+  "webhook_deliveries_failed",
+  "webhooks_auto_disabled",
+  "github_dispatches_created",
+  "github_dispatches_delivered",
+  "github_dispatches_failed",
+  "github_dispatch_rules_created",
+  "github_dispatch_rules_deleted",
+  "remote_probe_activations_created",
+  "remote_probe_activations_expired",
+  "probe_events_accepted",
+  "capture_rules_created",
+  "capture_rules_deleted",
+  "capture_policy_updates",
+  "trial_started",
+  "trial_converted",
+  "trial_expired",
+  "plan_upgraded",
+  "plan_downgraded",
+  "capacity_units_purchased",
+  "capacity_units_reduced",
+  "allowance_warning_emails_sent",
+  "allowance_limit_emails_sent",
+  "projects_existing_at_account_deletion",
+  "open_incidents_existing_at_account_deletion",
+  "open_improvements_existing_at_account_deletion"
+];
+var AccountMetricKeySchema = external_exports.enum(ACCOUNT_METRIC_KEYS);
+
 // ../../packages/storage/src/incident-context.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -20411,11 +20791,24 @@ function deriveIncidentReasonFromSourceEventTypes(eventTypes) {
 // ../../packages/auth/src/primitives.ts
 var import_argon2 = require("@node-rs/argon2");
 
+// ../../packages/auth/src/account-deletion-auth.ts
+var DEFAULT_ACCOUNT_DELETION_CODE_LIFETIME_MS = 1e3 * 60 * 10;
+
 // ../../packages/auth/src/web-session-auth.ts
 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);
 
@@ -20433,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 = [
@@ -20603,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
@@ -20635,6 +21152,26 @@ var STORAGE_BOOTSTRAP_STATEMENTS = [
     CREATE INDEX email_auth_challenges_code_hash_idx
     ON email_auth_challenges (code_hash)
   `,
+  `
+    CREATE TABLE account_deletion_challenges (
+      id uuid PRIMARY KEY,
+      organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+      user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      email text NOT NULL,
+      code_hash text NOT NULL,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      expires_at timestamptz NOT NULL,
+      used_at timestamptz
+    )
+  `,
+  `
+    CREATE INDEX account_deletion_challenges_scope_idx
+    ON account_deletion_challenges (organization_id, user_id, lower(email), created_at DESC)
+  `,
+  `
+    CREATE INDEX account_deletion_challenges_code_hash_idx
+    ON account_deletion_challenges (code_hash)
+  `,
   `
     CREATE TABLE github_device_authorizations (
       id uuid PRIMARY KEY,
@@ -21345,6 +21882,103 @@ var STORAGE_BOOTSTRAP_STATEMENTS = [
       PRIMARY KEY (organization_id, period_starts_at)
     )
   `,
+  `
+    CREATE TABLE project_usage_counters (
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      period_starts_at timestamptz NOT NULL,
+      raw_ingested_events integer NOT NULL DEFAULT 0,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (project_id, period_starts_at)
+    )
+  `,
+  `
+    CREATE TABLE account_analytics_accounts (
+      analytics_account_id uuid PRIMARY KEY,
+      organization_id uuid UNIQUE,
+      organization_id_hash text NOT NULL UNIQUE,
+      created_at timestamptz NOT NULL,
+      first_seen_at timestamptz NOT NULL,
+      metrics_collection_started_at timestamptz NOT NULL,
+      backfilled_from_retained_rows_at timestamptz,
+      deleted_at timestamptz,
+      initial_plan text,
+      latest_known_plan text,
+      latest_capacity_units integer,
+      account_deleted boolean NOT NULL DEFAULT false,
+      metrics_schema_version integer NOT NULL DEFAULT 1,
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `,
+  `
+    CREATE TABLE account_metric_periods (
+      analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+      period_grain text NOT NULL CHECK (period_grain IN ('day', 'month', 'year', 'lifetime')),
+      period_starts_at timestamptz NOT NULL,
+      metric_key text NOT NULL,
+      metric_value bigint NOT NULL DEFAULT 0,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (analytics_account_id, period_grain, period_starts_at, metric_key)
+    )
+  `,
+  `
+    CREATE INDEX account_metric_periods_grain_period_metric_idx
+    ON account_metric_periods (period_grain, period_starts_at, metric_key)
+  `,
+  `
+    CREATE INDEX account_metric_periods_account_grain_period_idx
+    ON account_metric_periods (analytics_account_id, period_grain, period_starts_at)
+  `,
+  `
+    CREATE TABLE account_metric_events (
+      dedupe_key_hash text PRIMARY KEY,
+      analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+      metric_source text NOT NULL,
+      occurred_at timestamptz NOT NULL,
+      recorded_at timestamptz NOT NULL DEFAULT now(),
+      metric_deltas jsonb NOT NULL
+    )
+  `,
+  `
+    CREATE TABLE account_payment_retention_records (
+      id uuid PRIMARY KEY,
+      analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+      organization_id_hash text NOT NULL,
+      provider text NOT NULL,
+      plan text,
+      billing_state text,
+      stripe_customer_id text,
+      stripe_subscription_id text,
+      billing_period_starts_at timestamptz,
+      billing_period_ends_at timestamptz,
+      additional_capacity_units integer,
+      last_billing_event_id text,
+      account_deleted_at timestamptz NOT NULL,
+      recorded_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      UNIQUE (analytics_account_id, provider)
+    )
+  `,
+  `
+    CREATE INDEX account_payment_retention_records_provider_idx
+    ON account_payment_retention_records (provider, account_deleted_at DESC)
+  `,
+  `
+    CREATE TABLE account_payment_provider_events (
+      provider_event_key text PRIMARY KEY,
+      analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+      organization_id_hash text NOT NULL,
+      provider text NOT NULL,
+      provider_event_id text NOT NULL,
+      provider_event_type text NOT NULL,
+      processed_at timestamptz NOT NULL,
+      account_deleted_at timestamptz NOT NULL,
+      recorded_at timestamptz NOT NULL DEFAULT now()
+    )
+  `,
+  `
+    CREATE UNIQUE INDEX account_payment_provider_events_provider_event_key
+    ON account_payment_provider_events (provider, provider_event_id)
+  `,
   `
     CREATE TABLE operational_email_deliveries (
       id uuid PRIMARY KEY,
@@ -21414,51 +22048,296 @@ 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
+        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_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)
       `,
       `
@@ -22113,15 +22992,182 @@ var STORAGE_SCHEMA_MIGRATIONS = [
     statements: [
       "ALTER TABLE capture_policies ADD COLUMN IF NOT EXISTS immediate_client_error_path_rules jsonb"
     ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202606100001_add_project_usage_counters",
+    description: "Add durable project-level raw ingestion counters for project dashboard metrics.",
+    statements: [
+      `
+        CREATE TABLE IF NOT EXISTS project_usage_counters (
+          project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+          period_starts_at timestamptz NOT NULL,
+          raw_ingested_events integer NOT NULL DEFAULT 0,
+          updated_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (project_id, period_starts_at)
+        )
+      `
+    ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202606100002_add_account_deletion_challenges",
+    description: "Add scoped OTP challenges for account deletion confirmation.",
+    statements: [
+      `
+        CREATE TABLE IF NOT EXISTS account_deletion_challenges (
+          id uuid PRIMARY KEY,
+          organization_id uuid NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+          user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+          email text NOT NULL,
+          code_hash text NOT NULL,
+          created_at timestamptz NOT NULL DEFAULT now(),
+          expires_at timestamptz NOT NULL,
+          used_at timestamptz
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS account_deletion_challenges_scope_idx
+        ON account_deletion_challenges (organization_id, user_id, lower(email), created_at DESC)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS account_deletion_challenges_code_hash_idx
+        ON account_deletion_challenges (code_hash)
+      `
+    ]
+  }),
+  defineStorageSchemaMigration({
+    id: "202606100003_add_account_analytics_and_payment_retention",
+    description: "Add deletion-safe account analytics and payment retention ledgers.",
+    statements: [
+      `
+        CREATE TABLE IF NOT EXISTS account_analytics_accounts (
+          analytics_account_id uuid PRIMARY KEY,
+          organization_id uuid UNIQUE,
+          organization_id_hash text NOT NULL UNIQUE,
+          created_at timestamptz NOT NULL,
+          first_seen_at timestamptz NOT NULL,
+          metrics_collection_started_at timestamptz NOT NULL,
+          backfilled_from_retained_rows_at timestamptz,
+          deleted_at timestamptz,
+          initial_plan text,
+          latest_known_plan text,
+          latest_capacity_units integer,
+          account_deleted boolean NOT NULL DEFAULT false,
+          metrics_schema_version integer NOT NULL DEFAULT 1,
+          updated_at timestamptz NOT NULL DEFAULT now()
+        )
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS account_metric_periods (
+          analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+          period_grain text NOT NULL CHECK (period_grain IN ('day', 'month', 'year', 'lifetime')),
+          period_starts_at timestamptz NOT NULL,
+          metric_key text NOT NULL,
+          metric_value bigint NOT NULL DEFAULT 0,
+          updated_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (analytics_account_id, period_grain, period_starts_at, metric_key)
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS account_metric_periods_grain_period_metric_idx
+        ON account_metric_periods (period_grain, period_starts_at, metric_key)
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS account_metric_periods_account_grain_period_idx
+        ON account_metric_periods (analytics_account_id, period_grain, period_starts_at)
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS account_metric_events (
+          dedupe_key_hash text PRIMARY KEY,
+          analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+          metric_source text NOT NULL,
+          occurred_at timestamptz NOT NULL,
+          recorded_at timestamptz NOT NULL DEFAULT now(),
+          metric_deltas jsonb NOT NULL
+        )
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS account_payment_retention_records (
+          id uuid PRIMARY KEY,
+          analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+          organization_id_hash text NOT NULL,
+          provider text NOT NULL,
+          plan text,
+          billing_state text,
+          stripe_customer_id text,
+          stripe_subscription_id text,
+          billing_period_starts_at timestamptz,
+          billing_period_ends_at timestamptz,
+          additional_capacity_units integer,
+          last_billing_event_id text,
+          account_deleted_at timestamptz NOT NULL,
+          recorded_at timestamptz NOT NULL DEFAULT now(),
+          updated_at timestamptz NOT NULL DEFAULT now(),
+          UNIQUE (analytics_account_id, provider)
+        )
+      `,
+      `
+        CREATE INDEX IF NOT EXISTS account_payment_retention_records_provider_idx
+        ON account_payment_retention_records (provider, account_deleted_at DESC)
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS account_payment_provider_events (
+          provider_event_key text PRIMARY KEY,
+          analytics_account_id uuid NOT NULL REFERENCES account_analytics_accounts(analytics_account_id),
+          organization_id_hash text NOT NULL,
+          provider text NOT NULL,
+          provider_event_id text NOT NULL,
+          provider_event_type text NOT NULL,
+          processed_at timestamptz NOT NULL,
+          account_deleted_at timestamptz NOT NULL,
+          recorded_at timestamptz NOT NULL DEFAULT now()
+        )
+      `,
+      `
+        CREATE UNIQUE INDEX IF NOT EXISTS account_payment_provider_events_provider_event_key
+        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");
 
@@ -23307,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) {
@@ -23341,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,
@@ -23972,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) {
@@ -24185,7 +25231,7 @@ async function listLocalIncidents(input, dependencies) {
       return true;
     }
     return incident.status === input.status;
-  }).filter((incident) => input.severity === void 0 ? true : incident.severity === input.severity).sort(sortIncidentsDescending);
+  }).filter((incident) => input.severity === void 0 ? true : incident.severity === input.severity).filter((incident) => input.firstSeenAfter === void 0 ? true : incident.first_seen_at >= input.firstSeenAfter).sort(sortIncidentsDescending);
   const startIndex = input.cursor === void 0 ? 0 : incidents.findIndex((incident) => buildCursor(incident) === input.cursor) + 1;
   const pagedIncidents = input.limit === void 0 ? incidents.slice(startIndex) : incidents.slice(startIndex, startIndex + input.limit);
   const hasMore = input.limit !== void 0 && startIndex + input.limit < incidents.length;
@@ -24381,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);
@@ -26165,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}`);
   }
@@ -26184,7 +27398,7 @@ function createProjectMcpTools(api) {
         }
         return { projects: await api.listProjects(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async create_project(input) {
@@ -26199,7 +27413,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.createProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async update_project(input) {
@@ -26219,7 +27433,7 @@ function createProjectMcpTools(api) {
         }
         return { project: await api.updateProject(requestInput) };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     },
     async delete_project(input) {
@@ -26231,7 +27445,7 @@ function createProjectMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError11(error);
+        mapMcpError12(error);
       }
     }
   };
@@ -26438,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}`);
   }
@@ -26496,6 +27710,9 @@ function readIncidentListFilters(input) {
   if (typeof input["severity"] === "string") {
     requestInput.severity = input["severity"];
   }
+  if (typeof input["firstSeenAfter"] === "string") {
+    requestInput.firstSeenAfter = input["firstSeenAfter"];
+  }
   if (typeof input["cursor"] === "string") {
     requestInput.cursor = input["cursor"];
   }
@@ -26516,6 +27733,7 @@ async function listAllCloudIncidents(input, api) {
       ...filters.service === void 0 ? {} : { service: filters.service },
       ...filters.status === void 0 ? {} : { status: filters.status },
       ...filters.severity === void 0 ? {} : { severity: filters.severity },
+      ...filters.firstSeenAfter === void 0 ? {} : { firstSeenAfter: filters.firstSeenAfter },
       ...cursor === void 0 ? {} : { cursor }
     });
     incidents.push(...response.incidents.map((incident) => attachSourceToRecord(incident, "cloud")));
@@ -26577,7 +27795,8 @@ function createRetrievalMcpTools(api) {
             ...incidentFilters.environment === void 0 ? {} : { environment: incidentFilters.environment },
             ...incidentFilters.service === void 0 ? {} : { service: incidentFilters.service },
             ...incidentFilters.status === void 0 ? {} : { status: incidentFilters.status },
-            ...incidentFilters.severity === void 0 ? {} : { severity: incidentFilters.severity }
+            ...incidentFilters.severity === void 0 ? {} : { severity: incidentFilters.severity },
+            ...incidentFilters.firstSeenAfter === void 0 ? {} : { firstSeenAfter: incidentFilters.firstSeenAfter }
           });
           const cloudIncidents = await listAllCloudIncidents(input, {
             listIncidents: (requestInput2) => api.listIncidents(requestInput2)
@@ -26608,6 +27827,9 @@ function createRetrievalMcpTools(api) {
         if (incidentFilters.severity !== void 0) {
           requestInput.severity = incidentFilters.severity;
         }
+        if (incidentFilters.firstSeenAfter !== void 0) {
+          requestInput.firstSeenAfter = incidentFilters.firstSeenAfter;
+        }
         if (incidentFilters.cursor !== void 0) {
           requestInput.cursor = incidentFilters.cursor;
         }
@@ -26620,7 +27842,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidents.incidents.map((incident) => attachSourceToRecord(incident, "cloud"))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident(input) {
@@ -26655,7 +27877,7 @@ function createRetrievalMcpTools(api) {
           )
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_incident_context(input) {
@@ -26684,7 +27906,7 @@ function createRetrievalMcpTools(api) {
           "cloud"
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incident(input) {
@@ -26729,7 +27951,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async resolve_incidents(input) {
@@ -26790,7 +28012,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incident(input) {
@@ -26835,7 +28057,7 @@ function createRetrievalMcpTools(api) {
           })()
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async reopen_incidents(input) {
@@ -26896,7 +28118,7 @@ function createRetrievalMcpTools(api) {
           incidents: incidentIds.map((incidentId) => localIncidents.get(incidentId))
         };
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_bundle(input) {
@@ -26927,7 +28149,7 @@ function createRetrievalMcpTools(api) {
           }
         );
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_logs(input) {
@@ -26947,7 +28169,7 @@ function createRetrievalMcpTools(api) {
         }
         return await api.getLogs(requestInput);
       } catch (error) {
-        mapMcpError12(error);
+        mapMcpError13(error);
       }
     },
     async get_reproduction(input) {
@@ -26978,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}`);
   }
@@ -27006,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) {
@@ -27028,7 +28250,7 @@ async function runJsonCommand2(command) {
     const result = await command();
     return parseJsonOutput2(result.output);
   } catch {
-    mapMcpError14();
+    mapMcpError15();
   }
 }
 function createSetupMcpTools(commands) {
@@ -27087,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}`);
   }
@@ -27104,7 +28326,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async get_slack_connect_url(input) {
@@ -27117,7 +28339,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async test_slack_destination(input) {
@@ -27130,7 +28352,7 @@ function createSlackMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError15(error);
+        mapMcpError16(error);
       }
     },
     async delete_slack_destination(input) {
@@ -27143,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}`);
   }
@@ -27171,7 +28393,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listProjectTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_project_token(input) {
@@ -27186,7 +28408,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_project_token(input) {
@@ -27199,7 +28421,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async list_member_tokens(input) {
@@ -27214,7 +28436,7 @@ function createTokenMcpTools(api) {
           tokens: await api.listMemberTokens(requestInput)
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async create_member_token(input) {
@@ -27226,7 +28448,7 @@ function createTokenMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError16(error);
+        mapMcpError17(error);
       }
     },
     async revoke_member_token(input) {
@@ -27238,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}`);
   }
@@ -27266,7 +28488,7 @@ function createWebhookMcpTools(api) {
           webhooks: await api.listWebhooks(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async create_webhook(input) {
@@ -27287,7 +28509,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.createWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async update_webhook(input) {
@@ -27313,7 +28535,7 @@ function createWebhookMcpTools(api) {
           webhook: await api.updateWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async delete_webhook(input) {
@@ -27326,7 +28548,7 @@ function createWebhookMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async test_webhook(input) {
@@ -27343,7 +28565,7 @@ function createWebhookMcpTools(api) {
           delivery: await api.testWebhook(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async list_webhook_deliveries(input) {
@@ -27360,7 +28582,7 @@ function createWebhookMcpTools(api) {
           deliveries: await api.listWebhookDeliveries(requestInput)
         };
       } catch (error) {
-        mapMcpError17(error);
+        mapMcpError18(error);
       }
     },
     async retry_webhook_delivery(input) {
@@ -27372,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}`);
   }
@@ -27397,7 +28619,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async create_weekly_report_channel(input) {
@@ -27413,7 +28635,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async update_weekly_report_channel(input) {
@@ -27428,7 +28650,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     },
     async delete_weekly_report_channel(input) {
@@ -27440,7 +28662,7 @@ function createWeeklyReportMcpTools(api) {
           })
         };
       } catch (error) {
-        mapMcpError18(error);
+        mapMcpError19(error);
       }
     }
   };
@@ -27509,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))
@@ -28808,7 +30031,7 @@ var zodToJsonSchema = (schema, options) => {
 var package_default = {
   name: "@debugbundle/mcp",
   mcpName: "com.debugbundle/mcp",
-  version: "1.3.0",
+  version: "1.5.0",
   private: false,
   description: "Model Context Protocol server for DebugBundle",
   license: "AGPL-3.0-only",
@@ -28844,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();
@@ -28862,6 +30235,7 @@ var listIncidentsInputSchema = external_exports.object({
   service: external_exports.string().optional(),
   status: external_exports.string().optional(),
   severity: external_exports.string().optional(),
+  firstSeenAfter: external_exports.string().optional(),
   cursor: external_exports.string().optional(),
   limit: external_exports.number().optional()
 });
@@ -29600,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",