@belvador/mcp 0.3.0 → 0.5.0

package/dist/cli.js

@@ -124,8 +124,12 @@ var API_ERROR_STATUS = {
   INCIDENT_STATE_INVALID: 409,
   NOTIFICATION_POLICY_INVALID: 400,
   COVERAGE_EXPECTATION_INVALID: 400,
+  COVERAGE_SIGNAL_UNAVAILABLE: 400,
+  COVERAGE_CODE_OWNED: 409,
+  COVERAGE_LIMIT: 409,
   PRIVACY_RULE_INVALID: 400,
   PRIVACY_REGEX_UNSAFE: 400,
+  PRIVACY_VERSION_CONFLICT: 409,
   METRIC_CARDINALITY_LIMIT: 429,
   RELEASE_NOT_FOUND: 404,
   PUBLIC_API_PAUSED: 503,
@@ -178,7 +182,7 @@ function cleanUntrustedText(raw, maxBytes = MCP_LIMITS.untrustedStringMaxBytes)
   const { text, cut } = cutUtf8(escaped, maxBytes);
   return { text, cut, suspicious };
 }
-var MCP_TOOLS_VERSION = 3;
+var MCP_TOOLS_VERSION = 5;
 var MCP_TOOLS = [
   { name: "get_workspace", toolset: "investigate", scope: "org:read", readOnly: true, destructive: false, idempotent: true },
   { name: "list_projects", toolset: "investigate", scope: "projects:read", readOnly: true, destructive: false, idempotent: true },
@@ -208,9 +212,7 @@ var MCP_TOOLS = [
   { name: "get_doc", toolset: "docs", scope: null, readOnly: true, destructive: false, idempotent: true }
 ];
 var MCP_TOOLS_PENDING = {
-  query_metrics: "P14",
-  release_health: "P15",
-  get_coverage: "P10"
+  release_health: "P15"
 };
 
 // ../src/shared/mcp/docs.ts
@@ -255,7 +257,7 @@ function docsFetcher(siteUrl, fetcher = fetch, now = () => Date.now()) {
 import { CLIENT_CAPABILITIES_META_KEY, inputRequired, McpServer } from "@modelcontextprotocol/server";
 
 // ../src/shared/contracts/mcp-tools.ts
-import { z as z24 } from "zod";
+import { z as z29 } from "zod";
 
 // ../src/shared/contracts/api-ops/access.ts
 import { z as z3 } from "zod";
@@ -643,7 +645,8 @@ var MONITOR_RULE_KINDS = [
   "count",
   "assertion",
   "deadline",
-  "stalled"
+  "stalled",
+  "metric"
 ];
 var SLO_RULE_SEVERITIES = ["page", "ticket"];
 function validRuleTriggers(triggers) {
@@ -862,14 +865,297 @@ var ALERT_OPERATIONS = [
   })
 ];
 
+// ../src/shared/contracts/api-ops/coverage.ts
+import { z as z8 } from "zod";
+
+// ../src/shared/contracts/coverage.ts
+import { z as z7 } from "zod";
+
+// ../src/shared/contracts/integration-health.ts
+import { z as z6 } from "zod";
+
+// ../src/shared/contracts/platforms.ts
+var PLATFORMS = [
+  "javascript-browser",
+  "react",
+  "node",
+  "python",
+  "tanstack-start",
+  "other"
+];
+
+// ../src/shared/contracts/integration-health.ts
+var VERIFICATION_ID_RE = /^bv1_[0-9a-f]{32}$/;
+var verificationIdSchema = z6.string().regex(VERIFICATION_ID_RE);
+var SURFACES = ["browser", "server"];
+var RECEIPT_SURFACES = ["browser", "server", "belvador"];
+var CHECKS = ["delivery", "uncaught", "pipeline"];
+var HOOK_STATES = ["ok", "missing", "unknown"];
+var verificationContextSchema = z6.object({
+  v: z6.literal(1),
+  surface: z6.enum(RECEIPT_SURFACES),
+  check: z6.enum(CHECKS),
+  hook: z6.enum(HOOK_STATES).optional(),
+  uncaught_expected: z6.boolean().optional()
+});
+var iso = z6.string().datetime();
+var projectId2 = z6.number().int().positive();
+var verificationReceiptSchema = z6.object({
+  project_id: projectId2,
+  verification_id: verificationIdSchema,
+  surface: z6.enum(RECEIPT_SURFACES),
+  check: z6.enum(CHECKS),
+  hook: z6.enum(HOOK_STATES),
+  uncaught_expected: z6.boolean(),
+  sdk_name: z6.string().max(80),
+  sdk_version: z6.string().max(40),
+  environment: z6.string().max(64),
+  release: z6.string().max(200),
+  source_host: z6.string().max(253),
+  received_at: iso
+});
+var SDK_DELIVERY_DROP_REASONS = ["network_error", "queue_overflow", "send_error"];
+var clientDiscardSchema = z6.object({
+  hour: iso,
+  reason: z6.enum(SDK_DELIVERY_DROP_REASONS),
+  n: z6.number().int().nonnegative()
+});
+var edgeVerificationRequestSchema = z6.object({
+  v: z6.literal(1),
+  project_id: projectId2,
+  verification_id: verificationIdSchema
+});
+var readbackCheckSchema = z6.object({
+  surface: z6.enum(RECEIPT_SURFACES),
+  check: z6.enum(CHECKS),
+  hook: z6.enum(HOOK_STATES),
+  received_at: iso
+});
+var edgeVerificationResponseSchema = z6.object({
+  checks: z6.array(readbackCheckSchema).max(8)
+});
+var readbackResponseSchema = z6.object({
+  v: z6.literal(1),
+  verification_id: verificationIdSchema,
+  node: z6.enum(["connected", "offline"]),
+  checks: z6.array(readbackCheckSchema).max(8)
+});
+var ENVIRONMENT_RE = /^[^\u0000-\u001f]{1,64}$/;
+var projectRuntimeSchema = z6.object({
+  project_id: projectId2,
+  environment: z6.string().max(64),
+  surface: z6.enum(SURFACES),
+  sdk_name: z6.string().max(80),
+  sdk_version: z6.string().max(40),
+  latest_release: z6.string().max(200),
+  first_seen: iso,
+  last_seen: iso,
+  events_24h: z6.number().int().nonnegative(),
+  check_ins_24h: z6.number().int().nonnegative()
+});
+
+// ../src/shared/contracts/vocab/coverage.ts
+var COVERAGE_SURFACES = [
+  "browser",
+  "server",
+  "worker",
+  "job",
+  "edge_function",
+  "database",
+  "uptime"
+];
+var COVERAGE_SIGNALS = [
+  "errors",
+  "traces",
+  "logs",
+  "metrics",
+  "check_ins",
+  "web_vitals",
+  "probes"
+];
+var COVERAGE_STATUSES = ["verified", "stale", "problem", "unknown"];
+var COVERAGE_SOURCES = ["ui", "code"];
+
+// ../src/shared/contracts/coverage.ts
+var SURFACE_SIGNALS = {
+  browser: ["errors", "traces", "logs", "web_vitals"],
+  server: ["errors", "traces", "logs", "metrics"],
+  worker: ["errors", "traces", "logs", "metrics"],
+  edge_function: ["errors", "traces", "logs", "metrics"],
+  job: ["check_ins", "errors", "traces", "logs"],
+  database: ["traces", "metrics"],
+  uptime: ["probes"]
+};
+function coveragePairOk(surface, signal) {
+  return SURFACE_SIGNALS[surface].includes(signal);
+}
+var COVERAGE_RULES = {
+  staleAfterHoursDefault: 168,
+  staleAfterHoursMin: 1,
+  staleAfterHoursMax: 720,
+  noteMax: 200,
+  evidenceRowsPerProject: 256,
+  undeclaredDays: 30,
+  resendMs: 3600000,
+  newKeyFlushMs: 60000,
+  backfillErrorsDays: 30,
+  backfillTelemetryDays: 7,
+  setMaxItems: 1000
+};
+var FAAS_CLOUD_PLATFORMS = new Set([
+  "aws_lambda",
+  "azure_functions",
+  "gcp_cloud_functions",
+  "alibaba_cloud_fc",
+  "tencent_cloud_scf"
+]);
+var FUNCTION_RUNTIMES = new Set(["cloudflare", "workerd", "vercel-edge", "edge-light"]);
+var seconds = z7.number().int().positive();
+var coverageSeenRowSchema = z7.object({
+  environment: z7.string().max(64),
+  surface: z7.enum(COVERAGE_SURFACES),
+  signal: z7.enum(COVERAGE_SIGNALS),
+  last_seen: seconds,
+  last_verified: seconds.nullable()
+}).strict();
+var coverageSeenReportSchema = z7.object({
+  project_id: z7.number().int().positive(),
+  rows: z7.array(coverageSeenRowSchema).max(COVERAGE_RULES.evidenceRowsPerProject)
+}).strict();
+var environment = z7.string().trim().regex(ENVIRONMENT_RE);
+var note = z7.string().trim().max(COVERAGE_RULES.noteMax).regex(/^[^\p{Cc}]*$/u);
+var coverageExpectationInputSchema = z7.object({
+  environment,
+  surface: z7.enum(COVERAGE_SURFACES),
+  signals: z7.array(z7.enum(COVERAGE_SIGNALS)).min(1).max(COVERAGE_SIGNALS.length),
+  staleAfterHours: z7.number().int().min(COVERAGE_RULES.staleAfterHoursMin).max(COVERAGE_RULES.staleAfterHoursMax).default(COVERAGE_RULES.staleAfterHoursDefault),
+  note: note.default("")
+}).superRefine((e, ctx) => {
+  const seen = new Set;
+  for (const s of e.signals) {
+    if (seen.has(s))
+      ctx.addIssue({ code: "custom", path: ["signals"], message: "duplicate" });
+    seen.add(s);
+    if (!coveragePairOk(e.surface, s))
+      ctx.addIssue({ code: "custom", path: ["signals"], message: `not_for_${e.surface}` });
+  }
+});
+var coverageExpectationListSchema = z7.array(coverageExpectationInputSchema).max(COVERAGE_RULES.setMaxItems).superRefine((list, ctx) => {
+  const keys = new Set;
+  list.forEach((e, i) => {
+    const k = `${e.environment}\x00${e.surface}`;
+    if (keys.has(k))
+      ctx.addIssue({ code: "custom", path: [i, "surface"], message: "duplicate" });
+    keys.add(k);
+  });
+});
+var iso2 = z7.string();
+var count = z7.number().int().nonnegative();
+var coverageCellSchema = z7.object({
+  expectation_id: z7.string(),
+  project_id: z7.number().int().positive(),
+  environment: z7.string(),
+  surface: z7.enum(COVERAGE_SURFACES),
+  signal: z7.enum(COVERAGE_SIGNALS),
+  status: z7.enum(COVERAGE_STATUSES),
+  source: z7.enum(["receipt", "signal"]).nullable(),
+  last_seen_at: iso2.nullable(),
+  last_verified_at: iso2.nullable(),
+  problem_code: z7.string().nullable()
+});
+var coverageExpectationRowSchema = z7.object({
+  expectation_id: z7.string(),
+  project_id: z7.number().int().positive(),
+  environment: z7.string(),
+  surface: z7.enum(COVERAGE_SURFACES),
+  signals: z7.array(z7.enum(COVERAGE_SIGNALS)),
+  stale_after_hours: z7.number().int(),
+  note: z7.string(),
+  config_source: z7.enum(COVERAGE_SOURCES),
+  revision: z7.number().int(),
+  updated_at: iso2
+});
+var coverageReportSchema = z7.object({
+  generated_at: iso2,
+  expectations_max: z7.number().int().nonnegative(),
+  summary: z7.object({ total: count, verified: count, stale: count, problem: count, unknown: count }),
+  projects: z7.array(z7.object({
+    project_id: z7.number().int().positive(),
+    slug: z7.string(),
+    name: z7.string(),
+    platform: z7.string(),
+    primary_environment: z7.string(),
+    config_source: z7.enum(COVERAGE_SOURCES).nullable()
+  })),
+  expectations: z7.array(coverageExpectationRowSchema),
+  cells: z7.array(coverageCellSchema),
+  undeclared: z7.array(z7.object({
+    project_id: z7.number().int().positive(),
+    environment: z7.string(),
+    surface: z7.enum(COVERAGE_SURFACES),
+    signal: z7.enum(COVERAGE_SIGNALS),
+    last_seen_at: iso2
+  })),
+  environments: z7.array(z7.string()),
+  node_agent_version: z7.string().nullable()
+});
+
+// ../src/shared/contracts/api-ops/coverage.ts
+var COVERAGE_INPUTS = {
+  get: z8.object({
+    workspaceId: uuid,
+    projectId: projectId.optional(),
+    environment: z8.string().trim().regex(ENVIRONMENT_RE).optional()
+  }),
+  set: z8.object({
+    workspaceId: uuid,
+    projectId,
+    configSource: z8.enum(COVERAGE_SOURCES).default("ui"),
+    expectations: coverageExpectationListSchema
+  })
+};
+var C = COVERAGE_INPUTS;
+var COVERAGE_OPERATIONS = [
+  op({
+    id: "coverage.get",
+    method: "GET",
+    path: "/v1/coverage",
+    scope: "coverage:read",
+    sensitivity: "normal",
+    kind: "read",
+    rpcs: ["api_read_coverage"],
+    input: C.get,
+    workspace: true,
+    idempotency: "none",
+    mcp: "reliability",
+    summary: "What each app is expected to send (surface × signal × environment) against what Belvador saw: `verified`, `stale`, `problem` or `unknown`, the verified rate, and signals seen but not declared. Same numbers as the Coverage page.",
+    ui: []
+  }),
+  op({
+    id: "coverage.set",
+    method: "PUT",
+    path: "/v1/projects/{project_id}/coverage-expectations",
+    scope: "coverage:write",
+    sensitivity: "normal",
+    kind: "write",
+    rpcs: ["set_coverage_expectations"],
+    input: C.set,
+    workspace: true,
+    idempotency: "optional",
+    mcp: "configure",
+    summary: "Replace a project's coverage expectations (one per environment × surface). `config_source: code` locks them in the app; send `ui` once to hand them back. Members and up.",
+    ui: ["coverage#setCoverageExpectations"]
+  })
+];
+
 // ../src/shared/contracts/api-ops/incidents.ts
-import { z as z10 } from "zod";
+import { z as z14 } from "zod";
 
 // ../src/shared/contracts/notifications.ts
-import { z as z9 } from "zod";
+import { z as z13 } from "zod";
 
 // ../src/shared/contracts/maintenance.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 var MAINTENANCE_SCOPES = ["workspace", "project", "monitor"];
 var MAINTENANCE_LIMITS = {
   durationMinutesMin: 5,
@@ -879,21 +1165,21 @@ var MAINTENANCE_LIMITS = {
   onceAheadDays: 366,
   previewStarts: 3
 };
-var weekdaySchema = z6.number().int().min(1).max(7);
-var timeOfDay = z6.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
+var weekdaySchema = z9.number().int().min(1).max(7);
+var timeOfDay = z9.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
 var base = {
-  scope: z6.enum(MAINTENANCE_SCOPES),
-  projectIds: z6.array(z6.number().int().positive()).max(MAINTENANCE_LIMITS.idsMax),
-  monitorIds: z6.array(z6.guid()).max(MAINTENANCE_LIMITS.idsMax),
-  timezone: z6.string().trim().min(1).max(64),
-  durationMinutes: z6.number().int().min(MAINTENANCE_LIMITS.durationMinutesMin).max(MAINTENANCE_LIMITS.durationMinutesMax),
-  reason: z6.string().trim().max(MAINTENANCE_LIMITS.reasonMax).regex(/^[^\p{Cc}]*$/u)
+  scope: z9.enum(MAINTENANCE_SCOPES),
+  projectIds: z9.array(z9.number().int().positive()).max(MAINTENANCE_LIMITS.idsMax),
+  monitorIds: z9.array(z9.guid()).max(MAINTENANCE_LIMITS.idsMax),
+  timezone: z9.string().trim().min(1).max(64),
+  durationMinutes: z9.number().int().min(MAINTENANCE_LIMITS.durationMinutesMin).max(MAINTENANCE_LIMITS.durationMinutesMax),
+  reason: z9.string().trim().max(MAINTENANCE_LIMITS.reasonMax).regex(/^[^\p{Cc}]*$/u)
 };
-var maintenanceInputSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("once"), startsAt: z6.string().datetime({ offset: true }), ...base }),
-  z6.object({
-    kind: z6.literal("weekly"),
-    weekdays: z6.array(weekdaySchema).min(1).max(7),
+var maintenanceInputSchema = z9.discriminatedUnion("kind", [
+  z9.object({ kind: z9.literal("once"), startsAt: z9.string().datetime({ offset: true }), ...base }),
+  z9.object({
+    kind: z9.literal("weekly"),
+    weekdays: z9.array(weekdaySchema).min(1).max(7),
     startTime: timeOfDay,
     ...base
   })
@@ -925,15 +1211,182 @@ function validTimeZone(tz) {
 var fmtCache = new Map;
 
 // ../src/shared/contracts/signal-monitors.ts
-import { z as z8 } from "zod";
+import { z as z12 } from "zod";
+
+// ../src/shared/contracts/metrics.ts
+import { z as z10 } from "zod";
+
+// ../src/shared/contracts/vocab/telemetry.ts
+var TELEMETRY_MAX_WINDOW_MS = 7 * 24 * 3600 * 1000;
+var ATTR_OPS = ["=", "!=", "exists"];
+var ATTR_FILTERS_MAX = 5;
+var TELEMETRY_PLAN_DEFAULTS = {
+  traces_retention_days: 7,
+  logs_retention_days: 7,
+  traces_monthly_bytes: 5 * 1000 ** 3,
+  logs_monthly_bytes: 5 * 1000 ** 3,
+  metrics_retention_days: 14,
+  metrics_monthly_bytes: 2 * 1000 ** 3,
+  metric_series_max: 1e4,
+  metric_names_max: 1000,
+  telemetry_rate_bytes_per_sec: 1024 * 1024,
+  telemetry_burst_bytes: 8 * 1024 * 1024,
+  telemetry_buffer_minutes: 15,
+  max_ingest_keys_per_project: 10
+};
+
+// ../src/shared/contracts/vocab/metrics.ts
+var METRIC_TYPES = ["gauge", "sum", "histogram", "exp_histogram"];
+var METRIC_KINDS = ["gauge", "counter", "histogram", "exp_histogram"];
+var METRIC_AGGREGATIONS = ["avg", "sum", "min", "max", "count", "rate", "p50", "p90", "p95", "p99"];
+var METRIC_NAME_RE = /^[A-Za-z_][A-Za-z0-9_.:\-/]{0,254}$/;
+var METRIC_ATTR_KEY_RE = /^[A-Za-z0-9_.:\-/@]{1,256}$/;
+var METRIC_GROUP_BY_MAX = 2;
+function defaultAggregation(kind) {
+  return kind === "counter" ? "rate" : kind === "histogram" || kind === "exp_histogram" ? "p95" : "avg";
+}
+
+// ../src/shared/contracts/metrics.ts
+var METRIC_TEMPORALITIES = ["unspecified", "delta", "cumulative"];
+var METRIC_LIMITS = {
+  attributesPerSeries: 32,
+  attributeValueMaxChars: 256,
+  nameMaxChars: 255,
+  unitMaxChars: 63,
+  descriptionMaxChars: 512,
+  bucketsMax: 320,
+  seriesActiveMs: 24 * 3600 * 1000,
+  seriesTouchMs: 3600 * 1000,
+  expMaxStoredScale: 3,
+  expMinScale: -10,
+  expMaxScale: 20,
+  resourceKeys: ["service.name", "service.namespace", "deployment.environment.name", "host.name"],
+  limitedNamesKept: 50
+};
+var METRIC_PLAN_DEFAULTS = {
+  metrics_retention_days: TELEMETRY_PLAN_DEFAULTS.metrics_retention_days,
+  metrics_monthly_bytes: TELEMETRY_PLAN_DEFAULTS.metrics_monthly_bytes,
+  metric_series_max: TELEMETRY_PLAN_DEFAULTS.metric_series_max,
+  metric_names_max: TELEMETRY_PLAN_DEFAULTS.metric_names_max
+};
+var METRIC_SERIES_MAX_RANGE = { min: 100, max: 1e6 };
+var METRIC_NAMES_MAX_RANGE = { min: 10, max: 1e5 };
+var metricsConfigSchema = z10.object({
+  retention_days: z10.number().int().min(1).max(90),
+  series_max: z10.number().int().min(METRIC_SERIES_MAX_RANGE.min).max(METRIC_SERIES_MAX_RANGE.max),
+  names_max: z10.number().int().min(METRIC_NAMES_MAX_RANGE.min).max(METRIC_NAMES_MAX_RANGE.max)
+});
+var METRIC_QUERY = {
+  filtersMax: ATTR_FILTERS_MAX,
+  groupByMax: METRIC_GROUP_BY_MAX,
+  minStepSeconds: 60,
+  maxStepSeconds: 86400,
+  maxWindowMs: 7 * 24 * 3600 * 1000,
+  defaultWindowMs: 3600 * 1000,
+  groupsMax: 50,
+  pointsMax: 1e4,
+  namesMax: 1000,
+  seriesPageSize: 100,
+  exemplarsMax: 50,
+  queryMaxSeconds: 3
+};
+var metricName = z10.string().min(1).max(METRIC_LIMITS.nameMaxChars).regex(METRIC_NAME_RE);
+var attrKey = z10.string().regex(METRIC_ATTR_KEY_RE);
+var metricFilterSchema = z10.object({
+  k: attrKey,
+  op: z10.enum(ATTR_OPS),
+  v: z10.string().max(512).optional()
+});
+var metricQuerySchema = z10.object({
+  name: metricName,
+  aggregation: z10.enum(METRIC_AGGREGATIONS),
+  filter: z10.array(metricFilterSchema).max(METRIC_QUERY.filtersMax),
+  group_by: z10.array(attrKey).max(METRIC_QUERY.groupByMax)
+}).superRefine((q, ctx) => {
+  q.filter.forEach((f, i) => {
+    if (f.op === "exists" !== (f.v === undefined))
+      ctx.addIssue({ code: "custom", path: ["filter", i, "v"], message: "value" });
+  });
+  if (new Set(q.group_by).size !== q.group_by.length)
+    ctx.addIssue({ code: "custom", path: ["group_by"], message: "unique" });
+});
+var ts = z10.string().max(40);
+var count2 = z10.coerce.number().int().nonnegative().catch(0);
+var label = z10.string().max(METRIC_LIMITS.attributeValueMaxChars);
+var completeness = {
+  complete: z10.boolean(),
+  reason: z10.enum(["time_budget", "row_cap", "groups", "points"]).optional().catch(undefined)
+};
+var metricNameRowSchema = z10.object({
+  name: metricName,
+  type: z10.enum(METRIC_TYPES),
+  kind: z10.enum(METRIC_KINDS),
+  unit: z10.string().max(METRIC_LIMITS.unitMaxChars).catch(""),
+  description: z10.string().max(METRIC_LIMITS.descriptionMaxChars).catch(""),
+  series: count2,
+  last_seen: ts
+});
+var metricCardinalitySchema = z10.object({
+  series_active: count2,
+  series_max: count2,
+  names_active: count2,
+  names_max: count2,
+  limited: z10.array(z10.object({ name: z10.string().max(METRIC_LIMITS.nameMaxChars), points: count2 })).max(METRIC_LIMITS.limitedNamesKept).catch([])
+});
+var metricNamesSchema = z10.object({
+  names: z10.array(metricNameRowSchema).max(METRIC_QUERY.namesMax),
+  cardinality: metricCardinalitySchema,
+  ...completeness
+});
+var metricSeriesRowSchema = z10.object({
+  series_id: z10.string().regex(/^[0-9a-f]{16}$/),
+  name: metricName,
+  type: z10.enum(METRIC_TYPES),
+  kind: z10.enum(METRIC_KINDS),
+  temporality: z10.enum(METRIC_TEMPORALITIES).catch("unspecified"),
+  unit: z10.string().max(METRIC_LIMITS.unitMaxChars).catch(""),
+  service: label.catch(""),
+  environment: z10.string().max(64).catch(""),
+  attributes: z10.record(z10.string().max(256), label).catch({}),
+  first_seen: ts,
+  last_seen: ts
+});
+var metricSeriesListSchema = z10.object({
+  series: z10.array(metricSeriesRowSchema).max(METRIC_QUERY.seriesPageSize),
+  next_cursor: z10.string().max(64).nullable(),
+  ...completeness
+});
+var metricExemplarSchema = z10.object({
+  t: ts,
+  value: z10.number(),
+  trace_id: z10.string().regex(/^[0-9a-f]{32}$/),
+  span_id: z10.union([z10.string().regex(/^[0-9a-f]{16}$/), z10.literal("")]),
+  group: z10.number().int().nonnegative()
+});
+var metricResultSchema = z10.object({
+  name: metricName,
+  aggregation: z10.enum(METRIC_AGGREGATIONS),
+  kind: z10.enum(METRIC_KINDS),
+  unit: z10.string().max(METRIC_LIMITS.unitMaxChars).catch(""),
+  step_seconds: z10.number().int().positive(),
+  from: ts,
+  to: ts,
+  groups: z10.array(z10.object({
+    key: z10.record(z10.string().max(256), label),
+    points: z10.array(z10.object({ t: ts, v: z10.number().nullable() })).max(METRIC_QUERY.pointsMax)
+  })).max(METRIC_QUERY.groupsMax),
+  exemplars: z10.array(metricExemplarSchema).max(METRIC_QUERY.exemplarsMax).catch([]),
+  ...completeness
+});
+var HIST_OVERFLOW = Number.MAX_VALUE;
 
 // ../src/shared/contracts/monitors.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 
 // ../src/shared/contracts/vocab/monitors.ts
 var MONITOR_MODES = ["check_in", "heartbeat"];
-var MONITOR_TYPES = ["job", "count", "assertion", "deadline", "progress"];
-var SIGNAL_MONITOR_TYPES = ["count", "assertion", "deadline", "progress"];
+var MONITOR_TYPES = ["job", "count", "assertion", "deadline", "progress", "metric"];
+var SIGNAL_MONITOR_TYPES = ["count", "assertion", "deadline", "progress", "metric"];
 
 // ../src/shared/contracts/monitors.ts
 var MONITOR_KINDS = ["crontab", "interval", "on_demand"];
@@ -947,7 +1400,8 @@ var MONITOR_INCIDENT_CODES = [
   "MONITOR_COUNT",
   "MONITOR_ASSERTION",
   "MONITOR_DEADLINE_MISSED",
-  "MONITOR_STALLED"
+  "MONITOR_STALLED",
+  "MONITOR_METRIC"
 ];
 var FAILURE_INCIDENT_CODES = MONITOR_INCIDENT_CODES.filter((c) => c !== "MONITOR_UNKNOWN");
 var INCIDENT_EVENTS = ["opened", "updated", "resolved"];
@@ -1000,112 +1454,114 @@ function crontabShapeOk(value) {
   const fields = value.trim().split(/\s+/);
   return value.length <= 120 && fields.length === 5 && fields.every((f) => /^[0-9A-Za-z*,/?#LW-]+$/.test(f));
 }
-var crontabScheduleSchema = z7.object({
-  type: z7.literal("crontab"),
-  value: z7.string().refine(crontabShapeOk, "crontab")
+var crontabScheduleSchema = z11.object({
+  type: z11.literal("crontab"),
+  value: z11.string().refine(crontabShapeOk, "crontab")
 });
-var intervalScheduleSchema = z7.object({
-  type: z7.literal("interval"),
-  value: z7.number().int().min(1).max(MONITOR_LIMITS.intervalValueMax),
-  unit: z7.enum(INTERVAL_UNITS)
+var intervalScheduleSchema = z11.object({
+  type: z11.literal("interval"),
+  value: z11.number().int().min(1).max(MONITOR_LIMITS.intervalValueMax),
+  unit: z11.enum(INTERVAL_UNITS)
 });
-var scheduleSchema = z7.discriminatedUnion("type", [
+var scheduleSchema = z11.discriminatedUnion("type", [
   crontabScheduleSchema,
   intervalScheduleSchema
 ]);
-var monitorSettingsSchema = z7.object({
+var monitorSettingsSchema = z11.object({
   schedule: scheduleSchema.nullable(),
-  timezone: z7.string().min(1).max(64),
-  checkin_margin: z7.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
-  max_runtime: z7.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
-  failure_issue_threshold: z7.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
-  recovery_threshold: z7.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax)
+  timezone: z11.string().min(1).max(64),
+  checkin_margin: z11.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
+  max_runtime: z11.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
+  failure_issue_threshold: z11.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
+  recovery_threshold: z11.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax)
 });
-var iso = z7.string().datetime();
-var projectId2 = z7.number().int().positive();
-var envName = z7.string().min(1).max(MONITOR_LIMITS.environmentMax);
+var iso3 = z11.string().datetime();
+var projectId3 = z11.number().int().positive();
+var envName = z11.string().min(1).max(MONITOR_LIMITS.environmentMax);
 var monitorDefinitionSchema = monitorSettingsSchema.extend({
-  id: z7.guid(),
-  project_id: projectId2,
-  slug: z7.string().regex(SLUG_RE),
-  kind: z7.enum(MONITOR_KINDS),
-  expected_environments: z7.array(envName).max(MONITOR_LIMITS.expectedEnvironmentsMax),
-  paused_until: iso.nullable(),
-  created_at: iso,
-  config_source: z7.enum(CONFIG_SOURCES),
-  config_hash: z7.string().regex(/^[0-9a-f]{64}$/).nullable()
+  id: z11.guid(),
+  project_id: projectId3,
+  slug: z11.string().regex(SLUG_RE),
+  kind: z11.enum(MONITOR_KINDS),
+  expected_environments: z11.array(envName).max(MONITOR_LIMITS.expectedEnvironmentsMax),
+  paused_until: iso3.nullable(),
+  created_at: iso3,
+  config_source: z11.enum(CONFIG_SOURCES),
+  config_hash: z11.string().regex(/^[0-9a-f]{64}$/).nullable()
 });
-var outcomeCounts = z7.object({
-  ok: z7.number().int().nonnegative(),
-  skipped: z7.number().int().nonnegative(),
-  error: z7.number().int().nonnegative(),
-  timeout: z7.number().int().nonnegative(),
-  missed: z7.number().int().nonnegative(),
-  unknown: z7.number().int().nonnegative()
+var outcomeCounts = z11.object({
+  ok: z11.number().int().nonnegative(),
+  skipped: z11.number().int().nonnegative(),
+  error: z11.number().int().nonnegative(),
+  timeout: z11.number().int().nonnegative(),
+  missed: z11.number().int().nonnegative(),
+  unknown: z11.number().int().nonnegative()
 });
-var signalStatusSchema = z7.object({
-  type: z7.enum(SIGNAL_MONITOR_TYPES),
-  value: z7.number().int().nonnegative().max(1e9).nullable(),
-  threshold: z7.number().int().nonnegative().max(1e9).nullable(),
-  window_end: iso.nullable(),
-  pending: z7.number().int().nonnegative().max(1e6).nullable(),
-  stalled: z7.number().int().nonnegative().max(1e6).nullable(),
-  refused_24h: z7.number().int().nonnegative().max(1e9).nullable()
+var MONITOR_NUMBER_MAX = 1000000000000000;
+var monitorNumber = z11.number().finite().min(-MONITOR_NUMBER_MAX).max(MONITOR_NUMBER_MAX);
+var signalStatusSchema = z11.object({
+  type: z11.enum(SIGNAL_MONITOR_TYPES),
+  value: monitorNumber.nullable(),
+  threshold: monitorNumber.nullable(),
+  window_end: iso3.nullable(),
+  pending: z11.number().int().nonnegative().max(1e6).nullable(),
+  stalled: z11.number().int().nonnegative().max(1e6).nullable(),
+  refused_24h: z11.number().int().nonnegative().max(1e9).nullable()
 });
-var monitorStatusSchema = z7.object({
-  monitor_id: z7.guid(),
-  project_id: projectId2,
+var monitorStatusSchema = z11.object({
+  monitor_id: z11.guid(),
+  project_id: projectId3,
   environment: envName,
-  open_failure: z7.enum(FAILURE_INCIDENT_CODES).nullable(),
-  open_unknown: z7.boolean(),
-  unobservable: z7.enum(UNOBSERVABLE_REASONS).nullable(),
-  last_outcome: z7.enum(RUN_OUTCOMES).nullable(),
-  last_check_in_at: iso.nullable(),
-  last_healthy_at: iso.nullable(),
-  next_deadline_at: iso.nullable(),
-  next_due_at: iso.nullable().optional(),
-  in_progress: z7.boolean(),
+  open_failure: z11.enum(FAILURE_INCIDENT_CODES).nullable(),
+  open_unknown: z11.boolean(),
+  unobservable: z11.enum(UNOBSERVABLE_REASONS).nullable(),
+  last_outcome: z11.enum(RUN_OUTCOMES).nullable(),
+  last_check_in_at: iso3.nullable(),
+  last_healthy_at: iso3.nullable(),
+  next_deadline_at: iso3.nullable(),
+  next_due_at: iso3.nullable().optional(),
+  in_progress: z11.boolean(),
   counts_24h: outcomeCounts,
   signal: signalStatusSchema.optional(),
-  evaluated_at: iso
+  evaluated_at: iso3
 });
-var monitorIncidentSchema = z7.object({
-  incident_id: z7.guid(),
-  monitor_id: z7.guid(),
-  project_id: projectId2,
+var monitorIncidentSchema = z11.object({
+  incident_id: z11.guid(),
+  monitor_id: z11.guid(),
+  project_id: projectId3,
   environment: envName,
-  code: z7.enum(MONITOR_INCIDENT_CODES),
-  event: z7.enum(INCIDENT_EVENTS),
-  occurred_at: iso,
-  detected_late: z7.boolean(),
-  reason: z7.string().regex(REASON_RE).nullable(),
-  duration_ms: z7.number().int().nonnegative().nullable(),
-  consecutive: z7.number().int().min(1).max(1e5),
-  reviewed_by: z7.guid().nullable(),
-  observed: z7.number().int().min(0).max(1e9).nullable().optional(),
-  threshold: z7.number().int().min(0).max(1e9).nullable().optional()
+  code: z11.enum(MONITOR_INCIDENT_CODES),
+  event: z11.enum(INCIDENT_EVENTS),
+  occurred_at: iso3,
+  detected_late: z11.boolean(),
+  reason: z11.string().regex(REASON_RE).nullable(),
+  duration_ms: z11.number().int().nonnegative().nullable(),
+  consecutive: z11.number().int().min(1).max(1e5),
+  reviewed_by: z11.guid().nullable(),
+  observed: monitorNumber.nullable().optional(),
+  threshold: monitorNumber.nullable().optional()
 });
-var monitorDiscoverySchema = z7.object({
-  project_id: projectId2,
-  slug: z7.string().regex(SLUG_RE),
+var monitorDiscoverySchema = z11.object({
+  project_id: projectId3,
+  slug: z11.string().regex(SLUG_RE),
   settings: monitorSettingsSchema.nullable(),
-  config_hash: z7.string().regex(/^[0-9a-f]{64}$/).nullable(),
-  check_ins: z7.number().int().nonnegative(),
-  last_seen_at: iso
+  config_hash: z11.string().regex(/^[0-9a-f]{64}$/).nullable(),
+  check_ins: z11.number().int().nonnegative(),
+  last_seen_at: iso3
 });
 var MONITOR_NAME_MAX = MONITOR_LIMITS.nameMax;
-var environmentName = z7.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/);
-var monitorInputSchema = z7.object({
-  name: z7.string().trim().min(1).max(MONITOR_LIMITS.nameMax),
-  mode: z7.enum(MONITOR_MODES).default("check_in"),
-  kind: z7.enum(MONITOR_KINDS),
+var environmentName = z11.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/);
+var monitorInputSchema = z11.object({
+  name: z11.string().trim().min(1).max(MONITOR_LIMITS.nameMax),
+  mode: z11.enum(MONITOR_MODES).default("check_in"),
+  kind: z11.enum(MONITOR_KINDS),
   schedule: scheduleSchema.nullable(),
-  timezone: z7.string().trim().min(1).max(64),
-  checkinMarginMin: z7.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
-  maxRuntimeMin: z7.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
-  failureThreshold: z7.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
-  recoveryThreshold: z7.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
-  expectedEnvironments: z7.array(environmentName).min(1).max(MONITOR_LIMITS.expectedEnvironmentsMax)
+  timezone: z11.string().trim().min(1).max(64),
+  checkinMarginMin: z11.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
+  maxRuntimeMin: z11.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
+  failureThreshold: z11.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
+  recoveryThreshold: z11.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
+  expectedEnvironments: z11.array(environmentName).min(1).max(MONITOR_LIMITS.expectedEnvironmentsMax)
 }).refine((v) => v.kind === "on_demand" ? v.schedule === null : v.schedule?.type === v.kind, {
   path: ["schedule"],
   message: "schedule"
@@ -1120,88 +1576,88 @@ var MONITOR_INPUT_DEFAULTS = {
   recoveryThreshold: MONITOR_LIMITS.recoveryThresholdDefault,
   expectedEnvironments: [DEFAULT_CHECK_IN_ENVIRONMENT]
 };
-var runOutcome = z7.enum(RUN_OUTCOMES);
-var runFlags = z7.array(z7.string().max(32)).max(16);
-var monitorRunSchema = z7.object({
-  id: z7.number().int().positive(),
-  kind: z7.enum(["run", "missed"]),
+var runOutcome = z11.enum(RUN_OUTCOMES);
+var runFlags = z11.array(z11.string().max(32)).max(16);
+var monitorRunSchema = z11.object({
+  id: z11.number().int().positive(),
+  kind: z11.enum(["run", "missed"]),
   outcome: runOutcome,
-  started_at: iso,
-  ended_at: iso,
-  attempts: z7.number().int().nonnegative(),
-  duration_ms: z7.number().int().nonnegative().nullable(),
-  reason: z7.string().max(64).nullable(),
-  check_in_id: z7.string().max(64).nullable(),
-  trace_id: z7.string().max(32).nullable(),
-  release: z7.string().max(MONITOR_LIMITS.releaseMax).nullable(),
+  started_at: iso3,
+  ended_at: iso3,
+  attempts: z11.number().int().nonnegative(),
+  duration_ms: z11.number().int().nonnegative().nullable(),
+  reason: z11.string().max(64).nullable(),
+  check_in_id: z11.string().max(64).nullable(),
+  trace_id: z11.string().max(32).nullable(),
+  release: z11.string().max(MONITOR_LIMITS.releaseMax).nullable(),
   flags: runFlags
 });
-var openAttemptSchema = z7.object({
-  check_in_id: z7.string().max(64),
-  run_key: z7.string().max(64),
-  attempt: z7.number().int().nonnegative(),
-  state: z7.string().max(16),
-  started_at: iso,
-  deadline_at: iso
+var openAttemptSchema = z11.object({
+  check_in_id: z11.string().max(64),
+  run_key: z11.string().max(64),
+  attempt: z11.number().int().nonnegative(),
+  state: z11.string().max(16),
+  started_at: iso3,
+  deadline_at: iso3
 });
-var monitorRunsResponseSchema = z7.object({
-  open: z7.array(openAttemptSchema).max(100),
-  runs: z7.array(monitorRunSchema).max(MONITOR_LIMITS.runsPageSize),
-  next_cursor: z7.string().max(32).nullable()
+var monitorRunsResponseSchema = z11.object({
+  open: z11.array(openAttemptSchema).max(100),
+  runs: z11.array(monitorRunSchema).max(MONITOR_LIMITS.runsPageSize),
+  next_cursor: z11.string().max(32).nullable()
 });
-var timelineRunSchema = z7.object({
-  id: z7.number().int().positive(),
-  kind: z7.enum(["run", "missed"]),
+var timelineRunSchema = z11.object({
+  id: z11.number().int().positive(),
+  kind: z11.enum(["run", "missed"]),
   outcome: runOutcome,
-  ended_at: iso,
+  ended_at: iso3,
   flags: runFlags
 });
-var monitorTimelineResponseSchema = z7.object({
-  runs: z7.array(timelineRunSchema).max(MONITOR_LIMITS.timelineRuns)
+var monitorTimelineResponseSchema = z11.object({
+  runs: z11.array(timelineRunSchema).max(MONITOR_LIMITS.timelineRuns)
 });
-var monitorStripsResponseSchema = z7.object({
-  strips: z7.array(z7.object({
-    monitor_id: z7.guid(),
+var monitorStripsResponseSchema = z11.object({
+  strips: z11.array(z11.object({
+    monitor_id: z11.guid(),
     environment: envName,
-    runs: z7.array(timelineRunSchema).max(MONITOR_LIMITS.listStripRuns)
+    runs: z11.array(timelineRunSchema).max(MONITOR_LIMITS.listStripRuns)
   })).max(5000)
 });
-var monitorDiagnosticSchema = z7.object({
-  id: z7.string().regex(/^\d{1,19}$/),
-  check_in_id: z7.string().max(64).nullable(),
-  signal: z7.string().max(16),
-  exit_code: z7.number().int().min(0).max(255).nullable(),
-  received_at: iso,
-  body: z7.string().max(MONITOR_LIMITS.diagnosticMaxBytes * 2)
+var monitorDiagnosticSchema = z11.object({
+  id: z11.string().regex(/^\d{1,19}$/),
+  check_in_id: z11.string().max(64).nullable(),
+  signal: z11.string().max(16),
+  exit_code: z11.number().int().min(0).max(255).nullable(),
+  received_at: iso3,
+  body: z11.string().max(MONITOR_LIMITS.diagnosticMaxBytes * 2)
 });
-var monitorDiagnosticsResponseSchema = z7.object({
-  diagnostics: z7.array(monitorDiagnosticSchema).max(50),
-  next_cursor: z7.string().regex(/^\d{1,19}$/).nullable()
+var monitorDiagnosticsResponseSchema = z11.object({
+  diagnostics: z11.array(monitorDiagnosticSchema).max(50),
+  next_cursor: z11.string().regex(/^\d{1,19}$/).nullable()
 });
-var checkInDetailSchema = z7.object({
-  run_key: z7.string().max(64),
-  attempts: z7.array(z7.object({
-    check_in_id: z7.string().max(64),
-    attempt: z7.number().int().nonnegative(),
-    result: z7.string().max(16),
-    started_at: iso,
-    ended_at: iso.nullable(),
-    duration_ms: z7.number().int().nonnegative().nullable(),
-    reason: z7.string().max(64).nullable(),
-    trace_id: z7.string().max(32).nullable(),
-    release: z7.string().max(MONITOR_LIMITS.releaseMax).nullable()
+var checkInDetailSchema = z11.object({
+  run_key: z11.string().max(64),
+  attempts: z11.array(z11.object({
+    check_in_id: z11.string().max(64),
+    attempt: z11.number().int().nonnegative(),
+    result: z11.string().max(16),
+    started_at: iso3,
+    ended_at: iso3.nullable(),
+    duration_ms: z11.number().int().nonnegative().nullable(),
+    reason: z11.string().max(64).nullable(),
+    trace_id: z11.string().max(32).nullable(),
+    release: z11.string().max(MONITOR_LIMITS.releaseMax).nullable()
   })).max(1000),
-  errors: z7.array(z7.object({
-    event_id: z7.string().max(64),
-    issue_id: z7.number().int().nonnegative(),
-    title: z7.string().max(1024),
-    level: z7.string().max(16),
-    timestamp: iso,
-    same_trace: z7.boolean()
+  errors: z11.array(z11.object({
+    event_id: z11.string().max(64),
+    issue_id: z11.number().int().nonnegative(),
+    title: z11.string().max(1024),
+    level: z11.string().max(16),
+    timestamp: iso3,
+    same_trace: z11.boolean()
   })).max(50),
-  diagnostics: z7.array(monitorDiagnosticSchema).max(20).default([])
+  diagnostics: z11.array(monitorDiagnosticSchema).max(20).default([])
 });
-var incidentReviewSchema = z7.object({ incident_id: z7.guid() });
+var incidentReviewSchema = z11.object({ incident_id: z11.guid() });
 
 // ../src/shared/contracts/signal-monitors.ts
 var isSignalMonitorType = (t) => SIGNAL_MONITOR_TYPES.includes(t);
@@ -1241,6 +1697,7 @@ var SIGNAL_LIMITS = {
   evaluateEverySeconds: 15,
   settleSeconds: 20,
   countMaxDelayMinutes: 10,
+  metricDelaySeconds: 120,
   countMinutesPerTick: 60,
   windowsPerTick: 120,
   monitorsPerQuery: 50,
@@ -1254,11 +1711,11 @@ var SIGNAL_LIMITS = {
   queryMaxSeconds: 5
 };
 var SELECTOR_KEY_RE = /^(?:tags\.[A-Za-z0-9_.:-]{1,100}|[A-Za-z_][A-Za-z0-9_.:-]{0,127})$/;
-var scalar = z8.union([z8.string().max(SIGNAL_LIMITS.valueMax), z8.number().finite(), z8.boolean()]);
-var selectorConditionSchema = z8.object({
-  key: z8.string().min(1).max(SIGNAL_LIMITS.keyMax).regex(SELECTOR_KEY_RE),
-  op: z8.enum(SELECTOR_OPS),
-  value: z8.union([scalar, z8.array(z8.string().max(SIGNAL_LIMITS.valueMax)).min(1).max(SIGNAL_LIMITS.inValuesMax)]).optional()
+var scalar = z12.union([z12.string().max(SIGNAL_LIMITS.valueMax), z12.number().finite(), z12.boolean()]);
+var selectorConditionSchema = z12.object({
+  key: z12.string().min(1).max(SIGNAL_LIMITS.keyMax).regex(SELECTOR_KEY_RE),
+  op: z12.enum(SELECTOR_OPS),
+  value: z12.union([scalar, z12.array(z12.string().max(SIGNAL_LIMITS.valueMax)).min(1).max(SIGNAL_LIMITS.inValuesMax)]).optional()
 }).superRefine((c, ctx) => {
   const bad = (message) => ctx.addIssue({ code: "custom", path: ["value"], message });
   if (VALUELESS_OPS.has(c.op)) {
@@ -1280,10 +1737,10 @@ var selectorConditionSchema = z8.object({
   if (c.op === "prefix" && (typeof c.value !== "string" || c.value.length === 0))
     bad("text");
 });
-var environmentListSchema = z8.array(z8.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/)).min(1).max(SIGNAL_LIMITS.environmentsMax).refine((v) => new Set(v).size === v.length, "unique");
-var selectorSchema = z8.object({
-  signal: z8.enum(SIGNAL_KINDS),
-  match: z8.array(selectorConditionSchema).max(SIGNAL_LIMITS.matchMax)
+var environmentListSchema = z12.array(z12.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/)).min(1).max(SIGNAL_LIMITS.environmentsMax).refine((v) => new Set(v).size === v.length, "unique");
+var selectorSchema = z12.object({
+  signal: z12.enum(SIGNAL_KINDS),
+  match: z12.array(selectorConditionSchema).max(SIGNAL_LIMITS.matchMax)
 });
 function toNumber(v) {
   if (typeof v === "number")
@@ -1294,22 +1751,22 @@ function toNumber(v) {
   }
   return null;
 }
-var minutes = (min, max) => z8.number().int().min(min).max(max);
-var threshold = z8.number().int().min(0).max(SIGNAL_LIMITS.thresholdMax);
-var recovery = z8.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax);
+var minutes = (min, max) => z12.number().int().min(min).max(max);
+var threshold = z12.number().int().min(0).max(SIGNAL_LIMITS.thresholdMax);
+var recovery = z12.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax);
 var common = {
   environments: environmentListSchema,
-  severity: z8.enum(SEVERITIES),
+  severity: z12.enum(SEVERITIES),
   recovery_threshold: recovery
 };
-var countSettingsSchema = z8.object({
-  type: z8.literal("count"),
+var countSettingsSchema = z12.object({
+  type: z12.literal("count"),
   selector: selectorSchema,
   window_minutes: minutes(SIGNAL_LIMITS.windowMinutesMin, SIGNAL_LIMITS.windowMinutesMax),
-  comparator: z8.enum(COMPARATORS),
+  comparator: z12.enum(COMPARATORS),
   threshold,
   threshold_high: threshold.nullable(),
-  missing_data: z8.enum(MISSING_DATA_POLICIES),
+  missing_data: z12.enum(MISSING_DATA_POLICIES),
   ...common
 }).superRefine((s, ctx) => {
   if (s.comparator === "outside" && (s.threshold_high === null || s.threshold_high <= s.threshold)) {
@@ -1322,31 +1779,48 @@ var countSettingsSchema = z8.object({
     ctx.addIssue({ code: "custom", path: ["threshold"], message: "threshold" });
   }
 });
-var assertionSettingsSchema = z8.object({
-  type: z8.literal("assertion"),
+var assertionSettingsSchema = z12.object({
+  type: z12.literal("assertion"),
   selector: selectorSchema,
-  assert: z8.array(selectorConditionSchema).min(1).max(SIGNAL_LIMITS.assertMax),
+  assert: z12.array(selectorConditionSchema).min(1).max(SIGNAL_LIMITS.assertMax),
   window_minutes: minutes(SIGNAL_LIMITS.windowMinutesMin, SIGNAL_LIMITS.windowMinutesMax),
-  threshold: z8.number().int().min(1).max(SIGNAL_LIMITS.thresholdMax),
-  missing_data: z8.enum(MISSING_DATA_POLICIES),
+  threshold: z12.number().int().min(1).max(SIGNAL_LIMITS.thresholdMax),
+  missing_data: z12.enum(MISSING_DATA_POLICIES),
   ...common
 });
-var deadlineSettingsSchema = z8.object({
-  type: z8.literal("deadline"),
+var deadlineSettingsSchema = z12.object({
+  type: z12.literal("deadline"),
   occurrence_grace_minutes: minutes(0, SIGNAL_LIMITS.graceMinutesMax),
   progress_timeout_minutes: minutes(SIGNAL_LIMITS.progressMinutesMin, SIGNAL_LIMITS.progressMinutesMax).nullable(),
   ...common
 });
-var progressSettingsSchema = z8.object({
-  type: z8.literal("progress"),
+var progressSettingsSchema = z12.object({
+  type: z12.literal("progress"),
   progress_timeout_minutes: minutes(SIGNAL_LIMITS.progressMinutesMin, SIGNAL_LIMITS.progressMinutesMax),
   ...common
 });
-var signalSettingsSchema = z8.discriminatedUnion("type", [
+var metricThreshold = z12.number().finite().min(-MONITOR_NUMBER_MAX).max(MONITOR_NUMBER_MAX);
+var metricSettingsSchema = z12.object({
+  type: z12.literal("metric"),
+  metric_query: metricQuerySchema,
+  window_minutes: minutes(SIGNAL_LIMITS.windowMinutesMin, SIGNAL_LIMITS.windowMinutesMax),
+  comparator: z12.enum(COMPARATORS),
+  threshold: metricThreshold,
+  threshold_high: metricThreshold.nullable(),
+  missing_data: z12.enum(MISSING_DATA_POLICIES),
+  ...common
+}).superRefine((s, ctx) => {
+  if (s.comparator === "outside" && (s.threshold_high === null || s.threshold_high <= s.threshold))
+    ctx.addIssue({ code: "custom", path: ["threshold_high"], message: "threshold_high" });
+  if (s.comparator !== "outside" && s.threshold_high !== null)
+    ctx.addIssue({ code: "custom", path: ["threshold_high"], message: "threshold_high" });
+});
+var signalSettingsSchema = z12.discriminatedUnion("type", [
   countSettingsSchema,
   assertionSettingsSchema,
   deadlineSettingsSchema,
-  progressSettingsSchema
+  progressSettingsSchema,
+  metricSettingsSchema
 ]);
 function settingsFromRow(row) {
   if (!isSignalMonitorType(row.type) || !row.signal_settings || typeof row.signal_settings !== "object")
@@ -1360,76 +1834,76 @@ function settingsFromRow(row) {
   });
   return r.success ? r.data : null;
 }
-var signalMonitorInputSchema = z8.object({
-  name: z8.string().trim().min(1).max(MONITOR_LIMITS.nameMax),
+var signalMonitorInputSchema = z12.object({
+  name: z12.string().trim().min(1).max(MONITOR_LIMITS.nameMax),
   settings: signalSettingsSchema
 });
-var signalMonitorDefinitionSchema = z8.object({
-  id: z8.guid(),
-  project_id: z8.number().int().positive(),
-  slug: z8.string().regex(SLUG_RE),
+var signalMonitorDefinitionSchema = z12.object({
+  id: z12.guid(),
+  project_id: z12.number().int().positive(),
+  slug: z12.string().regex(SLUG_RE),
   settings: signalSettingsSchema,
-  paused_until: z8.string().datetime().nullable(),
-  created_at: z8.string().datetime(),
-  revision: z8.number().int().nonnegative()
+  paused_until: z12.string().datetime().nullable(),
+  created_at: z12.string().datetime(),
+  revision: z12.number().int().nonnegative()
 });
-var signalLimitsConfigSchema = z8.object({
-  pending_occurrences_per_monitor: z8.number().int().min(1).max(1e6),
-  pending_occurrences_per_project: z8.number().int().min(1).max(1e7)
+var signalLimitsConfigSchema = z12.object({
+  pending_occurrences_per_monitor: z12.number().int().min(1).max(1e6),
+  pending_occurrences_per_project: z12.number().int().min(1).max(1e7)
 });
 var OCCURRENCE_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
-var occurrenceInputSchema = z8.object({
-  monitor_slug: z8.string().regex(SLUG_RE),
-  occurrence_id: z8.string().regex(OCCURRENCE_ID_RE),
-  due_at: z8.string().datetime({ offset: true }),
-  environment: z8.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/).optional()
+var occurrenceInputSchema = z12.object({
+  monitor_slug: z12.string().regex(SLUG_RE),
+  occurrence_id: z12.string().regex(OCCURRENCE_ID_RE),
+  due_at: z12.string().datetime({ offset: true }),
+  environment: z12.string().trim().min(1).max(MONITOR_LIMITS.environmentMax).regex(/^[A-Za-z0-9._-]+$/).optional()
 });
 var occurrenceCancelSchema = occurrenceInputSchema.pick({ monitor_slug: true, occurrence_id: true, environment: true });
 var OCCURRENCE_PAST_SKEW_MS = 5 * 60000;
-var occurrenceRowSchema = z8.object({
-  occurrence_id: z8.string().max(SIGNAL_LIMITS.occurrenceIdMax),
-  environment: z8.string().max(MONITOR_LIMITS.environmentMax),
-  state: z8.enum(OCCURRENCE_STATES),
-  due_at: z8.string().datetime(),
-  deadline_at: z8.string().datetime(),
-  registered_at: z8.string().datetime(),
-  started_at: z8.string().datetime().nullable(),
-  last_signal_at: z8.string().datetime().nullable(),
-  ended_at: z8.string().datetime().nullable(),
-  stalled: z8.boolean()
+var occurrenceRowSchema = z12.object({
+  occurrence_id: z12.string().max(SIGNAL_LIMITS.occurrenceIdMax),
+  environment: z12.string().max(MONITOR_LIMITS.environmentMax),
+  state: z12.enum(OCCURRENCE_STATES),
+  due_at: z12.string().datetime(),
+  deadline_at: z12.string().datetime(),
+  registered_at: z12.string().datetime(),
+  started_at: z12.string().datetime().nullable(),
+  last_signal_at: z12.string().datetime().nullable(),
+  ended_at: z12.string().datetime().nullable(),
+  stalled: z12.boolean()
 });
-var occurrencesResponseSchema = z8.object({
-  occurrences: z8.array(occurrenceRowSchema).max(SIGNAL_LIMITS.occurrencesPageSize),
-  pending: z8.number().int().nonnegative(),
-  next_due_at: z8.string().datetime().nullable(),
-  next_cursor: z8.string().max(64).nullable(),
-  refused_24h: z8.number().int().nonnegative()
+var occurrencesResponseSchema = z12.object({
+  occurrences: z12.array(occurrenceRowSchema).max(SIGNAL_LIMITS.occurrencesPageSize),
+  pending: z12.number().int().nonnegative(),
+  next_due_at: z12.string().datetime().nullable(),
+  next_cursor: z12.string().max(64).nullable(),
+  refused_24h: z12.number().int().nonnegative()
 });
-var signalSeriesSchema = z8.object({
-  environment: z8.string().max(MONITOR_LIMITS.environmentMax),
-  buckets: z8.array(z8.object({ minute: z8.string().datetime(), matched: z8.number().int().nonnegative(), violations: z8.number().int().nonnegative(), lossy: z8.boolean() })).max(1440),
-  counted_through: z8.string().datetime().nullable()
+var signalSeriesSchema = z12.object({
+  environment: z12.string().max(MONITOR_LIMITS.environmentMax),
+  buckets: z12.array(z12.object({ minute: z12.string().datetime(), matched: z12.number().int().nonnegative(), violations: z12.number().int().nonnegative(), lossy: z12.boolean() })).max(1440),
+  counted_through: z12.string().datetime().nullable()
 });
-var signalResponseSchema = z8.object({
-  series: z8.array(signalSeriesSchema).max(SIGNAL_LIMITS.environmentsMax),
-  runs: z8.array(z8.object({
-    run_id: z8.string().max(SIGNAL_LIMITS.occurrenceIdMax),
-    environment: z8.string().max(MONITOR_LIMITS.environmentMax),
-    started_at: z8.string().datetime(),
-    last_signal_at: z8.string().datetime(),
-    stalled: z8.boolean()
+var signalResponseSchema = z12.object({
+  series: z12.array(signalSeriesSchema).max(SIGNAL_LIMITS.environmentsMax),
+  runs: z12.array(z12.object({
+    run_id: z12.string().max(SIGNAL_LIMITS.occurrenceIdMax),
+    environment: z12.string().max(MONITOR_LIMITS.environmentMax),
+    started_at: z12.string().datetime(),
+    last_signal_at: z12.string().datetime(),
+    stalled: z12.boolean()
   })).max(SIGNAL_LIMITS.occurrencesPageSize)
 });
-var backtestSettingsSchema = z8.union([countSettingsSchema, assertionSettingsSchema]);
-var backtestResponseSchema = z8.object({
-  alerts: z8.number().int().nonnegative(),
-  windows: z8.number().int().nonnegative(),
-  violated_windows: z8.number().int().nonnegative(),
-  first_at: z8.string().datetime().nullable(),
-  last_at: z8.string().datetime().nullable(),
-  days: z8.number().nonnegative(),
-  matched_total: z8.number().int().nonnegative(),
-  violations_total: z8.number().int().nonnegative()
+var backtestSettingsSchema = z12.union([countSettingsSchema, assertionSettingsSchema]);
+var backtestResponseSchema = z12.object({
+  alerts: z12.number().int().nonnegative(),
+  windows: z12.number().int().nonnegative(),
+  violated_windows: z12.number().int().nonnegative(),
+  first_at: z12.string().datetime().nullable(),
+  last_at: z12.string().datetime().nullable(),
+  days: z12.number().nonnegative(),
+  matched_total: z12.number().int().nonnegative(),
+  violations_total: z12.number().int().nonnegative()
 });
 
 // ../src/shared/contracts/notifications.ts
@@ -1444,24 +1918,24 @@ var NOTIFY_LIMITS = {
 };
 var HOLDABLE_SEVERITIES = ["medium", "low"];
 var DIGEST_MODES = ["off", "hourly", "daily"];
-var timeOfDay2 = z9.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
+var timeOfDay2 = z13.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/);
 var unique = (xs) => new Set(xs).size === xs.length;
-var quietHoursSchema = z9.object({
-  days: z9.array(weekdaySchema).min(1).max(7).refine(unique),
+var quietHoursSchema = z13.object({
+  days: z13.array(weekdaySchema).min(1).max(7).refine(unique),
   start: timeOfDay2,
   end: timeOfDay2
 }).refine((q) => q.start !== q.end, { path: ["end"] });
-var policyInputSchema = z9.object({
-  name: z9.string().trim().min(1).max(NOTIFY_LIMITS.nameMax).regex(/^[^\p{Cc}]*$/u),
-  timezone: z9.string().trim().min(1).max(64).refine(validTimeZone),
+var policyInputSchema = z13.object({
+  name: z13.string().trim().min(1).max(NOTIFY_LIMITS.nameMax).regex(/^[^\p{Cc}]*$/u),
+  timezone: z13.string().trim().min(1).max(64).refine(validTimeZone),
   quietHours: quietHoursSchema.nullable(),
-  quietSeverities: z9.array(z9.enum(HOLDABLE_SEVERITIES)).max(2).refine(unique),
-  digest: z9.enum(DIGEST_MODES),
+  quietSeverities: z13.array(z13.enum(HOLDABLE_SEVERITIES)).max(2).refine(unique),
+  digest: z13.enum(DIGEST_MODES),
   digestAt: timeOfDay2.nullable(),
-  digestSeverities: z9.array(z9.enum(HOLDABLE_SEVERITIES)).max(2).refine(unique),
-  fallback: z9.array(z9.guid()).max(NOTIFY_LIMITS.chainMax).refine(unique),
-  escalateAfterMinutes: z9.number().int().min(NOTIFY_LIMITS.escalateMinutesMin).max(NOTIFY_LIMITS.escalateMinutesMax).nullable(),
-  escalation: z9.array(z9.guid()).max(NOTIFY_LIMITS.chainMax).refine(unique)
+  digestSeverities: z13.array(z13.enum(HOLDABLE_SEVERITIES)).max(2).refine(unique),
+  fallback: z13.array(z13.guid()).max(NOTIFY_LIMITS.chainMax).refine(unique),
+  escalateAfterMinutes: z13.number().int().min(NOTIFY_LIMITS.escalateMinutesMin).max(NOTIFY_LIMITS.escalateMinutesMax).nullable(),
+  escalation: z13.array(z13.guid()).max(NOTIFY_LIMITS.chainMax).refine(unique)
 }).superRefine((p, ctx) => {
   if (p.digest === "daily" !== (p.digestAt !== null))
     ctx.addIssue({ code: "custom", path: ["digestAt"], message: "digest_at" });
@@ -1473,46 +1947,46 @@ var HOUR = 60 * MIN;
 var DAY = 24 * HOUR;
 
 // ../src/shared/contracts/api-ops/incidents.ts
-var incidentOnly = z10.object({ workspaceId: uuid, incidentId: uuid });
-var note = z10.string().trim().min(1).max(2000).regex(/^[^\u0000-\u0008\u000b\u000c\u000e-\u001f]*$/);
+var incidentOnly = z14.object({ workspaceId: uuid, incidentId: uuid });
+var note2 = z14.string().trim().min(1).max(2000).regex(/^[^\u0000-\u0008\u000b\u000c\u000e-\u001f]*$/);
 var INCIDENT_KINDS = ["monitor", "uptime", "slo", "issue"];
 var INCIDENT_GROUP_BY = ["monitor", "project_env"];
-var incidentRuleInputSchema = z10.object({
-  name: z10.string().trim().min(1).max(80).regex(/^[^\p{Cc}]*$/u),
-  isEnabled: z10.boolean(),
-  position: z10.number().int().min(0).max(1000).default(0),
-  projectIds: z10.array(z10.number().int().positive()).max(50),
-  environments: z10.array(z10.string().trim().min(1).max(64)).max(20),
-  kinds: z10.array(z10.enum(INCIDENT_KINDS)).min(1).max(4),
-  minSeverity: z10.enum(SEVERITIES),
-  groupBy: z10.enum(INCIDENT_GROUP_BY),
-  windowMinutes: z10.number().int().min(5).max(240),
-  recoveryHoldMinutes: z10.number().int().min(0).max(1440)
+var incidentRuleInputSchema = z14.object({
+  name: z14.string().trim().min(1).max(80).regex(/^[^\p{Cc}]*$/u),
+  isEnabled: z14.boolean(),
+  position: z14.number().int().min(0).max(1000).default(0),
+  projectIds: z14.array(z14.number().int().positive()).max(50),
+  environments: z14.array(z14.string().trim().min(1).max(64)).max(20),
+  kinds: z14.array(z14.enum(INCIDENT_KINDS)).min(1).max(4),
+  minSeverity: z14.enum(SEVERITIES),
+  groupBy: z14.enum(INCIDENT_GROUP_BY),
+  windowMinutes: z14.number().int().min(5).max(240),
+  recoveryHoldMinutes: z14.number().int().min(0).max(1440)
 });
 var INCIDENT_INPUTS = {
-  list: z10.object({
+  list: z14.object({
     workspaceId: uuid,
     limit: pageLimit,
     cursor,
-    state: z10.enum(["active", "resolved", "all"]).default("all")
+    state: z14.enum(["active", "resolved", "all"]).default("all")
   }),
   incidentOnly,
-  resolve: incidentOnly.extend({ note: note.max(500) }),
-  note: incidentOnly.extend({ note }),
+  resolve: incidentOnly.extend({ note: note2.max(500) }),
+  note: incidentOnly.extend({ note: note2 }),
   update: incidentOnly.extend({
-    title: z10.string().trim().min(1).max(120).regex(/^[^\p{Cc}]*$/u).optional(),
+    title: z14.string().trim().min(1).max(120).regex(/^[^\p{Cc}]*$/u).optional(),
     ownerUserId: uuid.nullable().optional()
   }),
-  workspace: z10.object({ workspaceId: uuid }),
-  saveRule: z10.object({ workspaceId: uuid, ruleId: uuid.nullable(), input: incidentRuleInputSchema }),
-  ruleOnly: z10.object({ workspaceId: uuid, ruleId: uuid }),
-  savePolicy: z10.object({
+  workspace: z14.object({ workspaceId: uuid }),
+  saveRule: z14.object({ workspaceId: uuid, ruleId: uuid.nullable(), input: incidentRuleInputSchema }),
+  ruleOnly: z14.object({ workspaceId: uuid, ruleId: uuid }),
+  savePolicy: z14.object({
     workspaceId: uuid,
     policyId: uuid.nullable(),
-    isDefault: z10.boolean(),
+    isDefault: z14.boolean(),
     input: policyInputSchema
   }),
-  policyOnly: z10.object({ workspaceId: uuid, policyId: uuid })
+  policyOnly: z14.object({ workspaceId: uuid, policyId: uuid })
 };
 var I = INCIDENT_INPUTS;
 var w = "incidents:write";
@@ -1701,20 +2175,20 @@ var INCIDENT_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/monitors.ts
-import { z as z15 } from "zod";
+import { z as z19 } from "zod";
 
 // ../src/shared/contracts/heartbeat.ts
-import { z as z12 } from "zod";
+import { z as z16 } from "zod";
 
 // ../src/shared/contracts/signed-message.ts
-import { z as z11 } from "zod";
-var nodeIdSchema = z11.guid();
-var signedEnvelopeSchema = z11.object({
+import { z as z15 } from "zod";
+var nodeIdSchema = z15.guid();
+var signedEnvelopeSchema = z15.object({
   node_id: nodeIdSchema,
-  ts: z11.number().int().positive(),
-  nonce: z11.string().regex(/^[A-Za-z0-9_-]{16,64}$/),
-  payload: z11.record(z11.string(), z11.unknown()),
-  sig: z11.string().regex(/^[A-Za-z0-9_-]{86}$/)
+  ts: z15.number().int().positive(),
+  nonce: z15.string().regex(/^[A-Za-z0-9_-]{16,64}$/),
+  payload: z15.record(z15.string(), z15.unknown()),
+  sig: z15.string().regex(/^[A-Za-z0-9_-]{86}$/)
 });
 
 // ../src/shared/contracts/heartbeat.ts
@@ -1752,78 +2226,78 @@ var HEARTBEAT_LIMITS = {
   diagnosticsPerRun: 5
 };
 var PAUSED_FOREVER_MS = Date.parse("9999-12-31T00:00:00.000Z");
-var uuid2 = z12.guid();
-var ms = z12.number().int().nonnegative();
-var hex64 = z12.string().regex(/^[0-9a-f]{64}$/);
-var envName2 = z12.string().min(1).max(MONITOR_LIMITS.environmentMax);
-var heartbeatMonitorConfigSchema = z12.object({
+var uuid2 = z16.guid();
+var ms = z16.number().int().nonnegative();
+var hex64 = z16.string().regex(/^[0-9a-f]{64}$/);
+var envName2 = z16.string().min(1).max(MONITOR_LIMITS.environmentMax);
+var heartbeatMonitorConfigSchema = z16.object({
   id: uuid2,
-  project_id: z12.number().int().positive(),
-  slug: z12.string().regex(SLUG_RE),
+  project_id: z16.number().int().positive(),
+  slug: z16.string().regex(SLUG_RE),
   environment: envName2,
   schedule: scheduleSchema,
-  timezone: z12.string().min(1).max(64),
-  grace_min: z12.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
-  max_runtime_min: z12.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
-  failure_threshold: z12.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
-  recovery_threshold: z12.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
+  timezone: z16.string().min(1).max(64),
+  grace_min: z16.number().int().min(MONITOR_LIMITS.checkinMarginMin).max(MONITOR_LIMITS.checkinMarginMax),
+  max_runtime_min: z16.number().int().min(MONITOR_LIMITS.maxRuntimeMin).max(MONITOR_LIMITS.maxRuntimeMax),
+  failure_threshold: z16.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
+  recovery_threshold: z16.number().int().min(MONITOR_LIMITS.thresholdMin).max(MONITOR_LIMITS.thresholdMax),
   paused_until: ms.nullable(),
   created_at: ms
 });
-var heartbeatTokenConfigSchema = z12.object({
+var heartbeatTokenConfigSchema = z16.object({
   id: uuid2,
   monitor_id: uuid2,
   hash: hex64,
   expires_at: ms.nullable()
 });
-var heartbeatSyncSchema = z12.object({
-  v: z12.literal(1),
+var heartbeatSyncSchema = z16.object({
+  v: z16.literal(1),
   workspace_id: uuid2,
-  route: z12.string().regex(PING_ROUTE_RE),
-  revision: z12.number().int().positive(),
-  workspace_status: z12.enum(["active", "suspended", "deleting"]),
-  ingest_kill: z12.boolean(),
-  limits: z12.object({
-    check_in_rate_per_sec: z12.number().int().positive(),
-    check_in_burst: z12.number().int().positive(),
-    monthly_check_in_cap: z12.number().int().positive()
-  }),
-  projects: z12.array(z12.object({ id: z12.number().int().positive(), node_id: nodeIdSchema.nullable() })).max(1000),
-  monitors: z12.array(heartbeatMonitorConfigSchema).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace),
-  tokens: z12.array(heartbeatTokenConfigSchema).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace * 2)
+  route: z16.string().regex(PING_ROUTE_RE),
+  revision: z16.number().int().positive(),
+  workspace_status: z16.enum(["active", "suspended", "deleting"]),
+  ingest_kill: z16.boolean(),
+  limits: z16.object({
+    check_in_rate_per_sec: z16.number().int().positive(),
+    check_in_burst: z16.number().int().positive(),
+    monthly_check_in_cap: z16.number().int().positive()
+  }),
+  projects: z16.array(z16.object({ id: z16.number().int().positive(), node_id: nodeIdSchema.nullable() })).max(1000),
+  monitors: z16.array(heartbeatMonitorConfigSchema).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace),
+  tokens: z16.array(heartbeatTokenConfigSchema).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace * 2)
 });
-var signedHeartbeatSyncSchema = z12.object({
-  body: z12.string().min(2).max(4 * 1024 * 1024),
-  ts: z12.number().int().positive(),
-  kid: z12.string().regex(/^[A-Za-z0-9_-]{1,40}$/),
-  sig: z12.string().regex(/^[A-Za-z0-9_-]{86}$/)
+var signedHeartbeatSyncSchema = z16.object({
+  body: z16.string().min(2).max(4 * 1024 * 1024),
+  ts: z16.number().int().positive(),
+  kid: z16.string().regex(/^[A-Za-z0-9_-]{1,40}$/),
+  sig: z16.string().regex(/^[A-Za-z0-9_-]{86}$/)
 });
-var heartbeatHourSchema = z12.object({
+var heartbeatHourSchema = z16.object({
   monitor_id: uuid2,
-  hour: z12.string().datetime(),
-  ok: z12.number().int().nonnegative(),
-  failed: z12.number().int().nonnegative(),
-  started: z12.number().int().nonnegative(),
-  missed: z12.number().int().nonnegative(),
-  logs: z12.number().int().nonnegative()
+  hour: z16.string().datetime(),
+  ok: z16.number().int().nonnegative(),
+  failed: z16.number().int().nonnegative(),
+  started: z16.number().int().nonnegative(),
+  missed: z16.number().int().nonnegative(),
+  logs: z16.number().int().nonnegative()
 });
-var heartbeatReportSchema = z12.object({
-  v: z12.literal(1),
+var heartbeatReportSchema = z16.object({
+  v: z16.literal(1),
   workspace_id: uuid2,
-  route: z12.string().regex(PING_ROUTE_RE),
-  revision: z12.number().int().nonnegative(),
-  sent_at: z12.string().datetime(),
-  incidents: z12.array(monitorIncidentSchema).max(HEARTBEAT_LIMITS.reportMaxIncidents),
-  statuses: z12.array(monitorStatusSchema).max(HEARTBEAT_LIMITS.reportMaxStatuses),
-  hours: z12.array(heartbeatHourSchema).max(HEARTBEAT_LIMITS.reportMaxHours),
-  token_uses: z12.array(z12.object({ token_id: uuid2, last_used_at: z12.string().datetime() })).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace * 2)
+  route: z16.string().regex(PING_ROUTE_RE),
+  revision: z16.number().int().nonnegative(),
+  sent_at: z16.string().datetime(),
+  incidents: z16.array(monitorIncidentSchema).max(HEARTBEAT_LIMITS.reportMaxIncidents),
+  statuses: z16.array(monitorStatusSchema).max(HEARTBEAT_LIMITS.reportMaxStatuses),
+  hours: z16.array(heartbeatHourSchema).max(HEARTBEAT_LIMITS.reportMaxHours),
+  token_uses: z16.array(z16.object({ token_id: uuid2, last_used_at: z16.string().datetime() })).max(HEARTBEAT_LIMITS.maxMonitorsPerWorkspace * 2)
 });
 var ENCODER = new TextEncoder;
 var UTF8 = new TextDecoder("utf-8", { fatal: false, ignoreBOM: false });
 var TOKEN_IN_TEXT = new RegExp(PING_TOKEN_PATTERN, "g");
 
 // ../src/shared/contracts/slo.ts
-import { z as z13 } from "zod";
+import { z as z17 } from "zod";
 
 // ../src/shared/contracts/vocab/slo.ts
 var SLO_SOURCES = ["uptime", "monitor", "heartbeat", "spans"];
@@ -1855,17 +2329,17 @@ var SLO_SOURCE_META = {
   heartbeat: { provenance: "ping_token", estimated: false, slis: ["availability"], budgeting: "Occurrences" },
   spans: { provenance: "ingest_key", estimated: true, slis: ["availability", "latency"], budgeting: "Occurrences" }
 };
-var nodeSloSchema = z13.object({
-  slo_id: z13.guid(),
-  project_id: z13.number().int().positive(),
-  source: z13.enum(["monitor", "spans"]),
-  sli: z13.enum(SLO_SLIS),
-  monitor_id: z13.guid().optional(),
-  environment: z13.string().min(1).max(SLO_LIMITS.environmentMaxChars).optional(),
-  service: z13.string().min(1).max(128).optional(),
-  operation: z13.string().min(1).max(256).optional(),
-  latency_threshold_ms: z13.number().int().min(1).max(60000).optional(),
-  public_sources: z13.boolean()
+var nodeSloSchema = z17.object({
+  slo_id: z17.guid(),
+  project_id: z17.number().int().positive(),
+  source: z17.enum(["monitor", "spans"]),
+  sli: z17.enum(SLO_SLIS),
+  monitor_id: z17.guid().optional(),
+  environment: z17.string().min(1).max(SLO_LIMITS.environmentMaxChars).optional(),
+  service: z17.string().min(1).max(128).optional(),
+  operation: z17.string().min(1).max(256).optional(),
+  latency_threshold_ms: z17.number().int().min(1).max(60000).optional(),
+  public_sources: z17.boolean()
 }).superRefine((v, ctx) => {
   if (v.source === "monitor" && (!v.monitor_id || v.sli !== "availability"))
     ctx.addIssue({ code: "custom", path: ["monitor_id"], message: "INVALID_INPUT" });
@@ -1874,27 +2348,27 @@ var nodeSloSchema = z13.object({
   if (v.sli === "latency" !== (v.latency_threshold_ms !== undefined))
     ctx.addIssue({ code: "custom", path: ["latency_threshold_ms"], message: "INVALID_INPUT" });
 });
-var sliCountsSchema = z13.object({
-  minute: z13.string().datetime(),
-  items: z13.array(z13.object({ slo_id: z13.guid(), good: z13.number().int().min(0), total: z13.number().int().min(0) }).refine((x) => x.good <= x.total, { message: "INVALID_INPUT" })).max(SLO_LIMITS.sliItemsPerMessage)
+var sliCountsSchema = z17.object({
+  minute: z17.string().datetime(),
+  items: z17.array(z17.object({ slo_id: z17.guid(), good: z17.number().int().min(0), total: z17.number().int().min(0) }).refine((x) => x.good <= x.total, { message: "INVALID_INPUT" })).max(SLO_LIMITS.sliItemsPerMessage)
 });
-var sloInputSchema = z13.object({
-  name: z13.string().trim().min(1).max(SLO_LIMITS.nameMaxChars),
-  description: z13.string().max(SLO_LIMITS.descriptionMaxChars).default(""),
-  source: z13.enum(SLO_SOURCES),
-  sourceRef: z13.object({
-    id: z13.guid().optional(),
-    projectId: z13.number().int().positive().optional(),
-    service: z13.string().max(128).optional(),
-    operation: z13.string().max(256).optional(),
-    environment: z13.string().max(SLO_LIMITS.environmentMaxChars).optional()
-  }),
-  sli: z13.enum(SLO_SLIS),
-  latencyThresholdMs: z13.number().int().min(1).max(60000).nullable(),
-  objective: z13.number().min(SLO_LIMITS.objectiveMin).max(SLO_LIMITS.objectiveMax),
-  windowDays: z13.union([z13.literal(7), z13.literal(28), z13.literal(30)]),
-  alertPolicy: z13.enum(SLO_ALERT_POLICIES),
-  allowPublicSources: z13.boolean().default(false)
+var sloInputSchema = z17.object({
+  name: z17.string().trim().min(1).max(SLO_LIMITS.nameMaxChars),
+  description: z17.string().max(SLO_LIMITS.descriptionMaxChars).default(""),
+  source: z17.enum(SLO_SOURCES),
+  sourceRef: z17.object({
+    id: z17.guid().optional(),
+    projectId: z17.number().int().positive().optional(),
+    service: z17.string().max(128).optional(),
+    operation: z17.string().max(256).optional(),
+    environment: z17.string().max(SLO_LIMITS.environmentMaxChars).optional()
+  }),
+  sli: z17.enum(SLO_SLIS),
+  latencyThresholdMs: z17.number().int().min(1).max(60000).nullable(),
+  objective: z17.number().min(SLO_LIMITS.objectiveMin).max(SLO_LIMITS.objectiveMax),
+  windowDays: z17.union([z17.literal(7), z17.literal(28), z17.literal(30)]),
+  alertPolicy: z17.enum(SLO_ALERT_POLICIES),
+  allowPublicSources: z17.boolean().default(false)
 }).superRefine((v, ctx) => {
   if (!SLO_SOURCE_META[v.source].slis.includes(v.sli))
     ctx.addIssue({ code: "custom", path: ["sli"], message: "INVALID_INPUT" });
@@ -1909,7 +2383,7 @@ var sloInputSchema = z13.object({
 });
 
 // ../src/shared/contracts/uptime.ts
-import { z as z14 } from "zod";
+import { z as z18 } from "zod";
 
 // ../src/shared/contracts/vocab/uptime.ts
 var UPTIME_STATUSES = ["up", "degraded", "down", "unknown", "paused", "pending"];
@@ -1982,51 +2456,51 @@ function isForbiddenHeader(name) {
   const n = name.trim().toLowerCase();
   return UPTIME_FORBIDDEN_HEADERS.includes(n) || n.startsWith("proxy-") || n.startsWith("sec-");
 }
-var text = z14.string().min(1).max(UPTIME_LIMITS.assertionTextMax);
-var statusRange = z14.string().regex(/^[1-5][0-9]{2}(-[1-5][0-9]{2})?$/);
-var assertionSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("status"), in: z14.array(statusRange).min(1).max(10) }),
-  z14.object({ type: z14.literal("body_contains"), value: text, case_sensitive: z14.boolean().default(true) }),
-  z14.object({ type: z14.literal("body_not_contains"), value: text, case_sensitive: z14.boolean().default(true) }),
-  z14.object({
-    type: z14.literal("json_pointer"),
-    pointer: z14.string().max(256).regex(/^(\/([^~/]|~0|~1)*)*$/),
-    op: z14.enum(["exists", "equals", "type"]),
-    value: z14.string().max(UPTIME_LIMITS.assertionTextMax).optional()
-  }),
-  z14.object({
-    type: z14.literal("header"),
-    name: z14.string().min(1).max(UPTIME_LIMITS.headerNameMax).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/),
-    op: z14.enum(["equals", "contains", "exists"]),
-    value: z14.string().max(UPTIME_LIMITS.assertionTextMax).optional()
-  }),
-  z14.object({ type: z14.literal("latency_ms"), lt: z14.number().int().min(1).max(60000) }),
-  z14.object({ type: z14.literal("tls_valid") })
+var text = z18.string().min(1).max(UPTIME_LIMITS.assertionTextMax);
+var statusRange = z18.string().regex(/^[1-5][0-9]{2}(-[1-5][0-9]{2})?$/);
+var assertionSchema = z18.discriminatedUnion("type", [
+  z18.object({ type: z18.literal("status"), in: z18.array(statusRange).min(1).max(10) }),
+  z18.object({ type: z18.literal("body_contains"), value: text, case_sensitive: z18.boolean().default(true) }),
+  z18.object({ type: z18.literal("body_not_contains"), value: text, case_sensitive: z18.boolean().default(true) }),
+  z18.object({
+    type: z18.literal("json_pointer"),
+    pointer: z18.string().max(256).regex(/^(\/([^~/]|~0|~1)*)*$/),
+    op: z18.enum(["exists", "equals", "type"]),
+    value: z18.string().max(UPTIME_LIMITS.assertionTextMax).optional()
+  }),
+  z18.object({
+    type: z18.literal("header"),
+    name: z18.string().min(1).max(UPTIME_LIMITS.headerNameMax).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/),
+    op: z18.enum(["equals", "contains", "exists"]),
+    value: z18.string().max(UPTIME_LIMITS.assertionTextMax).optional()
+  }),
+  z18.object({ type: z18.literal("latency_ms"), lt: z18.number().int().min(1).max(60000) }),
+  z18.object({ type: z18.literal("tls_valid") })
 ]);
-var header = z14.object({
-  name: z14.string().min(1).max(UPTIME_LIMITS.headerNameMax).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/),
-  value: z14.string().max(UPTIME_LIMITS.headerValueMax).regex(/^[^\r\n\u0000]*$/)
+var header = z18.object({
+  name: z18.string().min(1).max(UPTIME_LIMITS.headerNameMax).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/),
+  value: z18.string().max(UPTIME_LIMITS.headerValueMax).regex(/^[^\r\n\u0000]*$/)
 });
-var uptimeCheckInputSchema = z14.object({
-  projectId: z14.number().int().positive(),
-  name: z14.string().trim().min(1).max(UPTIME_LIMITS.nameMaxChars),
-  kind: z14.enum(UPTIME_KINDS),
-  url: z14.string().max(UPTIME_LIMITS.urlMaxChars).nullable(),
-  host: z14.string().max(253).nullable(),
-  port: z14.number().int().min(1).max(65535).nullable(),
-  method: z14.enum(UPTIME_METHODS).default("GET"),
-  headers: z14.array(header).max(UPTIME_LIMITS.headersMax).default([]),
-  followRedirects: z14.boolean().default(false),
-  timeoutMs: z14.number().int().min(UPTIME_LIMITS.timeoutMs.min).max(UPTIME_LIMITS.timeoutMs.max),
-  intervalSeconds: z14.number().int().refine((n) => UPTIME_INTERVALS.includes(n)),
-  regions: z14.array(z14.enum(UPTIME_REGIONS)).min(UPTIME_LIMITS.minRegions).max(UPTIME_REGIONS.length),
-  assertions: z14.array(assertionSchema).max(UPTIME_LIMITS.assertionsMax).default([]),
-  failureThreshold: z14.number().int().min(1).max(5),
-  recoveryThreshold: z14.number().int().min(1).max(5),
-  certWarningDays: z14.number().int().min(1).max(60),
-  environment: z14.string().trim().max(64).default(""),
-  strictMetadata: z14.boolean().default(false),
-  evidenceOnFailure: z14.boolean().default(true)
+var uptimeCheckInputSchema = z18.object({
+  projectId: z18.number().int().positive(),
+  name: z18.string().trim().min(1).max(UPTIME_LIMITS.nameMaxChars),
+  kind: z18.enum(UPTIME_KINDS),
+  url: z18.string().max(UPTIME_LIMITS.urlMaxChars).nullable(),
+  host: z18.string().max(253).nullable(),
+  port: z18.number().int().min(1).max(65535).nullable(),
+  method: z18.enum(UPTIME_METHODS).default("GET"),
+  headers: z18.array(header).max(UPTIME_LIMITS.headersMax).default([]),
+  followRedirects: z18.boolean().default(false),
+  timeoutMs: z18.number().int().min(UPTIME_LIMITS.timeoutMs.min).max(UPTIME_LIMITS.timeoutMs.max),
+  intervalSeconds: z18.number().int().refine((n) => UPTIME_INTERVALS.includes(n)),
+  regions: z18.array(z18.enum(UPTIME_REGIONS)).min(UPTIME_LIMITS.minRegions).max(UPTIME_REGIONS.length),
+  assertions: z18.array(assertionSchema).max(UPTIME_LIMITS.assertionsMax).default([]),
+  failureThreshold: z18.number().int().min(1).max(5),
+  recoveryThreshold: z18.number().int().min(1).max(5),
+  certWarningDays: z18.number().int().min(1).max(60),
+  environment: z18.string().trim().max(64).default(""),
+  strictMetadata: z18.boolean().default(false),
+  evidenceOnFailure: z18.boolean().default(true)
 }).superRefine((v, ctx) => {
   if (v.kind === "http" && !v.url)
     ctx.addIssue({ code: "custom", path: ["url"], message: "INVALID_INPUT" });
@@ -2037,243 +2511,243 @@ var uptimeCheckInputSchema = z14.object({
   if (v.headers.some((h) => isForbiddenHeader(h.name)))
     ctx.addIssue({ code: "custom", path: ["headers"], message: "UPTIME_HEADER_FORBIDDEN" });
 });
-var uptimeDefinitionSchema = z14.object({
-  check_id: z14.guid(),
-  workspace_id: z14.guid(),
-  project_id: z14.number().int().positive(),
-  revision: z14.number().int().nonnegative(),
-  kind: z14.enum(UPTIME_KINDS),
-  url: z14.string().max(UPTIME_LIMITS.urlMaxChars).nullable(),
-  host: z14.string().max(253).nullable(),
-  port: z14.number().int().min(1).max(65535).nullable(),
-  method: z14.enum(UPTIME_METHODS),
-  headers: z14.array(header).max(UPTIME_LIMITS.headersMax),
-  follow_redirects: z14.boolean(),
-  timeout_ms: z14.number().int().min(UPTIME_LIMITS.timeoutMs.min).max(UPTIME_LIMITS.timeoutMs.max),
-  interval_seconds: z14.number().int().positive(),
-  regions: z14.array(z14.enum(UPTIME_REGIONS)).min(1).max(3),
-  assertions: z14.array(assertionSchema).max(UPTIME_LIMITS.assertionsMax),
-  failure_threshold: z14.number().int().min(1).max(5),
-  recovery_threshold: z14.number().int().min(1).max(5),
-  cert_warning_days: z14.number().int().min(1).max(60),
-  strict_metadata: z14.boolean(),
-  evidence_on_failure: z14.boolean(),
-  paused_until: z14.string().nullable(),
-  muted_until: z14.string().nullable()
+var uptimeDefinitionSchema = z18.object({
+  check_id: z18.guid(),
+  workspace_id: z18.guid(),
+  project_id: z18.number().int().positive(),
+  revision: z18.number().int().nonnegative(),
+  kind: z18.enum(UPTIME_KINDS),
+  url: z18.string().max(UPTIME_LIMITS.urlMaxChars).nullable(),
+  host: z18.string().max(253).nullable(),
+  port: z18.number().int().min(1).max(65535).nullable(),
+  method: z18.enum(UPTIME_METHODS),
+  headers: z18.array(header).max(UPTIME_LIMITS.headersMax),
+  follow_redirects: z18.boolean(),
+  timeout_ms: z18.number().int().min(UPTIME_LIMITS.timeoutMs.min).max(UPTIME_LIMITS.timeoutMs.max),
+  interval_seconds: z18.number().int().positive(),
+  regions: z18.array(z18.enum(UPTIME_REGIONS)).min(1).max(3),
+  assertions: z18.array(assertionSchema).max(UPTIME_LIMITS.assertionsMax),
+  failure_threshold: z18.number().int().min(1).max(5),
+  recovery_threshold: z18.number().int().min(1).max(5),
+  cert_warning_days: z18.number().int().min(1).max(60),
+  strict_metadata: z18.boolean(),
+  evidence_on_failure: z18.boolean(),
+  paused_until: z18.string().nullable(),
+  muted_until: z18.string().nullable()
 });
-var timingsSchema = z14.object({
-  dns_ms: z14.number().nonnegative().max(60000).nullable(),
-  connect_ms: z14.number().nonnegative().max(60000).nullable(),
-  tls_ms: z14.number().nonnegative().max(60000).nullable(),
-  ttfb_ms: z14.number().nonnegative().max(60000).nullable(),
-  download_ms: z14.number().nonnegative().max(60000).nullable(),
-  total_ms: z14.number().nonnegative().max(60000)
+var timingsSchema = z18.object({
+  dns_ms: z18.number().nonnegative().max(60000).nullable(),
+  connect_ms: z18.number().nonnegative().max(60000).nullable(),
+  tls_ms: z18.number().nonnegative().max(60000).nullable(),
+  ttfb_ms: z18.number().nonnegative().max(60000).nullable(),
+  download_ms: z18.number().nonnegative().max(60000).nullable(),
+  total_ms: z18.number().nonnegative().max(60000)
 });
-var probeResultSchema = z14.object({
-  check_id: z14.guid(),
-  revision: z14.number().int().nonnegative(),
-  slot: z14.number().int().nonnegative(),
-  region: z14.enum(UPTIME_REGIONS),
-  run_now: z14.string().max(64).optional(),
-  scheduled_at: z14.number().int().positive(),
-  started_at: z14.number().int().positive(),
-  outcome: z14.enum(UPTIME_OUTCOMES),
-  reason: z14.enum(UPTIME_REASONS).nullable(),
-  reason_group: z14.enum(UPTIME_REASON_GROUPS).nullable(),
-  status_code: z14.number().int().min(100).max(599).nullable(),
+var probeResultSchema = z18.object({
+  check_id: z18.guid(),
+  revision: z18.number().int().nonnegative(),
+  slot: z18.number().int().nonnegative(),
+  region: z18.enum(UPTIME_REGIONS),
+  run_now: z18.string().max(64).optional(),
+  scheduled_at: z18.number().int().positive(),
+  started_at: z18.number().int().positive(),
+  outcome: z18.enum(UPTIME_OUTCOMES),
+  reason: z18.enum(UPTIME_REASONS).nullable(),
+  reason_group: z18.enum(UPTIME_REASON_GROUPS).nullable(),
+  status_code: z18.number().int().min(100).max(599).nullable(),
   timings: timingsSchema.nullable(),
-  ip_family: z14.enum(["v4", "v6"]).nullable(),
-  http_version: z14.string().max(8).nullable(),
-  cert_not_after: z14.number().int().positive().nullable(),
-  cert_issuer: z14.string().max(200).nullable(),
-  cert_expiring: z14.boolean(),
-  evidence_sealed: z14.string().max(16384).nullable()
+  ip_family: z18.enum(["v4", "v6"]).nullable(),
+  http_version: z18.string().max(8).nullable(),
+  cert_not_after: z18.number().int().positive().nullable(),
+  cert_issuer: z18.string().max(200).nullable(),
+  cert_expiring: z18.boolean(),
+  evidence_sealed: z18.string().max(16384).nullable()
 });
-var probeIdSchema = z14.string().regex(/^probe-(eu|us|ap)-[a-z0-9]{4,16}$/);
-var resultBatchSchema = z14.object({
-  v: z14.literal(1),
+var probeIdSchema = z18.string().regex(/^probe-(eu|us|ap)-[a-z0-9]{4,16}$/);
+var resultBatchSchema = z18.object({
+  v: z18.literal(1),
   probe_id: probeIdSchema,
-  region: z14.enum(UPTIME_REGIONS),
-  version: z14.string().max(40),
-  sent_at: z14.number().int().positive(),
-  results: z14.array(probeResultSchema).max(UPTIME_LIMITS.resultsBatchMax),
-  stats: z14.object({ lag_p99_ms: z14.number().nonnegative(), checks_per_min: z14.number().nonnegative() })
+  region: z18.enum(UPTIME_REGIONS),
+  version: z18.string().max(40),
+  sent_at: z18.number().int().positive(),
+  results: z18.array(probeResultSchema).max(UPTIME_LIMITS.resultsBatchMax),
+  stats: z18.object({ lag_p99_ms: z18.number().nonnegative(), checks_per_min: z18.number().nonnegative() })
 });
 var assignmentSchema = uptimeDefinitionSchema.omit({ workspace_id: true, paused_until: true, muted_until: true }).extend({
-  seal_public_key: z14.string().regex(/^[A-Za-z0-9_-]{43}$/).nullable()
+  seal_public_key: z18.string().regex(/^[A-Za-z0-9_-]{43}$/).nullable()
 });
-var assignmentsSchema = z14.object({
-  v: z14.literal(1),
-  region: z14.enum(UPTIME_REGIONS),
-  revision: z14.number().int().nonnegative(),
-  issued_at: z14.number().int().positive(),
-  checks: z14.array(assignmentSchema).max(50000),
-  denied_hosts: z14.array(z14.string().max(253)).max(1e4),
-  run_now: z14.array(z14.object({ id: z14.string().max(64), check_id: z14.guid(), expires_at: z14.number().int() })).max(500)
+var assignmentsSchema = z18.object({
+  v: z18.literal(1),
+  region: z18.enum(UPTIME_REGIONS),
+  revision: z18.number().int().nonnegative(),
+  issued_at: z18.number().int().positive(),
+  checks: z18.array(assignmentSchema).max(50000),
+  denied_hosts: z18.array(z18.string().max(253)).max(1e4),
+  run_now: z18.array(z18.object({ id: z18.string().max(64), check_id: z18.guid(), expires_at: z18.number().int() })).max(500)
 });
-var uuid3 = z14.guid();
-var b64key = z14.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var iso2 = z14.string().datetime();
-var uptimeSyncSchema = z14.object({
-  v: z14.literal(1),
+var uuid3 = z18.guid();
+var b64key = z18.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var iso4 = z18.string().datetime();
+var uptimeSyncSchema = z18.object({
+  v: z18.literal(1),
   workspace_id: uuid3,
-  revision: z14.number().int().positive(),
-  workspace_status: z14.enum(["active", "suspended", "deleting"]),
-  suspended: z14.boolean(),
-  checks: z14.array(uptimeDefinitionSchema).max(UPTIME_LIMITS.maxChecksPerWorkspace),
-  projects: z14.array(z14.object({ id: z14.number().int().positive(), node_id: z14.guid().nullable(), seal_public_key: b64key.nullable() })).max(1000)
+  revision: z18.number().int().positive(),
+  workspace_status: z18.enum(["active", "suspended", "deleting"]),
+  suspended: z18.boolean(),
+  checks: z18.array(uptimeDefinitionSchema).max(UPTIME_LIMITS.maxChecksPerWorkspace),
+  projects: z18.array(z18.object({ id: z18.number().int().positive(), node_id: z18.guid().nullable(), seal_public_key: b64key.nullable() })).max(1000)
 });
-var uptimeReconcileSchema = z14.object({
-  v: z14.literal(1),
-  as_of: z14.number().int().positive(),
-  workspace_ids: z14.array(uuid3).max(UPTIME_LIMITS.reconcileMaxWorkspaces),
-  heartbeat_routes: z14.array(z14.string().regex(PING_ROUTE_RE)).max(UPTIME_LIMITS.reconcileMaxWorkspaces).optional()
+var uptimeReconcileSchema = z18.object({
+  v: z18.literal(1),
+  as_of: z18.number().int().positive(),
+  workspace_ids: z18.array(uuid3).max(UPTIME_LIMITS.reconcileMaxWorkspaces),
+  heartbeat_routes: z18.array(z18.string().regex(PING_ROUTE_RE)).max(UPTIME_LIMITS.reconcileMaxWorkspaces).optional()
 });
-var probeDirectorySyncSchema = z14.object({
-  v: z14.literal(1),
-  revision: z14.number().int().positive(),
-  probes: z14.array(z14.object({ probe_id: probeIdSchema, region: z14.enum(UPTIME_REGIONS), public_key: b64key, status: z14.enum(["active", "revoked"]) })).max(30),
-  denied_hosts: z14.array(z14.string().min(1).max(253)).max(1e4)
+var probeDirectorySyncSchema = z18.object({
+  v: z18.literal(1),
+  revision: z18.number().int().positive(),
+  probes: z18.array(z18.object({ probe_id: probeIdSchema, region: z18.enum(UPTIME_REGIONS), public_key: b64key, status: z18.enum(["active", "revoked"]) })).max(30),
+  denied_hosts: z18.array(z18.string().min(1).max(253)).max(1e4)
 });
-var runNowRequestSchema = z14.object({ v: z14.literal(1), workspace_id: uuid3, check_id: uuid3, run_id: z14.string().regex(/^[A-Za-z0-9_-]{8,64}$/) });
-var signedAssignmentsSchema = z14.object({ assignments: assignmentsSchema, sig: z14.string().regex(/^[A-Za-z0-9_-]{86}$/) });
-var uptimeRegionStateSchema = z14.object({
-  region: z14.enum(UPTIME_REGIONS),
-  outcome: z14.enum(UPTIME_OUTCOMES),
-  reason: z14.enum(UPTIME_REASONS).nullable(),
-  status_code: z14.number().int().min(100).max(599).nullable(),
-  total_ms: z14.number().nonnegative().max(60000).nullable(),
+var runNowRequestSchema = z18.object({ v: z18.literal(1), workspace_id: uuid3, check_id: uuid3, run_id: z18.string().regex(/^[A-Za-z0-9_-]{8,64}$/) });
+var signedAssignmentsSchema = z18.object({ assignments: assignmentsSchema, sig: z18.string().regex(/^[A-Za-z0-9_-]{86}$/) });
+var uptimeRegionStateSchema = z18.object({
+  region: z18.enum(UPTIME_REGIONS),
+  outcome: z18.enum(UPTIME_OUTCOMES),
+  reason: z18.enum(UPTIME_REASONS).nullable(),
+  status_code: z18.number().int().min(100).max(599).nullable(),
+  total_ms: z18.number().nonnegative().max(60000).nullable(),
   timings: timingsSchema.nullable().optional(),
-  at: iso2
+  at: iso4
 });
-var uptimeStatusReportSchema = z14.object({
+var uptimeStatusReportSchema = z18.object({
   check_id: uuid3,
-  revision: z14.number().int().nonnegative(),
-  status: z14.enum(UPTIME_STATUSES),
-  last_verdict: z14.enum(SLOT_VERDICTS).nullable(),
-  last_slot_at: iso2.nullable(),
+  revision: z18.number().int().nonnegative(),
+  status: z18.enum(UPTIME_STATUSES),
+  last_verdict: z18.enum(SLOT_VERDICTS).nullable(),
+  last_slot_at: iso4.nullable(),
   incident_id: uuid3.nullable(),
-  down_streak: z14.number().int().nonnegative(),
-  up_streak: z14.number().int().nonnegative(),
-  regions: z14.array(uptimeRegionStateSchema).max(3),
-  unobserved_regions: z14.array(z14.enum(UPTIME_REGIONS)).max(3),
-  cert_not_after: iso2.nullable(),
-  cert_expiring: z14.boolean(),
-  run_now: z14.object({ run_id: z14.string().max(64), results: z14.array(uptimeRegionStateSchema).max(3) }).nullable()
+  down_streak: z18.number().int().nonnegative(),
+  up_streak: z18.number().int().nonnegative(),
+  regions: z18.array(uptimeRegionStateSchema).max(3),
+  unobserved_regions: z18.array(z18.enum(UPTIME_REGIONS)).max(3),
+  cert_not_after: iso4.nullable(),
+  cert_expiring: z18.boolean(),
+  run_now: z18.object({ run_id: z18.string().max(64), results: z18.array(uptimeRegionStateSchema).max(3) }).nullable()
 });
 var UPTIME_EVENT_KINDS = ["opened", "resolved", "cert_expiring"];
-var uptimeEventSchema = z14.object({
-  event_id: z14.string().regex(/^[A-Za-z0-9:_-]{8,96}$/),
+var uptimeEventSchema = z18.object({
+  event_id: z18.string().regex(/^[A-Za-z0-9:_-]{8,96}$/),
   check_id: uuid3,
-  kind: z14.enum(UPTIME_EVENT_KINDS),
+  kind: z18.enum(UPTIME_EVENT_KINDS),
   incident_id: uuid3.nullable(),
-  at: iso2,
-  reason: z14.enum(UPTIME_REASONS).nullable(),
-  regions: z14.array(z14.enum(UPTIME_REGIONS)).max(3),
-  cert_days_left: z14.number().int().nullable()
+  at: iso4,
+  reason: z18.enum(UPTIME_REASONS).nullable(),
+  regions: z18.array(z18.enum(UPTIME_REGIONS)).max(3),
+  cert_days_left: z18.number().int().nullable()
 });
-var uptimeMinuteSchema = z14.object({
+var uptimeMinuteSchema = z18.object({
   check_id: uuid3,
-  minute: iso2,
-  up: z14.number().int().nonnegative(),
-  degraded: z14.number().int().nonnegative(),
-  down: z14.number().int().nonnegative(),
-  unknown: z14.number().int().nonnegative(),
-  latency: z14.array(z14.object({ region: z14.enum(UPTIME_REGIONS), n: z14.number().int().positive(), p50_ms: z14.number().nonnegative(), p95_ms: z14.number().nonnegative() })).max(3)
+  minute: iso4,
+  up: z18.number().int().nonnegative(),
+  degraded: z18.number().int().nonnegative(),
+  down: z18.number().int().nonnegative(),
+  unknown: z18.number().int().nonnegative(),
+  latency: z18.array(z18.object({ region: z18.enum(UPTIME_REGIONS), n: z18.number().int().positive(), p50_ms: z18.number().nonnegative(), p95_ms: z18.number().nonnegative() })).max(3)
 });
-var uptimeReportSchema = z14.object({
-  v: z14.literal(1),
+var uptimeReportSchema = z18.object({
+  v: z18.literal(1),
   workspace_id: uuid3,
-  revision: z14.number().int().nonnegative(),
-  sent_at: iso2,
-  events: z14.array(uptimeEventSchema).max(UPTIME_LIMITS.reportMaxEvents),
-  statuses: z14.array(uptimeStatusReportSchema).max(UPTIME_LIMITS.reportMaxStatuses),
-  minutes: z14.array(uptimeMinuteSchema).max(UPTIME_LIMITS.reportMaxMinutes)
+  revision: z18.number().int().nonnegative(),
+  sent_at: iso4,
+  events: z18.array(uptimeEventSchema).max(UPTIME_LIMITS.reportMaxEvents),
+  statuses: z18.array(uptimeStatusReportSchema).max(UPTIME_LIMITS.reportMaxStatuses),
+  minutes: z18.array(uptimeMinuteSchema).max(UPTIME_LIMITS.reportMaxMinutes)
 });
-var probeFleetReportSchema = z14.object({
-  v: z14.literal(1),
-  sent_at: iso2,
-  probes: z14.array(z14.object({
+var probeFleetReportSchema = z18.object({
+  v: z18.literal(1),
+  sent_at: iso4,
+  probes: z18.array(z18.object({
     probe_id: probeIdSchema,
-    region: z14.enum(UPTIME_REGIONS),
-    version: z14.string().max(40).nullable(),
-    last_seen_at: iso2.nullable(),
-    lag_p99_ms: z14.number().nonnegative().nullable(),
-    checks_per_min: z14.number().nonnegative().nullable()
+    region: z18.enum(UPTIME_REGIONS),
+    version: z18.string().max(40).nullable(),
+    last_seen_at: iso4.nullable(),
+    lag_p99_ms: z18.number().nonnegative().nullable(),
+    checks_per_min: z18.number().nonnegative().nullable()
   })).max(30),
-  regions_alive: z14.array(z14.enum(UPTIME_REGIONS)).max(3)
+  regions_alive: z18.array(z18.enum(UPTIME_REGIONS)).max(3)
 });
-var probeEnrollSchema = z14.object({
-  v: z14.literal(1),
+var probeEnrollSchema = z18.object({
+  v: z18.literal(1),
   probe_id: probeIdSchema,
-  public_key: z14.string().regex(/^[A-Za-z0-9_-]{43}$/),
-  code: z14.string().regex(/^[A-Za-z0-9_-]{43}$/),
-  ts: z14.number().int().positive(),
-  sig: z14.string().regex(/^[A-Za-z0-9_-]{86}$/)
+  public_key: z18.string().regex(/^[A-Za-z0-9_-]{43}$/),
+  code: z18.string().regex(/^[A-Za-z0-9_-]{43}$/),
+  ts: z18.number().int().positive(),
+  sig: z18.string().regex(/^[A-Za-z0-9_-]{86}$/)
 });
-var uptimeEvidenceEnvelopeSchema = z14.object({
-  v: z14.literal(1),
-  check_id: z14.guid(),
-  slot: z14.number().int().nonnegative(),
-  region: z14.enum(UPTIME_REGIONS),
+var uptimeEvidenceEnvelopeSchema = z18.object({
+  v: z18.literal(1),
+  check_id: z18.guid(),
+  slot: z18.number().int().nonnegative(),
+  region: z18.enum(UPTIME_REGIONS),
   probe_id: probeIdSchema,
-  at: z14.number().int().positive(),
-  sealed: z14.string().regex(/^[A-Za-z0-9_-]+$/).max(16384)
+  at: z18.number().int().positive(),
+  sealed: z18.string().regex(/^[A-Za-z0-9_-]+$/).max(16384)
 }).strict();
-var uptimeEvidenceSchema = z14.object({
-  v: z14.literal(1),
-  check_id: z14.guid(),
-  slot: z14.number().int().nonnegative(),
-  region: z14.enum(UPTIME_REGIONS),
-  at: z14.number().int().positive(),
-  reason: z14.enum(UPTIME_REASONS).nullable(),
-  status_line: z14.string().max(200).nullable(),
-  headers: z14.record(z14.string().max(64), z14.string().max(512)).refine((h) => Object.keys(h).length <= 20),
-  body: z14.string().max(UPTIME_LIMITS.evidenceMaxBytes * 4).nullable(),
-  body_truncated: z14.boolean(),
+var uptimeEvidenceSchema = z18.object({
+  v: z18.literal(1),
+  check_id: z18.guid(),
+  slot: z18.number().int().nonnegative(),
+  region: z18.enum(UPTIME_REGIONS),
+  at: z18.number().int().positive(),
+  reason: z18.enum(UPTIME_REASONS).nullable(),
+  status_line: z18.string().max(200).nullable(),
+  headers: z18.record(z18.string().max(64), z18.string().max(512)).refine((h) => Object.keys(h).length <= 20),
+  body: z18.string().max(UPTIME_LIMITS.evidenceMaxBytes * 4).nullable(),
+  body_truncated: z18.boolean(),
   timings: timingsSchema.nullable(),
-  ip: z14.string().max(64).nullable(),
-  error: z14.string().max(300).nullable()
+  ip: z18.string().max(64).nullable(),
+  error: z18.string().max(300).nullable()
 }).strict();
-var uptimeEvidenceListSchema = z14.object({
-  items: z14.array(uptimeEvidenceSchema.extend({ received_at: z14.number().int().positive() })).max(UPTIME_LIMITS.evidenceKeepPerCheck)
+var uptimeEvidenceListSchema = z18.object({
+  items: z18.array(uptimeEvidenceSchema.extend({ received_at: z18.number().int().positive() })).max(UPTIME_LIMITS.evidenceKeepPerCheck)
 });
 
 // ../src/shared/contracts/api-ops/monitors.ts
-var anyMonitorInputSchema = z15.union([monitorInputSchema, signalMonitorInputSchema]);
+var anyMonitorInputSchema = z19.union([monitorInputSchema, signalMonitorInputSchema]);
 var MAINTENANCE_INPUTS = {
-  create: z15.object({ workspaceId: uuid, input: maintenanceInputSchema }),
-  update: z15.object({ workspaceId: uuid, windowId: uuid, input: maintenanceInputSchema }),
-  delete: z15.object({ workspaceId: uuid, windowId: uuid })
+  create: z19.object({ workspaceId: uuid, input: maintenanceInputSchema }),
+  update: z19.object({ workspaceId: uuid, windowId: uuid, input: maintenanceInputSchema }),
+  delete: z19.object({ workspaceId: uuid, windowId: uuid })
 };
 var MONITOR_INPUTS = {
-  create: z15.object({ projectId, slug: z15.string().regex(SLUG_RE), input: anyMonitorInputSchema }),
-  update: z15.object({ monitorId: uuid, input: anyMonitorInputSchema }),
-  delete: z15.object({ monitorId: uuid, confirmSlug: z15.string().max(64) }),
-  setPause: z15.object({ monitorId: uuid, until: holdUntil }),
-  setMuted: z15.object({ monitorId: uuid, muted: z15.boolean() }),
-  dismissDiscovery: z15.object({ discoveryId: uuid }),
-  rotatePing: z15.object({
+  create: z19.object({ projectId, slug: z19.string().regex(SLUG_RE), input: anyMonitorInputSchema }),
+  update: z19.object({ monitorId: uuid, input: anyMonitorInputSchema }),
+  delete: z19.object({ monitorId: uuid, confirmSlug: z19.string().max(64) }),
+  setPause: z19.object({ monitorId: uuid, until: holdUntil }),
+  setMuted: z19.object({ monitorId: uuid, muted: z19.boolean() }),
+  dismissDiscovery: z19.object({ discoveryId: uuid }),
+  rotatePing: z19.object({
     monitorId: uuid,
-    graceHours: z15.number().int().refine((h) => HEARTBEAT_LIMITS.rotationGraceHoursChoices.includes(h))
+    graceHours: z19.number().int().refine((h) => HEARTBEAT_LIMITS.rotationGraceHoursChoices.includes(h))
   }),
-  monitorOnly: z15.object({ monitorId: uuid })
+  monitorOnly: z19.object({ monitorId: uuid })
 };
 var UPTIME_INPUTS = {
   create: uptimeCheckInputSchema,
-  update: z15.object({ checkId: uuid, input: uptimeCheckInputSchema }),
-  checkOnly: z15.object({ checkId: uuid }),
-  setHold: z15.object({ checkId: uuid, kind: z15.enum(["pause", "mute"]), until: holdUntil })
+  update: z19.object({ checkId: uuid, input: uptimeCheckInputSchema }),
+  checkOnly: z19.object({ checkId: uuid }),
+  setHold: z19.object({ checkId: uuid, kind: z19.enum(["pause", "mute"]), until: holdUntil })
 };
 var SLO_INPUTS = {
-  create: z15.object({ workspaceId: uuid, input: sloInputSchema }),
-  update: z15.object({ sloId: uuid, input: sloInputSchema }),
-  sloOnly: z15.object({ sloId: uuid }),
-  setHold: z15.object({ sloId: uuid, kind: z15.enum(["pause", "mute"]), until: holdUntil }),
-  import: z15.object({
+  create: z19.object({ workspaceId: uuid, input: sloInputSchema }),
+  update: z19.object({ sloId: uuid, input: sloInputSchema }),
+  sloOnly: z19.object({ sloId: uuid }),
+  setHold: z19.object({ sloId: uuid, kind: z19.enum(["pause", "mute"]), until: holdUntil }),
+  import: z19.object({
     workspaceId: uuid,
-    text: z15.string().max(SLO_LIMITS.openSloMaxBytes * 2),
-    dryRun: z15.boolean()
+    text: z19.string().max(SLO_LIMITS.openSloMaxBytes * 2),
+    dryRun: z19.boolean()
   })
 };
 var m = "monitors:write";
@@ -2615,19 +3089,19 @@ var MONITOR_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/node-data.ts
-import { z as z16 } from "zod";
-var issueId = z16.number().int().positive();
-var csv = z16.string().min(1).max(2000);
-var name2 = z16.string().min(1).max(256);
-var period = z16.enum(["1h", "24h", "7d", "14d", "30d"]);
-var nodeCursor = z16.string().min(1).max(600).optional();
+import { z as z20 } from "zod";
+var issueId = z20.number().int().positive();
+var csv = z20.string().min(1).max(2000);
+var name2 = z20.string().min(1).max(256);
+var period = z20.enum(["1h", "24h", "7d", "14d", "30d"]);
+var nodeCursor = z20.string().min(1).max(600).optional();
 var windowFields = {
-  start: z16.string().max(40).optional(),
-  end: z16.string().max(40).optional()
+  start: z20.string().max(40).optional(),
+  end: z20.string().max(40).optional()
 };
-var traceId = z16.string().regex(/^[0-9a-fA-F]{32}$/);
-var spanId = z16.string().regex(/^[0-9a-fA-F]{16}$/);
-var attrs = z16.string().max(2000).optional();
+var traceId = z20.string().regex(/^[0-9a-fA-F]{32}$/);
+var spanId = z20.string().regex(/^[0-9a-fA-F]{16}$/);
+var attrs = z20.string().max(2000).optional();
 var telemetryCommon = {
   ...windowFields,
   project: csv.optional(),
@@ -2635,112 +3109,134 @@ var telemetryCommon = {
   service: csv.optional(),
   attrs
 };
-var issueChange = z16.union([
-  z16.object({ action: z16.literal("resolve"), inNextRelease: z16.boolean().optional() }),
-  z16.object({ action: z16.literal("unresolve") }),
-  z16.object({ action: z16.literal("archive"), mode: z16.enum(["until_escalating", "forever"]) }),
-  z16.object({
-    action: z16.literal("archive"),
-    mode: z16.literal("until_condition"),
-    events: z16.number().int().min(1).max(1e6).optional(),
-    users: z16.number().int().min(1).max(1e5).optional(),
-    until: z16.string().datetime().optional()
-  }),
-  z16.object({ action: z16.literal("assign"), userId: z16.guid().nullable() }),
-  z16.object({ action: z16.literal("priority"), priority: z16.enum(["low", "medium", "high"]) })
+var issueChange = z20.union([
+  z20.object({ action: z20.literal("resolve"), inNextRelease: z20.boolean().optional() }),
+  z20.object({ action: z20.literal("unresolve") }),
+  z20.object({ action: z20.literal("archive"), mode: z20.enum(["until_escalating", "forever"]) }),
+  z20.object({
+    action: z20.literal("archive"),
+    mode: z20.literal("until_condition"),
+    events: z20.number().int().min(1).max(1e6).optional(),
+    users: z20.number().int().min(1).max(1e5).optional(),
+    until: z20.string().datetime().optional()
+  }),
+  z20.object({ action: z20.literal("assign"), userId: z20.guid().nullable() }),
+  z20.object({ action: z20.literal("priority"), priority: z20.enum(["low", "medium", "high"]) })
 ]);
 var NODE_INPUTS = {
-  issuesList: z16.object({
+  issuesList: z20.object({
     project: csv.optional(),
-    status: z16.enum(["unresolved", "resolved", "archived", "all"]).optional(),
+    status: z20.enum(["unresolved", "resolved", "archived", "all"]).optional(),
     level: csv.optional(),
     priority: csv.optional(),
     environment: csv.optional(),
     release: csv.optional(),
-    assignee: z16.string().max(64).optional(),
+    assignee: z20.string().max(64).optional(),
     period: period.optional(),
-    q: z16.string().max(200).optional(),
-    sort: z16.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
+    q: z20.string().max(200).optional(),
+    sort: z20.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
     cursor: nodeCursor,
-    limit: z16.number().int().min(1).max(100).optional()
+    limit: z20.number().int().min(1).max(100).optional()
   }),
-  issue: z16.object({ issueId }),
-  issueStats: z16.object({ issueId, range: z16.enum(["24h", "30d"]).optional() }),
-  issueEvents: z16.object({ issueId, cursor: nodeCursor }),
-  issueEvent: z16.object({
+  issue: z20.object({ issueId }),
+  issueStats: z20.object({ issueId, range: z20.enum(["24h", "30d"]).optional() }),
+  issueEvents: z20.object({ issueId, cursor: nodeCursor }),
+  issueEvent: z20.object({
     issueId,
-    eventId: z16.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
+    eventId: z20.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
   }),
-  issueUpdate: z16.object({ issueId, change: issueChange }),
-  issuesBulk: z16.object({
-    issueIds: z16.array(issueId).min(1).max(100),
+  issueUpdate: z20.object({ issueId, change: issueChange }),
+  issuesBulk: z20.object({
+    issueIds: z20.array(issueId).min(1).max(100),
     action: issueChange
   }),
-  spansList: z16.object({
+  spansList: z20.object({
     ...telemetryCommon,
-    operation: z16.string().min(1).max(1024).optional(),
-    status: z16.enum(["unset", "ok", "error"]).optional(),
-    kind: z16.enum(["internal", "server", "client", "producer", "consumer"]).optional(),
-    minDurationMs: z16.number().min(0).max(86400000).optional(),
-    maxDurationMs: z16.number().min(0).max(86400000).optional(),
-    mode: z16.enum(["spans", "traces"]).optional(),
+    operation: z20.string().min(1).max(1024).optional(),
+    status: z20.enum(["unset", "ok", "error"]).optional(),
+    kind: z20.enum(["internal", "server", "client", "producer", "consumer"]).optional(),
+    minDurationMs: z20.number().min(0).max(86400000).optional(),
+    maxDurationMs: z20.number().min(0).max(86400000).optional(),
+    mode: z20.enum(["spans", "traces"]).optional(),
     cursor: nodeCursor
   }),
-  spansHistogram: z16.object({
+  spansHistogram: z20.object({
     ...telemetryCommon,
-    operation: z16.string().min(1).max(1024).optional(),
-    status: z16.enum(["unset", "ok", "error"]).optional()
+    operation: z20.string().min(1).max(1024).optional(),
+    status: z20.enum(["unset", "ok", "error"]).optional()
   }),
-  trace: z16.object({ traceId }),
-  traceSpans: z16.object({ traceId, errorsOnly: z16.enum(["1"]).optional(), ...windowFields }),
-  span: z16.object({ traceId, spanId, ...windowFields }),
-  logsList: z16.object({
+  trace: z20.object({ traceId }),
+  traceSpans: z20.object({ traceId, errorsOnly: z20.enum(["1"]).optional(), ...windowFields }),
+  span: z20.object({ traceId, spanId, ...windowFields }),
+  logsList: z20.object({
     ...telemetryCommon,
-    severityMin: z16.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    severityMin: z20.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
     traceId: traceId.optional(),
     spanId: spanId.optional(),
-    q: z16.string().max(500).optional(),
-    order: z16.enum(["asc", "desc"]).optional(),
+    q: z20.string().max(500).optional(),
+    order: z20.enum(["asc", "desc"]).optional(),
     cursor: nodeCursor
   }),
-  logsFacets: z16.object({
+  logsFacets: z20.object({
     ...telemetryCommon,
-    severityMin: z16.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
-    q: z16.string().max(500).optional()
+    severityMin: z20.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    q: z20.string().max(500).optional()
   }),
-  logAround: z16.object({
+  logAround: z20.object({
     logId: name2,
-    at: z16.string().max(40),
-    same: z16.enum(["service", "trace"]).optional(),
-    before: z16.number().int().min(0).max(200).optional(),
-    after: z16.number().int().min(0).max(200).optional()
-  }),
-  telemetryUsage: z16.object({ project: csv.optional(), days: z16.number().int().min(1).max(31).optional() }),
-  monitorSignal: z16.object({ monitorId: z16.guid(), hours: z16.number().int().min(1).max(24).optional() }),
-  monitorOccurrences: z16.object({
-    monitorId: z16.guid(),
-    state: z16.enum(["open", "finished", "all"]).optional(),
-    environment: z16.string().min(1).max(64).optional(),
+    at: z20.string().max(40),
+    same: z20.enum(["service", "trace"]).optional(),
+    before: z20.number().int().min(0).max(200).optional(),
+    after: z20.number().int().min(0).max(200).optional()
+  }),
+  metricsNames: z20.object({
+    project: z20.number().int().positive(),
+    environment: csv.optional(),
+    q: z20.string().max(255).optional()
+  }),
+  metricsSeries: z20.object({
+    project: z20.number().int().positive(),
+    name: z20.string().regex(METRIC_NAME_RE),
+    environment: csv.optional(),
+    attrs,
+    cursor: z20.string().regex(/^[0-9a-f]{16}$/).optional()
+  }),
+  metricsQuery: z20.object({
+    project: z20.number().int().positive(),
+    name: z20.string().regex(METRIC_NAME_RE),
+    aggregation: z20.enum(METRIC_AGGREGATIONS),
+    ...windowFields,
+    step: z20.number().int().min(METRIC_QUERY.minStepSeconds).max(METRIC_QUERY.maxStepSeconds).multipleOf(60).optional(),
+    attrs,
+    groupBy: z20.string().min(1).max(600).optional(),
+    environment: csv.optional()
+  }),
+  telemetryUsage: z20.object({ project: csv.optional(), days: z20.number().int().min(1).max(31).optional() }),
+  monitorSignal: z20.object({ monitorId: z20.guid(), hours: z20.number().int().min(1).max(24).optional() }),
+  monitorOccurrences: z20.object({
+    monitorId: z20.guid(),
+    state: z20.enum(["open", "finished", "all"]).optional(),
+    environment: z20.string().min(1).max(64).optional(),
     cursor: nodeCursor
   }),
-  monitorBacktest: z16.object({ project: z16.number().int().positive(), settings: backtestSettingsSchema }),
-  occurrenceCreate: z16.object({
-    project: z16.number().int().positive(),
+  monitorBacktest: z20.object({ project: z20.number().int().positive(), settings: backtestSettingsSchema }),
+  occurrenceCreate: z20.object({
+    project: z20.number().int().positive(),
     monitorSlug: occurrenceInputSchema.shape.monitor_slug,
     occurrenceId: occurrenceInputSchema.shape.occurrence_id,
     dueAt: occurrenceInputSchema.shape.due_at,
     environment: occurrenceInputSchema.shape.environment
   }),
-  occurrenceCancel: z16.object({
-    project: z16.number().int().positive(),
-    monitorSlug: z16.string().regex(SLUG_RE),
-    occurrenceId: z16.string().regex(OCCURRENCE_ID_RE),
-    environment: z16.string().min(1).max(64).optional()
+  occurrenceCancel: z20.object({
+    project: z20.number().int().positive(),
+    monitorSlug: z20.string().regex(SLUG_RE),
+    occurrenceId: z20.string().regex(OCCURRENCE_ID_RE),
+    environment: z20.string().min(1).max(64).optional()
   }),
-  ticket: z16.object({
-    scope: z16.enum(["read", "write"]).default("read"),
-    project: z16.number().int().positive().optional(),
-    environment: z16.string().min(1).max(64).optional()
+  ticket: z20.object({
+    scope: z20.enum(["read", "write"]).default("read"),
+    project: z20.number().int().positive().optional(),
+    environment: z20.string().min(1).max(64).optional()
   })
 };
 var N = NODE_INPUTS;
@@ -2902,6 +3398,34 @@ var NODE_OPERATIONS = [
     node: { path: "q/logs/{log_id}/around" },
     summary: "Log records just before and after one record."
   }),
+  op({
+    ...read,
+    id: "metrics.names",
+    path: "/v1/metrics/names",
+    scope: "metrics:read",
+    input: N.metricsNames,
+    node: { path: "q/metrics/names" },
+    summary: "The metric catalog of one project (name, type, kind, unit, series count, last seen) and the node's series and name caps with the metrics it is dropping points for."
+  }),
+  op({
+    ...read,
+    id: "metrics.series",
+    path: "/v1/metrics/series",
+    scope: "metrics:read",
+    input: N.metricsSeries,
+    node: { path: "q/metrics/series", list: "series" },
+    paged: true,
+    summary: "The time series of one metric (attributes, service, environment, first and last seen), 100 per page."
+  }),
+  op({
+    ...read,
+    id: "metrics.query",
+    path: "/v1/metrics/query",
+    scope: "metrics:read",
+    input: N.metricsQuery,
+    node: { path: "q/metrics/query", window: true },
+    summary: "One metric aggregated per step (avg, sum, min, max, count, rate, p50–p99) in a window of at most 7 days, optionally grouped by up to two attributes (≤ 50 groups, ≤ 10,000 points), with exemplar trace ids."
+  }),
   op({
     ...read,
     id: "telemetry.usage",
@@ -3001,12 +3525,122 @@ var NODE_OPERATIONS = [
   })
 ];
 
-// ../src/shared/contracts/api-ops/projects.ts
+// ../src/shared/contracts/api-ops/privacy.ts
+import { z as z22 } from "zod";
+
+// ../src/shared/contracts/privacy.ts
 import { z as z21 } from "zod";
 
+// ../src/shared/privacy/rules.ts
+var PRIVACY_SCHEMA = 1;
+var PRIVACY_LIMITS = {
+  rules: 100,
+  allowlist: 100,
+  selector: 256,
+  pattern: 256,
+  replaceWith: 32,
+  ruleId: 64,
+  stringChars: 16384,
+  quantifierMax: 1000,
+  matches: 500,
+  depth: 32
+};
+var PRIVACY_MODES = ["standard", "strict"];
+var PRIVACY_RULE_TYPES = ["pattern", "anything", "creditcard", "ip", "email", "phone_e164"];
+var PRIVACY_METHODS = ["remove", "replace", "mask", "hash"];
+var AUTH_HEADER_KEYS = new Set(["authorization", "proxy-authorization", "x-api-key", "x-auth-token", "x-sentry-auth", "x-amz-security-token"]);
+var COOKIE_KEYS = new Set(["cookie", "cookies", "set-cookie"]);
+var BODY_KEYS = new Set(["body", "request_body", "response_body", "raw_body", "message_body", "html_body"]);
+var CARD_KEYS = new Set(["card_number", "cardnumber", "cc_number", "ccnum", "cvv", "cvc", "pan"]);
+var OCTET = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+var IPV4_RE = new RegExp(`(^|[^\\d.])(${OCTET}(?:\\.${OCTET}){3})(?![\\d.])`, "g");
+var H = "[0-9A-Fa-f]{1,4}";
+var IPV6_RE = new RegExp(`(^|[^0-9A-Fa-f:])((?:${H}:){7}${H}|(?:${H}:){1,6}:(?:${H}(?::${H}){0,5})?|::(?:${H}(?::${H}){0,6})?)(?![0-9A-Fa-f:])`, "g");
+var REMOVE = Symbol("remove");
+
+// ../src/shared/contracts/privacy.ts
+var ruleId = z21.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
+var privacyRuleInputSchema = z21.object({
+  id: ruleId,
+  selector: z21.string().min(1).max(PRIVACY_LIMITS.selector),
+  type: z21.enum(PRIVACY_RULE_TYPES),
+  method: z21.enum(PRIVACY_METHODS),
+  pattern: z21.string().min(1).max(PRIVACY_LIMITS.pattern).optional(),
+  ignoreCase: z21.boolean().optional(),
+  replaceWith: z21.string().max(PRIVACY_LIMITS.replaceWith).optional(),
+  enabled: z21.boolean().optional()
+});
+var privacyPolicyInputSchema = z21.object({
+  mode: z21.enum(PRIVACY_MODES),
+  rules: z21.array(privacyRuleInputSchema).max(PRIVACY_LIMITS.rules),
+  allowlist: z21.array(z21.string().min(1).max(PRIVACY_LIMITS.selector)).max(PRIVACY_LIMITS.allowlist)
+});
+var storedPolicySchema = z21.object({
+  schema: z21.literal(PRIVACY_SCHEMA),
+  version: z21.number().int().min(0),
+  mode: z21.enum(PRIVACY_MODES),
+  rules: z21.array(z21.record(z21.string(), z21.unknown())).max(PRIVACY_LIMITS.rules),
+  allowlist: z21.array(z21.string()).max(PRIVACY_LIMITS.allowlist)
+});
+var nodePrivacyBlockSchema = z21.array(z21.object({ project_id: z21.number().int().positive(), policy: z21.unknown() })).max(1000);
+var privacyRollupSchema = z21.object({
+  applied_version: z21.number().int().min(0).nullable(),
+  policy_missing_24h: z21.number().int().nonnegative(),
+  budget_exceeded_24h: z21.number().int().nonnegative(),
+  sdk_versions: z21.array(z21.object({ version: z21.number().int().min(0), last_seen_at: z21.string().datetime() })).max(5)
+});
+
+// ../src/shared/contracts/api-ops/privacy.ts
+var PRIVACY_INPUTS = {
+  get: z22.object({ workspaceId: uuid, projectId }),
+  set: z22.object({
+    workspaceId: uuid,
+    projectId,
+    expectedVersion: z22.number().int().min(0),
+    policy: privacyPolicyInputSchema
+  })
+};
+var P = PRIVACY_INPUTS;
+var PRIVACY_OPERATIONS = [
+  op({
+    id: "privacy.get",
+    method: "GET",
+    path: "/v1/projects/{project_id}/privacy",
+    scope: "projects:read",
+    sensitivity: "normal",
+    kind: "read",
+    rpcs: ["api_read_privacy"],
+    input: P.get,
+    workspace: true,
+    idempotency: "none",
+    mcp: "configure",
+    summary: "A project's privacy policy (mode, rules, strict allowlist, version), the built-in detectors that are off, whether user ids are pseudonymised, the last 20 versions and what the node applies and counted in the last 24 h.",
+    ui: []
+  }),
+  op({
+    id: "privacy.set",
+    method: "PUT",
+    path: "/v1/projects/{project_id}/privacy",
+    scope: "privacy:write",
+    sensitivity: "approval",
+    kind: "write",
+    rpcs: ["set_privacy_policy"],
+    input: P.set,
+    bodyField: "policy",
+    workspace: true,
+    idempotency: "optional",
+    mcp: "configure",
+    summary: "Replace a project's privacy policy (rules are applied in order on the node before anything is stored). Always needs an admin's approval; loosening (a rule removed or changed, strict off, allowlist grown) also needs their fresh authenticator code and emails owners.",
+    ui: ["privacy#setPrivacyPolicy"]
+  })
+];
+
+// ../src/shared/contracts/api-ops/projects.ts
+import { z as z26 } from "zod";
+
 // ../src/shared/contracts/ingest-keys.ts
-import { z as z17 } from "zod";
-var INGEST_KEY_SCOPES = ["traces", "logs", "errors", "monitors"];
+import { z as z23 } from "zod";
+var INGEST_KEY_SCOPES = ["traces", "logs", "metrics", "errors", "monitors"];
 var INGEST_KEY_STATES = ["active", "revoked"];
 var INGEST_KEY_LIMITS = {
   nameMaxChars: 80,
@@ -3015,174 +3649,92 @@ var INGEST_KEY_LIMITS = {
   edgeCacheSeconds: 60
 };
 var CHECKIN_AUTH_MODES = ["public_or_key", "key_only"];
-var ingestKeyConfigSchema = z17.object({
-  v: z17.literal(1),
-  key_id: z17.guid(),
-  project_public_id: z17.number().int().positive(),
-  project_id: z17.number().int().positive(),
-  workspace_id: z17.guid(),
+var ingestKeyConfigSchema = z23.object({
+  v: z23.literal(1),
+  key_id: z23.guid(),
+  project_public_id: z23.number().int().positive(),
+  project_id: z23.number().int().positive(),
+  workspace_id: z23.guid(),
   node_id: nodeIdSchema,
-  scopes: z17.array(z17.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
-  environments: z17.array(z17.string().max(INGEST_KEY_LIMITS.environmentMaxChars)).max(INGEST_KEY_LIMITS.environmentsMax),
-  expires_at: z17.string().datetime({ offset: true }).nullable(),
-  state: z17.enum(INGEST_KEY_STATES),
-  workspace_status: z17.enum(["active", "suspended", "deleting"]),
-  ingest_kill: z17.boolean(),
-  telemetry_kill: z17.boolean(),
-  telemetry_rate_bytes_per_sec: z17.number().int().positive(),
-  telemetry_burst_bytes: z17.number().int().positive(),
-  traces_monthly_bytes: z17.number().int().positive(),
-  logs_monthly_bytes: z17.number().int().positive(),
-  telemetry_buffer_minutes: z17.number().int().min(1).max(1440),
-  revision: z17.number().int().nonnegative()
+  scopes: z23.array(z23.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z23.array(z23.string().max(INGEST_KEY_LIMITS.environmentMaxChars)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expires_at: z23.string().datetime({ offset: true }).nullable(),
+  state: z23.enum(INGEST_KEY_STATES),
+  workspace_status: z23.enum(["active", "suspended", "deleting"]),
+  ingest_kill: z23.boolean(),
+  telemetry_kill: z23.boolean(),
+  telemetry_rate_bytes_per_sec: z23.number().int().positive(),
+  telemetry_burst_bytes: z23.number().int().positive(),
+  traces_monthly_bytes: z23.number().int().positive(),
+  logs_monthly_bytes: z23.number().int().positive(),
+  metrics_monthly_bytes: z23.number().int().positive().optional(),
+  telemetry_buffer_minutes: z23.number().int().min(1).max(1440),
+  revision: z23.number().int().nonnegative()
 });
-var createIngestKeyInputSchema = z17.object({
-  projectId: z17.number().int().positive(),
-  name: z17.string().trim().min(1).max(INGEST_KEY_LIMITS.nameMaxChars).refine((s) => !/[\u0000-\u001f\u007f]/.test(s)),
-  scopes: z17.array(z17.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
-  environments: z17.array(z17.string().trim().min(1).max(INGEST_KEY_LIMITS.environmentMaxChars).regex(/^[^\s/\u0000-\u001f]+$/)).max(INGEST_KEY_LIMITS.environmentsMax),
-  expiresAt: z17.string().datetime({ offset: true }).nullable()
+var createIngestKeyInputSchema = z23.object({
+  projectId: z23.number().int().positive(),
+  name: z23.string().trim().min(1).max(INGEST_KEY_LIMITS.nameMaxChars).refine((s) => !/[\u0000-\u001f\u007f]/.test(s)),
+  scopes: z23.array(z23.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z23.array(z23.string().trim().min(1).max(INGEST_KEY_LIMITS.environmentMaxChars).regex(/^[^\s/\u0000-\u001f]+$/)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expiresAt: z23.string().datetime({ offset: true }).nullable()
 });
-var ingestKeyRowSchema = z17.object({
-  id: z17.guid(),
-  project_id: z17.number().int().positive(),
-  name: z17.string(),
-  prefix: z17.string(),
-  scopes: z17.array(z17.enum(INGEST_KEY_SCOPES)),
-  environments: z17.array(z17.string()),
-  expires_at: z17.string().nullable(),
-  state: z17.enum(INGEST_KEY_STATES),
-  created_by: z17.guid().nullable(),
-  created_at: z17.string(),
-  revoked_at: z17.string().nullable(),
-  last_used_at: z17.string().nullable()
-});
-
-// ../src/shared/contracts/integration-health.ts
-import { z as z18 } from "zod";
-
-// ../src/shared/contracts/platforms.ts
-var PLATFORMS = [
-  "javascript-browser",
-  "react",
-  "node",
-  "python",
-  "tanstack-start",
-  "other"
-];
-
-// ../src/shared/contracts/integration-health.ts
-var VERIFICATION_ID_RE = /^bv1_[0-9a-f]{32}$/;
-var verificationIdSchema = z18.string().regex(VERIFICATION_ID_RE);
-var SURFACES = ["browser", "server"];
-var RECEIPT_SURFACES = ["browser", "server", "belvador"];
-var CHECKS = ["delivery", "uncaught", "pipeline"];
-var HOOK_STATES = ["ok", "missing", "unknown"];
-var verificationContextSchema = z18.object({
-  v: z18.literal(1),
-  surface: z18.enum(RECEIPT_SURFACES),
-  check: z18.enum(CHECKS),
-  hook: z18.enum(HOOK_STATES).optional(),
-  uncaught_expected: z18.boolean().optional()
-});
-var iso3 = z18.string().datetime();
-var projectId3 = z18.number().int().positive();
-var verificationReceiptSchema = z18.object({
-  project_id: projectId3,
-  verification_id: verificationIdSchema,
-  surface: z18.enum(RECEIPT_SURFACES),
-  check: z18.enum(CHECKS),
-  hook: z18.enum(HOOK_STATES),
-  uncaught_expected: z18.boolean(),
-  sdk_name: z18.string().max(80),
-  sdk_version: z18.string().max(40),
-  environment: z18.string().max(64),
-  release: z18.string().max(200),
-  source_host: z18.string().max(253),
-  received_at: iso3
-});
-var SDK_DELIVERY_DROP_REASONS = ["network_error", "queue_overflow", "send_error"];
-var clientDiscardSchema = z18.object({
-  hour: iso3,
-  reason: z18.enum(SDK_DELIVERY_DROP_REASONS),
-  n: z18.number().int().nonnegative()
-});
-var edgeVerificationRequestSchema = z18.object({
-  v: z18.literal(1),
-  project_id: projectId3,
-  verification_id: verificationIdSchema
-});
-var readbackCheckSchema = z18.object({
-  surface: z18.enum(RECEIPT_SURFACES),
-  check: z18.enum(CHECKS),
-  hook: z18.enum(HOOK_STATES),
-  received_at: iso3
-});
-var edgeVerificationResponseSchema = z18.object({
-  checks: z18.array(readbackCheckSchema).max(8)
-});
-var readbackResponseSchema = z18.object({
-  v: z18.literal(1),
-  verification_id: verificationIdSchema,
-  node: z18.enum(["connected", "offline"]),
-  checks: z18.array(readbackCheckSchema).max(8)
-});
-var ENVIRONMENT_RE = /^[^\u0000-\u001f]{1,64}$/;
-var projectRuntimeSchema = z18.object({
-  project_id: projectId3,
-  environment: z18.string().max(64),
-  surface: z18.enum(SURFACES),
-  sdk_name: z18.string().max(80),
-  sdk_version: z18.string().max(40),
-  latest_release: z18.string().max(200),
-  first_seen: iso3,
-  last_seen: iso3,
-  events_24h: z18.number().int().nonnegative(),
-  check_ins_24h: z18.number().int().nonnegative()
+var ingestKeyRowSchema = z23.object({
+  id: z23.guid(),
+  project_id: z23.number().int().positive(),
+  name: z23.string(),
+  prefix: z23.string(),
+  scopes: z23.array(z23.enum(INGEST_KEY_SCOPES)),
+  environments: z23.array(z23.string()),
+  expires_at: z23.string().nullable(),
+  state: z23.enum(INGEST_KEY_STATES),
+  created_by: z23.guid().nullable(),
+  created_at: z23.string(),
+  revoked_at: z23.string().nullable(),
+  last_used_at: z23.string().nullable()
 });
 
 // ../src/shared/contracts/node-config.ts
-import { z as z20 } from "zod";
+import { z as z25 } from "zod";
 
 // ../src/shared/contracts/backup.ts
-import { z as z19 } from "zod";
+import { z as z24 } from "zod";
 var BACKUP_KINDS = ["daily", "weekly", "manual", "pre_upgrade"];
-var ageRecipient = z19.string().regex(/^age1[02-9ac-hj-np-z]{58}$/);
-var backupIdSchema = z19.string().regex(/^[a-z0-9-]{8,64}$/);
-var nodeBackupConfigSchema = z19.object({
-  enabled: z19.boolean(),
-  hour_utc: z19.number().int().min(0).max(23),
-  weekly_day: z19.number().int().min(1).max(7),
+var ageRecipient = z24.string().regex(/^age1[02-9ac-hj-np-z]{58}$/);
+var backupIdSchema = z24.string().regex(/^[a-z0-9-]{8,64}$/);
+var nodeBackupConfigSchema = z24.object({
+  enabled: z24.boolean(),
+  hour_utc: z24.number().int().min(0).max(23),
+  weekly_day: z24.number().int().min(1).max(7),
   workspace_recipient: ageRecipient
 });
-var backupCredentialsRequestSchema = z19.object({
-  mode: z19.enum(["upload", "download"]),
+var backupCredentialsRequestSchema = z24.object({
+  mode: z24.enum(["upload", "download"]),
   backup_id: backupIdSchema,
-  source_node_id: z19.guid().optional()
+  source_node_id: z24.guid().optional()
 });
-var backupCredentialsSchema = z19.object({
-  endpoint: z19.string().url(),
-  bucket: z19.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/),
-  prefix: z19.string().regex(/^backups\/[0-9a-f-]{36}\/$/),
-  access_key_id: z19.string().min(8).max(200),
-  secret_access_key: z19.string().min(8).max(200),
-  session_token: z19.string().min(8).max(4000),
-  expires_at: z19.string().datetime()
+var backupCredentialsSchema = z24.object({
+  endpoint: z24.string().url(),
+  bucket: z24.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/),
+  prefix: z24.string().regex(/^backups\/[0-9a-f-]{36}\/$/),
+  access_key_id: z24.string().min(8).max(200),
+  secret_access_key: z24.string().min(8).max(200),
+  session_token: z24.string().min(8).max(4000),
+  expires_at: z24.string().datetime()
 });
-var rowCountsSchema = z19.record(z19.string().regex(/^[a-z_][a-z0-9_]{0,63}$/), z19.number().int().nonnegative());
-var backupManifestSchema = z19.object({
-  v: z19.literal(1),
+var rowCountsSchema = z24.record(z24.string().regex(/^[a-z_][a-z0-9_]{0,63}$/), z24.number().int().nonnegative());
+var backupManifestSchema = z24.object({
+  v: z24.literal(1),
   backup_id: backupIdSchema,
-  node_id: z19.guid(),
-  kind: z19.enum(BACKUP_KINDS),
-  created_at: z19.string().datetime(),
-  object_key: z19.string(),
-  size_bytes: z19.number().int().nonnegative(),
-  sha256: z19.string().regex(/^[0-9a-f]{64}$/),
-  clickhouse_version: z19.string().max(40),
-  schema_version: z19.number().int().nonnegative(),
+  node_id: z24.guid(),
+  kind: z24.enum(BACKUP_KINDS),
+  created_at: z24.string().datetime(),
+  object_key: z24.string(),
+  size_bytes: z24.number().int().nonnegative(),
+  sha256: z24.string().regex(/^[0-9a-f]{64}$/),
+  clickhouse_version: z24.string().max(40),
+  schema_version: z24.number().int().nonnegative(),
   row_counts: rowCountsSchema,
-  recipients: z19.array(z19.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
+  recipients: z24.array(z24.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
 });
 var BACKUP_ERROR_CODES = [
   "CLICKHOUSE_BACKUP_FAILED",
@@ -3196,48 +3748,48 @@ var BACKUP_ERROR_CODES = [
   "RESTORE_FAILED",
   "ROW_COUNT_MISMATCH"
 ];
-var backupReportSchema = z19.object({
+var backupReportSchema = z24.object({
   backup_id: backupIdSchema,
-  kind: z19.enum(BACKUP_KINDS),
-  status: z19.enum(["succeeded", "failed"]),
-  started_at: z19.string().datetime(),
-  finished_at: z19.string().datetime(),
+  kind: z24.enum(BACKUP_KINDS),
+  status: z24.enum(["succeeded", "failed"]),
+  started_at: z24.string().datetime(),
+  finished_at: z24.string().datetime(),
   manifest: backupManifestSchema.nullable(),
-  error_code: z19.enum(BACKUP_ERROR_CODES).nullable()
+  error_code: z24.enum(BACKUP_ERROR_CODES).nullable()
 });
-var drillReportSchema = z19.object({
+var drillReportSchema = z24.object({
   backup_id: backupIdSchema,
-  kind: z19.enum(["weekly_local", "monthly_new_machine"]),
-  status: z19.enum(["passed", "failed"]),
-  finished_at: z19.string().datetime(),
-  detail: z19.string().max(300),
-  error_code: z19.enum(BACKUP_ERROR_CODES).nullable()
+  kind: z24.enum(["weekly_local", "monthly_new_machine"]),
+  status: z24.enum(["passed", "failed"]),
+  finished_at: z24.string().datetime(),
+  detail: z24.string().max(300),
+  error_code: z24.enum(BACKUP_ERROR_CODES).nullable()
 });
-var nodeIdentityEscrowSchema = z19.object({
-  v: z19.literal(1),
-  node_id: z19.guid(),
-  seal: z19.object({
-    publicKey: z19.string().regex(/^[A-Za-z0-9_-]{43}$/),
-    privateKey: z19.string().regex(/^[A-Za-z0-9_-]{43}$/)
-  }),
-  created_at: z19.string().datetime()
+var nodeIdentityEscrowSchema = z24.object({
+  v: z24.literal(1),
+  node_id: z24.guid(),
+  seal: z24.object({
+    publicKey: z24.string().regex(/^[A-Za-z0-9_-]{43}$/),
+    privateKey: z24.string().regex(/^[A-Za-z0-9_-]{43}$/)
+  }),
+  created_at: z24.string().datetime()
 });
-var restoreArgsSchema = z19.object({
-  job_id: z19.guid(),
-  workspace_id: z19.guid(),
-  source_node_id: z19.guid(),
+var restoreArgsSchema = z24.object({
+  job_id: z24.guid(),
+  workspace_id: z24.guid(),
+  source_node_id: z24.guid(),
   manifest: backupManifestSchema,
-  sealed_identity: z19.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
-  mode: z19.enum(["rebuild", "drill"])
+  sealed_identity: z24.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
+  mode: z24.enum(["rebuild", "drill"])
 });
-var restoreReportSchema = z19.object({
-  job_id: z19.guid(),
+var restoreReportSchema = z24.object({
+  job_id: z24.guid(),
   backup_id: backupIdSchema,
-  mode: z19.enum(["rebuild", "drill"]),
-  status: z19.enum(["succeeded", "failed"]),
-  finished_at: z19.string().datetime(),
-  detail: z19.string().max(300),
-  error_code: z19.enum(BACKUP_ERROR_CODES).nullable()
+  mode: z24.enum(["rebuild", "drill"]),
+  status: z24.enum(["succeeded", "failed"]),
+  finished_at: z24.string().datetime(),
+  detail: z24.string().max(300),
+  error_code: z24.enum(BACKUP_ERROR_CODES).nullable()
 });
 
 // ../src/shared/contracts/node-config.ts
@@ -3251,83 +3803,85 @@ var SCRUB_GROUPS = [
   "headers"
 ];
 var MAX_NODE_MONITORS = 5000;
-var kid = z20.string().regex(/^[A-Za-z0-9_-]{1,40}$/);
-var publicKey = z20.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var nodeConfigSchema = z20.object({
-  v: z20.literal(1),
-  config_version: z20.number().int().positive(),
-  node_id: z20.guid(),
-  workspace_id: z20.guid(),
-  workspace_status: z20.enum(["active", "suspended"]),
-  issued_at: z20.string().datetime(),
-  retention_days: z20.number().int().min(1).max(3650),
-  channel: z20.enum(["stable", "canary"]).optional(),
-  projects: z20.array(z20.object({
-    project_id: z20.number().int().positive(),
-    slug: z20.string().max(64),
-    short_prefix: z20.string().regex(/^[A-Z0-9]{1,12}$/),
-    user_id_salt: z20.string().regex(/^[A-Za-z0-9_-]{22,64}$/),
-    scrub_disabled: z20.array(z20.enum(SCRUB_GROUPS)).max(SCRUB_GROUPS.length),
-    upload_tokens: z20.array(z20.object({
-      hash: z20.string().regex(/^[a-f0-9]{64}$/),
-      expires_at: z20.string().datetime()
+var kid = z25.string().regex(/^[A-Za-z0-9_-]{1,40}$/);
+var publicKey = z25.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var nodeConfigSchema = z25.object({
+  v: z25.literal(1),
+  config_version: z25.number().int().positive(),
+  node_id: z25.guid(),
+  workspace_id: z25.guid(),
+  workspace_status: z25.enum(["active", "suspended"]),
+  issued_at: z25.string().datetime(),
+  retention_days: z25.number().int().min(1).max(3650),
+  channel: z25.enum(["stable", "canary"]).optional(),
+  projects: z25.array(z25.object({
+    project_id: z25.number().int().positive(),
+    slug: z25.string().max(64),
+    short_prefix: z25.string().regex(/^[A-Z0-9]{1,12}$/),
+    user_id_salt: z25.string().regex(/^[A-Za-z0-9_-]{22,64}$/),
+    scrub_disabled: z25.array(z25.enum(SCRUB_GROUPS)).max(SCRUB_GROUPS.length),
+    upload_tokens: z25.array(z25.object({
+      hash: z25.string().regex(/^[a-f0-9]{64}$/),
+      expires_at: z25.string().datetime()
     })).max(10).optional()
   })).max(1000),
-  ticket_keys: z20.array(z20.object({ kid, public_key: publicKey, not_after: z20.string().datetime() })).min(1).max(5),
-  control_ops_keys: z20.array(z20.object({ kid, public_key: publicKey })).min(1).max(5),
-  kill_switches: z20.object({ ingest: z20.boolean(), alerts: z20.boolean() }),
+  ticket_keys: z25.array(z25.object({ kid, public_key: publicKey, not_after: z25.string().datetime() })).min(1).max(5),
+  control_ops_keys: z25.array(z25.object({ kid, public_key: publicKey })).min(1).max(5),
+  kill_switches: z25.object({ ingest: z25.boolean(), alerts: z25.boolean() }),
   backup: nodeBackupConfigSchema.optional(),
-  purged_projects: z20.array(z20.number().int().positive()).max(1000).optional(),
-  monitors: z20.array(monitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
-  purged_monitors: z20.array(z20.guid()).max(5000).optional(),
-  telemetry: z20.object({
-    traces_retention_days: z20.number().int().min(1).max(90),
-    logs_retention_days: z20.number().int().min(1).max(90),
-    traces_disk_share: z20.number().min(0.2).max(0.8)
+  purged_projects: z25.array(z25.number().int().positive()).max(1000).optional(),
+  monitors: z25.array(monitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  purged_monitors: z25.array(z25.guid()).max(5000).optional(),
+  telemetry: z25.object({
+    traces_retention_days: z25.number().int().min(1).max(90),
+    logs_retention_days: z25.number().int().min(1).max(90),
+    traces_disk_share: z25.number().min(0.2).max(0.8)
   }).optional(),
-  slos: z20.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
-  signal_monitors: z20.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
-  signal_limits: signalLimitsConfigSchema.optional()
+  metrics: metricsConfigSchema.optional(),
+  slos: z25.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
+  signal_monitors: z25.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  signal_limits: signalLimitsConfigSchema.optional(),
+  privacy: nodePrivacyBlockSchema.optional()
 });
-var signedNodeConfigSchema = z20.object({ config: nodeConfigSchema, kid, sig: z20.string() });
+var signedNodeConfigSchema = z25.object({ config: nodeConfigSchema, kid, sig: z25.string() });
 
 // ../src/shared/contracts/api-ops/projects.ts
-var slug = z21.string().regex(/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/);
-var name3 = z21.string().trim().min(1).max(60);
-var label = z21.string().trim().min(1).max(40);
-var platform = z21.enum(PLATFORMS);
-var origin = z21.string().trim().toLowerCase().regex(/^https?:\/\/[a-z0-9.-]+(:[0-9]{1,5})?$/).max(200);
-var keyId = z21.number().int().positive();
+var slug = z26.string().regex(/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/);
+var name3 = z26.string().trim().min(1).max(60);
+var label2 = z26.string().trim().min(1).max(40);
+var platform = z26.enum(PLATFORMS);
+var origin = z26.string().trim().toLowerCase().regex(/^https?:\/\/[a-z0-9.-]+(:[0-9]{1,5})?$/).max(200);
+var keyId = z26.number().int().positive();
 var PROJECT_INPUTS = {
-  create: z21.object({ workspaceId: uuid, name: name3, slug, platform }),
-  update: z21.object({ projectId, name: name3, platform, isPinned: z21.boolean() }),
-  updateIntake: z21.object({
+  create: z26.object({ workspaceId: uuid, name: name3, slug, platform }),
+  update: z26.object({ projectId, name: name3, platform, isPinned: z26.boolean() }),
+  updateIntake: z26.object({
     projectId,
-    rateLimit: z21.number().int().positive().nullable(),
-    burst: z21.number().int().positive().nullable(),
-    allowedOrigins: z21.array(origin).max(50)
+    rateLimit: z26.number().int().positive().nullable(),
+    burst: z26.number().int().positive().nullable(),
+    allowedOrigins: z26.array(origin).max(50)
   }),
-  updateObservability: z21.object({
+  updateObservability: z26.object({
     projectId,
-    primaryEnvironment: z21.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
-    allowCodeMonitors: z21.boolean()
+    primaryEnvironment: z26.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
+    allowCodeMonitors: z26.boolean()
   }),
-  setScrub: z21.object({ projectId, group: z21.enum(SCRUB_GROUPS), enabled: z21.boolean() }),
-  setCheckinAuth: z21.object({ projectId, mode: z21.enum(CHECKIN_AUTH_MODES) }),
-  setEnvironmentHidden: z21.object({
+  setScrub: z26.object({ projectId, group: z26.enum(SCRUB_GROUPS), enabled: z26.boolean() }),
+  setCheckinAuth: z26.object({ projectId, mode: z26.enum(CHECKIN_AUTH_MODES) }),
+  setEnvironmentHidden: z26.object({
     projectId,
-    name: z21.string().min(1).max(64),
-    hidden: z21.boolean()
-  }),
-  scheduleDeletion: z21.object({ projectId, confirmSlug: slug }),
-  projectOnly: z21.object({ projectId }),
-  labelled: z21.object({ projectId, label }),
-  keyOnly: z21.object({ keyId }),
-  tokenOnly: z21.object({ tokenId: keyId }),
+    name: z26.string().min(1).max(64),
+    hidden: z26.boolean()
+  }),
+  scheduleDeletion: z26.object({ projectId, confirmSlug: slug }),
+  projectOnly: z26.object({ projectId }),
+  labelled: z26.object({ projectId, label: label2 }),
+  keyOnly: z26.object({ keyId }),
+  tokenOnly: z26.object({ tokenId: keyId }),
   createIngestKey: createIngestKeyInputSchema,
-  ingestKeyOnly: z21.object({ keyId: uuid })
+  ingestKeyOnly: z26.object({ keyId: uuid })
 };
-var P = PROJECT_INPUTS;
+var P2 = PROJECT_INPUTS;
 var PROJECT_OPERATIONS = [
   op({
     id: "projects.create",
@@ -3337,7 +3891,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["create_project"],
-    input: P.create,
+    input: P2.create,
     workspace: true,
     idempotency: "required",
     status: 201,
@@ -3353,7 +3907,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["update_project"],
-    input: P.update,
+    input: P2.update,
     ifMatch: true,
     idempotency: "none",
     mcp: "configure",
@@ -3368,7 +3922,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["update_project_intake"],
-    input: P.updateIntake,
+    input: P2.updateIntake,
     ifMatch: true,
     idempotency: "none",
     mcp: "configure",
@@ -3383,7 +3937,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["update_project_observability"],
-    input: P.updateObservability,
+    input: P2.updateObservability,
     ifMatch: true,
     idempotency: "none",
     mcp: "configure",
@@ -3395,10 +3949,10 @@ var PROJECT_OPERATIONS = [
     method: "PUT",
     path: "/v1/projects/{project_id}/scrub/{group}",
     scope: "privacy:write",
-    sensitivity: "normal",
+    sensitivity: "approval",
     kind: "write",
     rpcs: ["set_project_scrub"],
-    input: P.setScrub,
+    input: P2.setScrub,
     idempotency: "none",
     mcp: "configure",
     summary: "Turn one built-in scrubbing group on or off.",
@@ -3412,7 +3966,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["set_project_checkin_auth"],
-    input: P.setCheckinAuth,
+    input: P2.setCheckinAuth,
     idempotency: "none",
     mcp: "configure",
     summary: "Choose which credentials may send check-ins.",
@@ -3426,7 +3980,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["set_environment_hidden"],
-    input: P.setEnvironmentHidden,
+    input: P2.setEnvironmentHidden,
     idempotency: "none",
     mcp: "configure",
     summary: "Hide or show an environment in lists.",
@@ -3440,7 +3994,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["schedule_project_deletion"],
-    input: P.scheduleDeletion,
+    input: P2.scheduleDeletion,
     idempotency: "none",
     mcp: "configure",
     summary: "Schedule the project's deletion; `confirm_slug` must repeat its slug.",
@@ -3454,7 +4008,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["cancel_project_deletion"],
-    input: P.projectOnly,
+    input: P2.projectOnly,
     idempotency: "optional",
     mcp: "configure",
     summary: "Cancel a scheduled project deletion.",
@@ -3468,7 +4022,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "normal",
     kind: "write",
     rpcs: ["request_test_event"],
-    input: P.projectOnly,
+    input: P2.projectOnly,
     idempotency: "optional",
     mcp: "reliability",
     summary: "Ask the node to send one test event through the public intake.",
@@ -3482,7 +4036,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["create_project_key"],
-    input: P.labelled,
+    input: P2.labelled,
     idempotency: "required",
     status: 201,
     mcp: "configure",
@@ -3497,7 +4051,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["rotate_project_key"],
-    input: P.keyOnly,
+    input: P2.keyOnly,
     idempotency: "optional",
     mcp: "configure",
     summary: "Replace a DSN key.",
@@ -3511,7 +4065,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["revoke_project_key"],
-    input: P.keyOnly,
+    input: P2.keyOnly,
     idempotency: "none",
     mcp: "configure",
     summary: "Revoke a DSN key.",
@@ -3525,7 +4079,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["create_upload_token"],
-    input: P.labelled,
+    input: P2.labelled,
     idempotency: "required",
     status: 201,
     mcp: "configure",
@@ -3541,7 +4095,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["revoke_upload_token"],
-    input: P.tokenOnly,
+    input: P2.tokenOnly,
     idempotency: "none",
     mcp: "configure",
     summary: "Revoke a source map upload token.",
@@ -3555,7 +4109,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["create_ingest_key"],
-    input: P.createIngestKey,
+    input: P2.createIngestKey,
     idempotency: "required",
     status: 201,
     mcp: "configure",
@@ -3571,7 +4125,7 @@ var PROJECT_OPERATIONS = [
     sensitivity: "approval",
     kind: "write",
     rpcs: ["revoke_ingest_key"],
-    input: P.ingestKeyOnly,
+    input: P2.ingestKeyOnly,
     idempotency: "none",
     mcp: "configure",
     summary: "Revoke an OTLP ingest key.",
@@ -3580,24 +4134,24 @@ var PROJECT_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/reads.ts
-import { z as z22 } from "zod";
-var list = z22.object({ workspaceId: uuid, limit: pageLimit, cursor });
+import { z as z27 } from "zod";
+var list = z27.object({ workspaceId: uuid, limit: pageLimit, cursor });
 var READ_INPUTS = {
-  workspace: z22.object({ workspaceId: uuid }),
+  workspace: z27.object({ workspaceId: uuid }),
   list,
-  projectsGet: z22.object({ workspaceId: uuid, projectId }),
+  projectsGet: z27.object({ workspaceId: uuid, projectId }),
   monitorsList: list.extend({ projectId: projectId.optional() }),
-  monitorsGet: z22.object({ workspaceId: uuid, monitorId: uuid }),
-  uptimeGet: z22.object({ workspaceId: uuid, checkId: uuid }),
-  slosGet: z22.object({ workspaceId: uuid, sloId: uuid }),
+  monitorsGet: z27.object({ workspaceId: uuid, monitorId: uuid }),
+  uptimeGet: z27.object({ workspaceId: uuid, checkId: uuid }),
+  slosGet: z27.object({ workspaceId: uuid, sloId: uuid }),
   alertsList: list.extend({
-    state: z22.enum(["open", "resolved", "all"]).default("all"),
+    state: z27.enum(["open", "resolved", "all"]).default("all"),
     monitorId: uuid.optional()
   }),
-  approvalsGet: z22.object({ workspaceId: uuid, approvalId: uuid }),
+  approvalsGet: z27.object({ workspaceId: uuid, approvalId: uuid }),
   monitorsListTyped: list.extend({
     projectId: projectId.optional(),
-    type: z22.enum(MONITOR_TYPES).optional()
+    type: z27.enum(MONITOR_TYPES).optional()
   })
 };
 var R = READ_INPUTS;
@@ -3809,6 +4363,8 @@ var API_OPERATIONS = [
   ...MONITOR_OPERATIONS,
   ...ALERT_OPERATIONS,
   ...INCIDENT_OPERATIONS,
+  ...COVERAGE_OPERATIONS,
+  ...PRIVACY_OPERATIONS,
   ...ACCESS_OPERATIONS,
   ...NODE_OPERATIONS
 ];
@@ -3833,6 +4389,8 @@ var APPROVAL_LIMITS = {
 var APPROVAL_APPROVER = {
   "projects.set_checkin_auth": "admin",
   "projects.schedule_deletion": "admin",
+  "projects.set_scrub": "admin",
+  "privacy.set": "admin",
   "project_keys.create": "member",
   "project_keys.rotate": "member",
   "project_keys.revoke": "member",
@@ -3877,14 +4435,14 @@ function approvalRequestSchema(operationId, input) {
 }
 
 // ../src/shared/contracts/api-ops/wire.ts
-import { z as z23 } from "zod";
+import { z as z28 } from "zod";
 var toSnake = (s) => s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 var toCamel = (s) => s.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
 var schemaCache = new WeakMap;
 function inputJsonSchema(op) {
   let js = schemaCache.get(op.input);
   if (!js) {
-    js = z23.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
+    js = z28.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
     schemaCache.set(op.input, js);
   }
   return js;
@@ -4098,7 +4656,7 @@ function wireInput(operationId, opts = {}) {
   for (const [k, v] of Object.entries(op.input.shape))
     if (!omit.has(k))
       shape[toSnake(k)] = v;
-  return z24.object(shape);
+  return z29.object(shape);
 }
 var BUDGETS = [
   { stringBytes: MCP_LIMITS.untrustedStringMaxBytes, listMax: MCP_LIMITS.listMax },
@@ -4188,40 +4746,40 @@ function errorResult(o) {
     }
   };
 }
-var TOOL_OUTPUT_SCHEMA = z24.object({
-  untrusted: z24.object({
-    data: z24.unknown(),
-    provenance: z24.object({
-      source: z24.enum(["node", "control_plane", "docs"]),
-      operations: z24.array(z24.string())
+var TOOL_OUTPUT_SCHEMA = z29.object({
+  untrusted: z29.object({
+    data: z29.unknown(),
+    provenance: z29.object({
+      source: z29.enum(["node", "control_plane", "docs"]),
+      operations: z29.array(z29.string())
     })
   }).optional(),
-  doc: z24.object({ slug: z24.string(), locale: z24.enum(["en", "vi"]), url: z24.string(), markdown: z24.string(), truncated: z24.boolean() }).optional(),
-  results: z24.array(z24.object({ slug: z24.string(), title: z24.string(), description: z24.string(), section: z24.string(), url: z24.string() })).optional(),
-  next_cursor: z24.string().nullable().optional(),
-  complete: z24.boolean().optional(),
-  omitted: z24.array(z24.object({ part: z24.string(), reason: z24.string(), scope: z24.string().optional() })).optional(),
-  truncated: z24.literal(true).optional(),
-  suspicious_unicode: z24.literal(true).optional(),
-  error: z24.object({
-    code: z24.string(),
-    status: z24.number(),
-    detail: z24.string().optional(),
-    scope: z24.string().optional(),
-    retry_after: z24.number().optional()
+  doc: z29.object({ slug: z29.string(), locale: z29.enum(["en", "vi"]), url: z29.string(), markdown: z29.string(), truncated: z29.boolean() }).optional(),
+  results: z29.array(z29.object({ slug: z29.string(), title: z29.string(), description: z29.string(), section: z29.string(), url: z29.string() })).optional(),
+  next_cursor: z29.string().nullable().optional(),
+  complete: z29.boolean().optional(),
+  omitted: z29.array(z29.object({ part: z29.string(), reason: z29.string(), scope: z29.string().optional() })).optional(),
+  truncated: z29.literal(true).optional(),
+  suspicious_unicode: z29.literal(true).optional(),
+  error: z29.object({
+    code: z29.string(),
+    status: z29.number(),
+    detail: z29.string().optional(),
+    scope: z29.string().optional(),
+    retry_after: z29.number().optional()
   }).optional(),
-  operations: z24.array(z24.record(z24.string(), z24.unknown())).optional(),
-  operation: z24.record(z24.string(), z24.unknown()).optional(),
-  plan: z24.record(z24.string(), z24.unknown()).optional(),
-  status: z24.enum(["done", "approval_required", "approval_pending", ...APPROVAL_STATES]).optional(),
-  approval: z24.object({
-    approval_id: z24.string(),
-    approval_url: z24.string(),
-    expires_at: z24.string(),
-    state: z24.enum(APPROVAL_STATES),
-    result_code: z24.string().nullable().optional(),
-    result: z24.record(z24.string(), z24.unknown()).optional(),
-    next: z24.string().optional()
+  operations: z29.array(z29.record(z29.string(), z29.unknown())).optional(),
+  operation: z29.record(z29.string(), z29.unknown()).optional(),
+  plan: z29.record(z29.string(), z29.unknown()).optional(),
+  status: z29.enum(["done", "approval_required", "approval_pending", ...APPROVAL_STATES]).optional(),
+  approval: z29.object({
+    approval_id: z29.string(),
+    approval_url: z29.string(),
+    expires_at: z29.string(),
+    state: z29.enum(APPROVAL_STATES),
+    result_code: z29.string().nullable().optional(),
+    result: z29.record(z29.string(), z29.unknown()).optional(),
+    next: z29.string().optional()
   }).optional()
 });
 var spec = (name) => {
@@ -4267,10 +4825,10 @@ var has = (rt, operationId) => {
   return !!op && rt.scopes.includes(op.scope);
 };
 var isoWindow = {
-  start: z24.string().max(40).describe("RFC 3339 start of the window, e.g. 2026-10-26T00:00:00Z. Required with end."),
-  end: z24.string().max(40).describe("RFC 3339 end of the window. The plan limits its length.")
+  start: z29.string().max(40).describe("RFC 3339 start of the window, e.g. 2026-10-26T00:00:00Z. Required with end."),
+  end: z29.string().max(40).describe("RFC 3339 end of the window. The plan limits its length.")
 };
-var traceIdSchema = z24.string().regex(/^[0-9a-fA-F]{32}$/);
+var traceIdSchema = z29.string().regex(/^[0-9a-fA-F]{32}$/);
 var MONITOR_KINDS2 = {
   cron: { list: "monitors.list", get: "monitors.get", idField: "monitor_id" },
   uptime: { list: "uptime.list", get: "uptime.get", idField: "check_id" },
@@ -4334,8 +4892,8 @@ function describe(op, scopes) {
     destructive: isDestructiveOperation(op)
   };
 }
-var params = z24.record(z24.string(), z24.unknown()).default({}).describe("Operation fields in wire names (snake_case), as describe_operation's args_schema shows.");
-var operationIdArg = z24.string().min(3).max(80).describe("An operation id from search_operations, e.g. `monitors.update`.");
+var params = z29.record(z29.string(), z29.unknown()).default({}).describe("Operation fields in wire names (snake_case), as describe_operation's args_schema shows.");
+var operationIdArg = z29.string().min(3).max(80).describe("An operation id from search_operations, e.g. `monitors.update`.");
 function approvalBlock(t, next) {
   return {
     approval_id: t.approval_id,
@@ -4355,7 +4913,7 @@ var MCP_TOOL_DEFS = [
     title: "Workspace and node",
     description: "The workspace this token belongs to (name, plan, limits) and the state of its node, the server that stores errors, traces and logs. Start here to learn what the token can reach.",
     operations: ["workspace.get", "node.get"],
-    input: z24.object({}),
+    input: z29.object({}),
     async run(_args, rt) {
       const [ws, node] = await Promise.all([rt.call("workspace.get", {}), rt.call("node.get", {})]);
       if (!ws.ok)
@@ -4373,9 +4931,9 @@ var MCP_TOOL_DEFS = [
     title: "Get an issue",
     description: "One issue with its 24 h and 30 d counts and, when the token can read events, its latest event (stack trace, request, breadcrumbs — scrubbed on the node).",
     operations: ["issues.get", "events.get"],
-    input: z24.object({
-      issue_id: z24.number().int().positive().describe("Issue id from search_issues."),
-      include_latest_event: z24.boolean().default(true)
+    input: z29.object({
+      issue_id: z29.number().int().positive().describe("Issue id from search_issues."),
+      include_latest_event: z29.boolean().default(true)
     }),
     async run(args, rt) {
       const omitted = [];
@@ -4403,9 +4961,9 @@ var MCP_TOOL_DEFS = [
     title: "Get a trace",
     description: "Summary of one distributed trace (services, duration, errors) by its 32-hex trace id, and optionally its spans (errors only, or the first page).",
     operations: ["traces.get", "traces.spans"],
-    input: z24.object({
+    input: z29.object({
       trace_id: traceIdSchema.describe("W3C trace id, 32 hex characters."),
-      spans: z24.enum(["none", "errors", "all"]).default("none")
+      spans: z29.enum(["none", "errors", "all"]).default("none")
     }),
     async run(args, rt) {
       const sum = await rt.call("traces.get", { trace_id: args["trace_id"] });
@@ -4428,16 +4986,70 @@ var MCP_TOOL_DEFS = [
   },
   single("search_spans", "spans.list", "Search spans", "OpenTelemetry spans in a time window (start and end required): filter by project, environment, service, operation, status, kind, duration or attribute filters (`attrs`, JSON list of {k, op, v}). mode=traces returns one row per trace."),
   single("query_logs", "logs.list", "Query logs", "OpenTelemetry logs in a time window (start and end required): filter by project, environment, service, minimum severity, trace or span id, text `q` or attribute filters. Newest first unless order=asc."),
+  {
+    ...spec("query_metrics"),
+    title: "Query metrics",
+    description: "OpenTelemetry metrics of one project. Without `name`: the metric catalog (name, type, unit, series count, last seen; `q` narrows by name) and the node's series caps. With `name` plus start and end: the metric aggregated per step — `aggregation` defaults to rate for counters, p95 for histograms and avg for gauges — optionally filtered by attributes (`attrs`, JSON list of {k, op, v}) and grouped by up to two attribute keys (`group_by`, comma-separated). Exemplar trace ids open with get_trace.",
+    operations: ["metrics.names", "metrics.query"],
+    input: z29.object({
+      project: z29.number().int().positive().describe("Numeric project id from list_projects."),
+      name: z29.string().regex(METRIC_NAME_RE).optional().describe("Metric name from the catalog, e.g. http.server.request.duration."),
+      q: z29.string().max(255).optional().describe("Catalog only: part of a metric name."),
+      aggregation: z29.enum(METRIC_AGGREGATIONS).optional(),
+      start: isoWindow.start.optional(),
+      end: isoWindow.end.optional(),
+      step: z29.number().int().min(60).max(86400).multipleOf(60).optional().describe("Seconds per point (whole minutes); picked from the window when absent."),
+      attrs: z29.string().max(2000).optional(),
+      group_by: z29.string().max(600).optional(),
+      environment: z29.string().max(2000).optional().describe("Comma-separated environments.")
+    }),
+    async run(args, rt) {
+      const scope = { project: args["project"], ...args["environment"] ? { environment: args["environment"] } : {} };
+      const name = args["name"];
+      if (!name) {
+        const r = await rt.call("metrics.names", { ...scope, ...args["q"] ? { q: args["q"] } : {} });
+        if (!r.ok)
+          return errorResult(r);
+        return wrapResult({ data: r.body, operations: ["metrics.names"], source: "node" }, listExtra(r.body));
+      }
+      const ops = ["metrics.query"];
+      let aggregation = args["aggregation"];
+      if (!aggregation) {
+        ops.unshift("metrics.names");
+        const cat = await rt.call("metrics.names", { ...scope, q: name });
+        if (!cat.ok)
+          return errorResult(cat);
+        const rows = cat.body?.names ?? [];
+        const kind = rows.find((n) => n.name === name)?.kind;
+        if (!METRIC_KINDS.includes(kind))
+          return errorResult({ ok: false, status: 404, code: "NOT_FOUND", detail: "unknown_metric" });
+        aggregation = defaultAggregation(kind);
+      }
+      const r = await rt.call("metrics.query", {
+        ...scope,
+        name,
+        aggregation,
+        start: args["start"],
+        end: args["end"],
+        ...args["step"] ? { step: args["step"] } : {},
+        ...args["attrs"] ? { attrs: args["attrs"] } : {},
+        ...args["group_by"] ? { group_by: args["group_by"] } : {}
+      });
+      if (!r.ok)
+        return errorResult(r);
+      return wrapResult({ data: r.body, operations: ops, source: "node" }, listExtra(r.body));
+    }
+  },
   {
     ...spec("correlate"),
     title: "Correlate by trace or run",
     description: "Everything that shares one W3C trace id or one Belvador run id (`belvador.run.id`, set by job monitors) in a time window: the trace summary, its error spans and the logs. Give exactly one of trace_id or run_id.",
     operations: ["traces.get", "traces.spans", "spans.list", "logs.list"],
-    input: z24.object({
+    input: z29.object({
       trace_id: traceIdSchema.optional(),
-      run_id: z24.string().min(1).max(128).optional(),
+      run_id: z29.string().min(1).max(128).optional(),
       ...isoWindow,
-      project: z24.string().max(2000).optional().describe("Comma-separated project ids.")
+      project: z29.string().max(2000).optional().describe("Comma-separated project ids.")
     }),
     async run(args, rt) {
       const trace = args["trace_id"];
@@ -4482,10 +5094,10 @@ var MCP_TOOL_DEFS = [
     title: "List monitors",
     description: "Monitors (cron, heartbeat, count, assertion, deadline, progress), uptime checks and SLOs with their current status. `kind` narrows to one family; `project_id` to one project (cron and uptime).",
     operations: ["monitors.list", "uptime.list", "slos.list"],
-    input: z24.object({
-      kind: z24.enum(["all", "cron", "uptime", "slo"]).default("all"),
-      project_id: z24.number().int().positive().optional(),
-      limit: z24.number().int().min(1).max(200).default(50)
+    input: z29.object({
+      kind: z29.enum(["all", "cron", "uptime", "slo"]).default("all"),
+      project_id: z29.number().int().positive().optional(),
+      limit: z29.number().int().min(1).max(200).default(50)
     }),
     async run(args, rt) {
       const kinds = args["kind"] && args["kind"] !== "all" ? [args["kind"]] : ["cron", "uptime", "slo"];
@@ -4513,10 +5125,10 @@ var MCP_TOOL_DEFS = [
     title: "Get a monitor",
     description: "One monitor (any type), uptime check or SLO by id: settings, current status and recent results. For count, assertion, deadline and progress monitors it adds the last 24 h of minute counts or runs from the node, and for deadline monitors the newest occurrences. `backtest: true` (count/assertion only) also replays the current settings over the last 30 days: how often it would have alerted.",
     operations: ["monitors.get", "uptime.get", "slos.get", "monitors.signal", "monitors.occurrences", "monitors.backtest"],
-    input: z24.object({
-      kind: z24.enum(["cron", "uptime", "slo"]),
-      id: z24.guid(),
-      backtest: z24.boolean().default(false)
+    input: z29.object({
+      kind: z29.enum(["cron", "uptime", "slo"]),
+      id: z29.guid(),
+      backtest: z29.boolean().default(false)
     }),
     async run(args, rt) {
       const k = MONITOR_KINDS2[args["kind"]];
@@ -4566,14 +5178,15 @@ var MCP_TOOL_DEFS = [
   single("list_alerts", "alerts.list", "List alerts", "Alerts Belvador raised (open, resolved or all), newest first, optionally for one monitor."),
   single("list_incidents", "incidents.list", "List incidents", "Incidents (INC-n): related alerts grouped into one piece of work. State (open, acknowledged, monitoring, resolved), severity and peak, owner, linked and still-firing alert counts; newest first. `state` = active, resolved or all. Returns ids for get_incident."),
   single("get_incident", "incidents.get", "Get an incident", "One incident by id: its linked alerts (monitor, uptime, SLO, issue) with ids for get_monitor_status or get_issue, the timeline (opened, joined, acknowledged, notes, escalation, resolution) and each message's delivery state. `accepted` means the service took the message; only `acknowledged: true` means a person took the incident."),
+  single("get_coverage", "coverage.get", "Get coverage", "What each app is expected to send (part of the app × signal × environment) against what Belvador really received: `verified` (fresh evidence or verification receipt), `stale`, `problem` (open connection problem) or `unknown` (never seen). Same numbers as the Coverage page. `undeclared` lists signals seen without an expectation; they do not count. Optional `project_id` and `environment` narrow it."),
   {
     ...spec("verify_integration"),
     title: "Send a test event",
     description: "Asks the node to send one tagged test error through the public intake of a project, proving the path real errors take. Not read-only: it creates one test event (reuse idempotency_key to retry without a second one).",
     operations: ["projects.send_test_event"],
-    input: z24.object({
-      project_id: z24.number().int().positive(),
-      idempotency_key: z24.string().min(8).max(255).optional()
+    input: z29.object({
+      project_id: z29.number().int().positive(),
+      idempotency_key: z29.string().min(8).max(255).optional()
     }),
     async run(args, rt) {
       const r = await rt.call("projects.send_test_event", { project_id: args["project_id"] }, { idempotencyKey: args["idempotency_key"] ?? rt.newKey() });
@@ -4587,9 +5200,9 @@ var MCP_TOOL_DEFS = [
     title: "Find a configuration change",
     description: "Searches what this token can change in its Belvador workspace: projects, keys and tokens, monitors of every type, maintenance windows, occurrences, uptime checks, SLOs, alert rules and destinations, members, service accounts and the node. Returns operation ids for describe_operation and plan_change, whether a person must approve the change, and whether this token holds the scope.",
     operations: [],
-    input: z24.object({
-      query: z24.string().min(1).max(200).describe("Words such as `rotate dsn key`, `heartbeat monitor`, `slack alert`."),
-      limit: z24.number().int().min(1).max(20).default(10)
+    input: z29.object({
+      query: z29.string().min(1).max(200).describe("Words such as `rotate dsn key`, `heartbeat monitor`, `slack alert`."),
+      limit: z29.number().int().min(1).max(20).default(10)
     }),
     async run(args, rt) {
       const q = words(String(args["query"]));
@@ -4617,7 +5230,7 @@ var MCP_TOOL_DEFS = [
     title: "Describe a configuration change",
     description: "Everything needed to call one operation: its fields (JSON Schema, wire names), the scope, whether it needs If-Match (call plan_change for the current ETag), an idempotency key, or a person's approval, and which fields the approving person types on belvador.dev instead of the agent.",
     operations: [],
-    input: z24.object({ operation_id: operationIdArg }),
+    input: z29.object({ operation_id: operationIdArg }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -4646,7 +5259,7 @@ var MCP_TOOL_DEFS = [
     title: "Check a change before applying it",
     description: "Validates params for one operation without changing anything: field errors, missing scope, whether a person must approve, and — when the resource can be read — its current state, the fields that would change and the ETag to pass as if_match.",
     operations: [],
-    input: z24.object({ operation_id: operationIdArg, params }),
+    input: z29.object({ operation_id: operationIdArg, params }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -4695,11 +5308,11 @@ var MCP_TOOL_DEFS = [
     title: "Apply a configuration change",
     description: "Runs one operation with params (validate first with plan_change). Always send idempotency_key: repeating a call with the same key never applies it twice. Sensitive operations answer approval_required with an approval_url a person opens on belvador.dev; nothing changes until they approve with their authenticator code.",
     operations: [],
-    input: z24.object({
+    input: z29.object({
       operation_id: operationIdArg,
       params,
-      idempotency_key: z24.string().min(8).max(255).describe("Unique per change; reuse it to retry or to fetch the result."),
-      if_match: z24.string().max(200).optional().describe("ETag from plan_change, for operations that need it.")
+      idempotency_key: z29.string().min(8).max(255).describe("Unique per change; reuse it to retry or to fetch the result."),
+      if_match: z29.string().max(200).optional().describe("ETag from plan_change, for operations that need it.")
     }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
@@ -4750,7 +5363,7 @@ var MCP_TOOL_DEFS = [
     title: "Follow an approval",
     description: "State of a change waiting for a person's approval: pending, approved, executed (with the ids it produced), rejected, expired or failed (with the error code).",
     operations: ["approvals.get"],
-    input: z24.object({ approval_id: z24.guid().describe("approval_id from apply_change.") }),
+    input: z29.object({ approval_id: z29.guid().describe("approval_id from apply_change.") }),
     async run(args, rt) {
       const r = await rt.call("approvals.get", { approval_id: args["approval_id"] });
       if (!r.ok)
@@ -4770,10 +5383,10 @@ var MCP_TOOL_DEFS = [
     title: "Search Belvador docs",
     description: "Searches the public Belvador documentation (titles and summaries) and returns the best pages with their slugs for get_doc.",
     operations: [],
-    input: z24.object({
-      query: z24.string().min(1).max(200),
-      locale: z24.enum(["en", "vi"]).default("en"),
-      limit: z24.number().int().min(1).max(10).default(5)
+    input: z29.object({
+      query: z29.string().min(1).max(200),
+      locale: z29.enum(["en", "vi"]).default("en"),
+      limit: z29.number().int().min(1).max(10).default(5)
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -4789,9 +5402,9 @@ var MCP_TOOL_DEFS = [
     title: "Read a docs page",
     description: "The Markdown of one public Belvador docs page by slug (e.g. `quickstart`, `sdk/react`, `reference/api`).",
     operations: [],
-    input: z24.object({
-      slug: z24.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
-      locale: z24.enum(["en", "vi"]).default("en")
+    input: z29.object({
+      slug: z29.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
+      locale: z29.enum(["en", "vi"]).default("en")
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -4973,7 +5586,7 @@ function findToken(env = process.env, keychain = keychainToken) {
 }
 
 // packages/mcp/src/cli.ts
-var PACKAGE_VERSION = "0.3.0";
+var PACKAGE_VERSION = "0.5.0";
 var HELP = `belvador-mcp ${PACKAGE_VERSION} — Belvador MCP server (stdio)
 
 Usage: npx -y @belvador/mcp [--toolsets=${MCP_DEFAULT_TOOLSETS.join(",")}]