@belvador/mcp 0.6.0 → 0.7.1

package/dist/cli.js

@@ -255,7 +255,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 z31 } from "zod";
+import { z as z32 } from "zod";
 
 // ../src/shared/contracts/api-ops/access.ts
 import { z as z3 } from "zod";
@@ -1225,7 +1225,7 @@ var TELEMETRY_PLAN_DEFAULTS = {
   logs_monthly_bytes: 5 * 1000 ** 3,
   metrics_retention_days: 14,
   metrics_monthly_bytes: 2 * 1000 ** 3,
-  metric_series_max: 1e4,
+  metric_series_max: 35000,
   metric_names_max: 1000,
   telemetry_rate_bytes_per_sec: 1024 * 1024,
   telemetry_burst_bytes: 8 * 1024 * 1024,
@@ -1236,7 +1236,7 @@ var TELEMETRY_PLAN_DEFAULTS = {
 // ../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_AGGREGATIONS = ["avg", "sum", "min", "max", "count", "rate", "p50", "p75", "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;
@@ -1288,7 +1288,8 @@ var METRIC_QUERY = {
   exemplarsMax: 50,
   queryMaxSeconds: 3
 };
-var metricName = z10.string().min(1).max(METRIC_LIMITS.nameMaxChars).regex(METRIC_NAME_RE);
+var metricNameSchema = z10.string().min(1).max(METRIC_LIMITS.nameMaxChars).regex(METRIC_NAME_RE);
+var metricName = metricNameSchema;
 var attrKey = z10.string().regex(METRIC_ATTR_KEY_RE);
 var metricFilterSchema = z10.object({
   k: attrKey,
@@ -2340,7 +2341,7 @@ var TOKEN_IN_TEXT = new RegExp(PING_TOKEN_PATTERN, "g");
 import { z as z17 } from "zod";
 
 // ../src/shared/contracts/vocab/slo.ts
-var SLO_SOURCES = ["uptime", "monitor", "heartbeat", "spans"];
+var SLO_SOURCES = ["uptime", "monitor", "heartbeat", "spans", "metric"];
 
 // ../src/shared/contracts/slo.ts
 var SLO_SLIS = ["availability", "latency"];
@@ -2360,6 +2361,8 @@ var SLO_LIMITS = {
   descriptionMaxChars: 1000,
   environmentMaxChars: 64,
   spansLagMinutes: 3,
+  metricsLagMinutes: 3,
+  metricSeenMinutes: 5,
   sliItemsPerMessage: 200,
   maxNodeSlos: 1000
 };
@@ -2367,14 +2370,30 @@ var SLO_SOURCE_META = {
   uptime: { provenance: "managed_probe", estimated: false, slis: ["availability", "latency"], budgeting: "Timeslices" },
   monitor: { provenance: "check_in", estimated: false, slis: ["availability"], budgeting: "Occurrences" },
   heartbeat: { provenance: "ping_token", estimated: false, slis: ["availability"], budgeting: "Occurrences" },
-  spans: { provenance: "ingest_key", estimated: true, slis: ["availability", "latency"], budgeting: "Occurrences" }
+  spans: { provenance: "ingest_key", estimated: true, slis: ["availability", "latency"], budgeting: "Occurrences" },
+  metric: { provenance: "ingest_key", estimated: false, slis: ["availability"], budgeting: "Occurrences" }
 };
+var sloMetricSchema = z17.object({
+  name: metricNameSchema,
+  filter: z17.array(metricFilterSchema).max(METRIC_QUERY.filtersMax).default([])
+}).superRefine((m, ctx) => {
+  m.filter.forEach((f, i) => {
+    if (f.op === "exists" !== (f.v === undefined))
+      ctx.addIssue({ code: "custom", path: ["filter", i, "v"], message: "INVALID_INPUT" });
+  });
+});
+function sameSloMetric(a, b) {
+  const key = (m) => JSON.stringify([m.name, [...m.filter].map((f) => [f.k, f.op, f.v ?? null]).sort()]);
+  return key(a) === key(b);
+}
 var nodeSloSchema = z17.object({
   slo_id: z17.guid(),
   project_id: z17.number().int().positive(),
-  source: z17.enum(["monitor", "spans"]),
+  source: z17.enum(["monitor", "spans", "metric"]),
   sli: z17.enum(SLO_SLIS),
   monitor_id: z17.guid().optional(),
+  good_metric: sloMetricSchema.optional(),
+  total_metric: sloMetricSchema.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(),
@@ -2385,6 +2404,8 @@ var nodeSloSchema = z17.object({
     ctx.addIssue({ code: "custom", path: ["monitor_id"], message: "INVALID_INPUT" });
   if (v.source === "spans" && !v.service)
     ctx.addIssue({ code: "custom", path: ["service"], message: "INVALID_INPUT" });
+  if (v.source === "metric" !== Boolean(v.good_metric && v.total_metric) || v.source === "metric" && v.sli !== "availability")
+    ctx.addIssue({ code: "custom", path: ["good_metric"], message: "INVALID_INPUT" });
   if (v.sli === "latency" !== (v.latency_threshold_ms !== undefined))
     ctx.addIssue({ code: "custom", path: ["latency_threshold_ms"], message: "INVALID_INPUT" });
 });
@@ -2401,7 +2422,9 @@ var sloInputSchema = z17.object({
     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()
+    environment: z17.string().max(SLO_LIMITS.environmentMaxChars).optional(),
+    goodMetric: sloMetricSchema.optional(),
+    totalMetric: sloMetricSchema.optional()
   }),
   sli: z17.enum(SLO_SLIS),
   latencyThresholdMs: z17.number().int().min(1).max(60000).nullable(),
@@ -2414,9 +2437,15 @@ var sloInputSchema = z17.object({
     ctx.addIssue({ code: "custom", path: ["sli"], message: "INVALID_INPUT" });
   if (v.sli === "latency" !== Boolean(v.latencyThresholdMs))
     ctx.addIssue({ code: "custom", path: ["latencyThresholdMs"], message: "INVALID_INPUT" });
-  if (v.source === "spans" ? !(v.sourceRef.projectId && v.sourceRef.service?.trim()) : !v.sourceRef.id)
+  const ref = v.sourceRef;
+  const refOk = v.source === "spans" ? Boolean(ref.projectId && ref.service?.trim()) : v.source === "metric" ? Boolean(ref.projectId && ref.goodMetric && ref.totalMetric) : Boolean(ref.id);
+  if (!refOk)
     ctx.addIssue({ code: "custom", path: ["sourceRef"], message: "INVALID_INPUT" });
-  if (v.sourceRef.environment !== undefined && v.source !== "monitor" && v.source !== "spans")
+  if (v.source === "metric" && ref.goodMetric && ref.totalMetric && sameSloMetric(ref.goodMetric, ref.totalMetric))
+    ctx.addIssue({ code: "custom", path: ["sourceRef", "goodMetric"], message: "INVALID_INPUT" });
+  if (v.source !== "metric" && (ref.goodMetric || ref.totalMetric))
+    ctx.addIssue({ code: "custom", path: ["sourceRef", "goodMetric"], message: "INVALID_INPUT" });
+  if (ref.environment !== undefined && v.source !== "monitor" && v.source !== "spans" && v.source !== "metric")
     ctx.addIssue({ code: "custom", path: ["sourceRef", "environment"], message: "INVALID_INPUT" });
   if (v.allowPublicSources && v.source !== "monitor" && v.source !== "spans")
     ctx.addIssue({ code: "custom", path: ["allowPublicSources"], message: "INVALID_INPUT" });
@@ -3015,7 +3044,7 @@ var MONITOR_OPERATIONS = [
     idempotency: "required",
     status: 201,
     mcp: "configure",
-    summary: "Create an SLO over a monitor, an uptime check or spans.",
+    summary: "Create an SLO over a monitor, a heartbeat, an uptime check, spans or two metric counters (good ÷ total).",
     ui: ["slos#createSlo"]
   }),
   op({
@@ -3129,7 +3158,7 @@ var MONITOR_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/node-data.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // ../src/shared/contracts/release-health.ts
 import { z as z21 } from "zod";
@@ -3387,175 +3416,234 @@ var fixStatusSchema = z21.object({
   verify_hours: z21.number()
 });
 
+// ../src/shared/contracts/web-vitals.ts
+import { z as z22 } from "zod";
+
+// ../src/shared/contracts/vocab/web-vitals.ts
+var WEB_VITAL_NAMES = ["LCP", "INP", "CLS", "FCP", "TTFB"];
+var WEB_VITAL_RATINGS = ["good", "needs-improvement", "poor"];
+var WEB_VITAL_PATH_MAX_CHARS = 200;
+
+// ../src/shared/contracts/web-vitals.ts
+var WEB_VITAL_LIMITS = {
+  routesMax: 200,
+  routesShown: 20,
+  attributionShown: 10,
+  estimateBelow: 100,
+  defaultSampleRate: 0.1,
+  targetMaxChars: 100,
+  pathMaxChars: WEB_VITAL_PATH_MAX_CHARS,
+  maxWindowMs: 7 * 24 * 3600 * 1000,
+  defaultWindowMs: 24 * 3600 * 1000
+};
+var ratingCounts = z22.object({
+  good: z22.number().int().nonnegative(),
+  needs_improvement: z22.number().int().nonnegative(),
+  poor: z22.number().int().nonnegative()
+});
+var webVitalSummarySchema = z22.object({
+  name: z22.enum(WEB_VITAL_NAMES),
+  metric: z22.string(),
+  unit: z22.enum(["ms", "1"]),
+  samples: z22.number().int().nonnegative(),
+  p75: z22.number().nullable(),
+  rating: z22.enum(WEB_VITAL_RATINGS).nullable(),
+  estimate: z22.boolean(),
+  ratings: ratingCounts,
+  distribution: z22.array(z22.object({ le: z22.number().nullable(), count: z22.number().int().nonnegative() })),
+  routes: z22.array(z22.object({
+    path: z22.string(),
+    samples: z22.number().int().nonnegative(),
+    p75: z22.number().nullable(),
+    rating: z22.enum(WEB_VITAL_RATINGS).nullable()
+  })),
+  routes_total: z22.number().int().nonnegative(),
+  attribution: z22.array(z22.object({ target: z22.string(), samples: z22.number().int().nonnegative(), p75: z22.number().nullable() }))
+});
+var webVitalsSummarySchema = z22.object({
+  from: z22.string(),
+  to: z22.string(),
+  path: z22.string().nullable(),
+  vitals: z22.array(webVitalSummarySchema),
+  complete: z22.boolean()
+});
+
 // ../src/shared/contracts/api-ops/node-data.ts
-var issueId = z22.number().int().positive();
-var csv = z22.string().min(1).max(2000);
-var name2 = z22.string().min(1).max(256);
-var period = z22.enum(["1h", "24h", "7d", "14d", "30d"]);
-var nodeCursor = z22.string().min(1).max(600).optional();
+var issueId = z23.number().int().positive();
+var csv = z23.string().min(1).max(2000);
+var projectIds2 = z23.string().max(2000).regex(/^[1-9][0-9]{0,15}(?:,[1-9][0-9]{0,15}){0,99}$/, "comma-separated project ids");
+var name2 = z23.string().min(1).max(256);
+var period = z23.enum(["1h", "24h", "7d", "14d", "30d"]);
+var nodeCursor = z23.string().min(1).max(600).optional();
 var windowFields = {
-  start: z22.string().max(40).optional(),
-  end: z22.string().max(40).optional()
+  start: z23.string().max(40).optional(),
+  end: z23.string().max(40).optional()
 };
-var traceId = z22.string().regex(/^[0-9a-fA-F]{32}$/);
-var spanId = z22.string().regex(/^[0-9a-fA-F]{16}$/);
-var attrs = z22.string().max(2000).optional();
+var traceId = z23.string().regex(/^[0-9a-fA-F]{32}$/);
+var spanId = z23.string().regex(/^[0-9a-fA-F]{16}$/);
+var attrs = z23.string().max(2000).optional();
 var telemetryCommon = {
   ...windowFields,
-  project: csv.optional(),
+  project: projectIds2.optional(),
   environment: csv.optional(),
   service: csv.optional(),
   attrs
 };
-var issueChange = z22.union([
-  z22.object({
-    action: z22.literal("resolve"),
-    inNextRelease: z22.boolean().optional(),
+var issueChange = z23.union([
+  z23.object({
+    action: z23.literal("resolve"),
+    inNextRelease: z23.boolean().optional(),
     inRelease: releaseNameSchema.optional()
   }),
-  z22.object({ action: z22.literal("unresolve") }),
-  z22.object({ action: z22.literal("archive"), mode: z22.enum(["until_escalating", "forever"]) }),
-  z22.object({
-    action: z22.literal("archive"),
-    mode: z22.literal("until_condition"),
-    events: z22.number().int().min(1).max(1e6).optional(),
-    users: z22.number().int().min(1).max(1e5).optional(),
-    until: z22.string().datetime().optional()
-  }),
-  z22.object({ action: z22.literal("assign"), userId: z22.guid().nullable() }),
-  z22.object({ action: z22.literal("priority"), priority: z22.enum(["low", "medium", "high"]) })
+  z23.object({ action: z23.literal("unresolve") }),
+  z23.object({ action: z23.literal("archive"), mode: z23.enum(["until_escalating", "forever"]) }),
+  z23.object({
+    action: z23.literal("archive"),
+    mode: z23.literal("until_condition"),
+    events: z23.number().int().min(1).max(1e6).optional(),
+    users: z23.number().int().min(1).max(1e5).optional(),
+    until: z23.string().datetime().optional()
+  }),
+  z23.object({ action: z23.literal("assign"), userId: z23.guid().nullable() }),
+  z23.object({ action: z23.literal("priority"), priority: z23.enum(["low", "medium", "high"]) })
 ]);
 var NODE_INPUTS = {
-  issuesList: z22.object({
-    project: csv.optional(),
-    status: z22.enum(["unresolved", "resolved", "archived", "all"]).optional(),
+  issuesList: z23.object({
+    project: projectIds2.optional(),
+    status: z23.enum(["unresolved", "resolved", "archived", "all"]).optional(),
     level: csv.optional(),
     priority: csv.optional(),
     environment: csv.optional(),
     release: csv.optional(),
-    assignee: z22.string().max(64).optional(),
+    assignee: z23.string().max(64).optional(),
     period: period.optional(),
-    q: z22.string().max(200).optional(),
-    sort: z22.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
+    q: z23.string().max(200).optional(),
+    sort: z23.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
     cursor: nodeCursor,
-    limit: z22.number().int().min(1).max(100).optional()
+    limit: z23.number().int().min(1).max(100).optional()
   }),
-  issue: z22.object({ issueId }),
-  issueStats: z22.object({ issueId, range: z22.enum(["24h", "30d"]).optional() }),
-  issueEvents: z22.object({ issueId, cursor: nodeCursor }),
-  issueEvent: z22.object({
+  issue: z23.object({ issueId }),
+  issueStats: z23.object({ issueId, range: z23.enum(["24h", "30d"]).optional() }),
+  issueEvents: z23.object({ issueId, cursor: nodeCursor }),
+  issueEvent: z23.object({
     issueId,
-    eventId: z22.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
+    eventId: z23.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
   }),
-  issueUpdate: z22.object({ issueId, change: issueChange }),
-  issuesBulk: z22.object({
-    issueIds: z22.array(issueId).min(1).max(100),
+  issueUpdate: z23.object({ issueId, change: issueChange }),
+  issuesBulk: z23.object({
+    issueIds: z23.array(issueId).min(1).max(100),
     action: issueChange
   }),
-  spansList: z22.object({
+  spansList: z23.object({
     ...telemetryCommon,
-    operation: z22.string().min(1).max(1024).optional(),
-    status: z22.enum(["unset", "ok", "error"]).optional(),
-    kind: z22.enum(["internal", "server", "client", "producer", "consumer"]).optional(),
-    minDurationMs: z22.number().min(0).max(86400000).optional(),
-    maxDurationMs: z22.number().min(0).max(86400000).optional(),
-    mode: z22.enum(["spans", "traces"]).optional(),
+    operation: z23.string().min(1).max(1024).optional(),
+    status: z23.enum(["unset", "ok", "error"]).optional(),
+    kind: z23.enum(["internal", "server", "client", "producer", "consumer"]).optional(),
+    minDurationMs: z23.number().min(0).max(86400000).optional(),
+    maxDurationMs: z23.number().min(0).max(86400000).optional(),
+    mode: z23.enum(["spans", "traces"]).optional(),
     cursor: nodeCursor
   }),
-  spansHistogram: z22.object({
+  spansHistogram: z23.object({
     ...telemetryCommon,
-    operation: z22.string().min(1).max(1024).optional(),
-    status: z22.enum(["unset", "ok", "error"]).optional()
+    operation: z23.string().min(1).max(1024).optional(),
+    status: z23.enum(["unset", "ok", "error"]).optional()
   }),
-  trace: z22.object({ traceId }),
-  traceSpans: z22.object({ traceId, errorsOnly: z22.enum(["1"]).optional(), ...windowFields }),
-  span: z22.object({ traceId, spanId, ...windowFields }),
-  logsList: z22.object({
+  trace: z23.object({ traceId }),
+  traceSpans: z23.object({ traceId, errorsOnly: z23.enum(["1"]).optional(), ...windowFields }),
+  span: z23.object({ traceId, spanId, ...windowFields }),
+  logsList: z23.object({
     ...telemetryCommon,
-    severityMin: z22.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    severityMin: z23.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
     traceId: traceId.optional(),
     spanId: spanId.optional(),
-    q: z22.string().max(500).optional(),
-    order: z22.enum(["asc", "desc"]).optional(),
+    q: z23.string().max(500).optional(),
+    order: z23.enum(["asc", "desc"]).optional(),
     cursor: nodeCursor
   }),
-  logsFacets: z22.object({
+  logsFacets: z23.object({
     ...telemetryCommon,
-    severityMin: z22.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
-    q: z22.string().max(500).optional()
-  }),
-  logAround: z22.object({
-    logId: z22.guid(),
-    at: z22.string().max(40),
-    same: z22.enum(["service", "trace"]).optional(),
-    before: z22.number().int().min(0).max(200).optional(),
-    after: z22.number().int().min(0).max(200).optional()
-  }),
-  metricsNames: z22.object({
-    project: z22.number().int().positive(),
+    severityMin: z23.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    q: z23.string().max(500).optional()
+  }),
+  logAround: z23.object({
+    logId: z23.guid(),
+    at: z23.string().max(40),
+    same: z23.enum(["service", "trace"]).optional(),
+    before: z23.number().int().min(0).max(200).optional(),
+    after: z23.number().int().min(0).max(200).optional()
+  }),
+  metricsNames: z23.object({
+    project: z23.number().int().positive(),
     environment: csv.optional(),
-    q: z22.string().max(255).optional()
+    q: z23.string().max(255).optional()
   }),
-  metricsSeries: z22.object({
-    project: z22.number().int().positive(),
-    name: z22.string().regex(METRIC_NAME_RE),
+  metricsSeries: z23.object({
+    project: z23.number().int().positive(),
+    name: z23.string().regex(METRIC_NAME_RE),
     environment: csv.optional(),
     attrs,
-    cursor: z22.string().regex(/^[0-9a-f]{16}$/).optional()
+    cursor: z23.string().regex(/^[0-9a-f]{16}$/).optional()
   }),
-  metricsQuery: z22.object({
-    project: z22.number().int().positive(),
-    name: z22.string().regex(METRIC_NAME_RE),
-    aggregation: z22.enum(METRIC_AGGREGATIONS),
+  metricsQuery: z23.object({
+    project: z23.number().int().positive(),
+    name: z23.string().regex(METRIC_NAME_RE),
+    aggregation: z23.enum(METRIC_AGGREGATIONS),
     ...windowFields,
-    step: z22.number().int().min(METRIC_QUERY.minStepSeconds).max(METRIC_QUERY.maxStepSeconds).multipleOf(60).optional(),
+    step: z23.number().int().min(METRIC_QUERY.minStepSeconds).max(METRIC_QUERY.maxStepSeconds).multipleOf(60).optional(),
     attrs,
-    groupBy: z22.string().min(1).max(600).optional(),
+    groupBy: z23.string().min(1).max(600).optional(),
     environment: csv.optional()
   }),
-  telemetryUsage: z22.object({
-    project: csv.optional(),
-    days: z22.number().int().min(1).max(31).optional()
+  telemetryUsage: z23.object({
+    project: projectIds2.optional(),
+    days: z23.number().int().min(1).max(31).optional()
   }),
-  monitorSignal: z22.object({
-    monitorId: z22.guid(),
-    hours: z22.number().int().min(1).max(24).optional()
+  monitorSignal: z23.object({
+    monitorId: z23.guid(),
+    hours: z23.number().int().min(1).max(24).optional()
   }),
-  monitorOccurrences: z22.object({
-    monitorId: z22.guid(),
-    state: z22.enum(["open", "finished", "all"]).optional(),
-    environment: z22.string().min(1).max(64).optional(),
+  monitorOccurrences: z23.object({
+    monitorId: z23.guid(),
+    state: z23.enum(["open", "finished", "all"]).optional(),
+    environment: z23.string().min(1).max(64).optional(),
     cursor: nodeCursor
   }),
-  monitorBacktest: z22.object({
-    project: z22.number().int().positive(),
+  monitorBacktest: z23.object({
+    project: z23.number().int().positive(),
     settings: backtestSettingsSchema
   }),
-  occurrenceCreate: z22.object({
-    project: z22.number().int().positive(),
+  occurrenceCreate: z23.object({
+    project: z23.number().int().positive(),
     monitorSlug: occurrenceInputSchema.shape.monitor_slug,
     occurrenceId: occurrenceInputSchema.shape.occurrence_id,
     dueAt: occurrenceInputSchema.shape.due_at,
     environment: occurrenceInputSchema.shape.environment
   }),
-  occurrenceCancel: z22.object({
-    project: z22.number().int().positive(),
-    monitorSlug: z22.string().regex(SLUG_RE),
-    occurrenceId: z22.string().regex(OCCURRENCE_ID_RE),
-    environment: z22.string().min(1).max(64).optional()
+  occurrenceCancel: z23.object({
+    project: z23.number().int().positive(),
+    monitorSlug: z23.string().regex(SLUG_RE),
+    occurrenceId: z23.string().regex(OCCURRENCE_ID_RE),
+    environment: z23.string().min(1).max(64).optional()
+  }),
+  webVitals: z23.object({
+    project: z23.number().int().positive(),
+    ...windowFields,
+    environment: csv.optional(),
+    path: z23.string().max(WEB_VITAL_LIMITS.pathMaxChars).regex(/^(?:\/[^\s?#]*|other)$/).optional()
   }),
-  releasesList: z22.object({
-    project: z22.number().int().positive(),
+  releasesList: z23.object({
+    project: z23.number().int().positive(),
     environment: environmentNameSchema.optional()
   }),
-  releaseHealth: z22.object({
-    project: z22.number().int().positive(),
+  releaseHealth: z23.object({
+    project: z23.number().int().positive(),
     version: releaseNameSchema,
     environment: environmentNameSchema.optional(),
     compare: releaseNameSchema.optional()
   }),
-  deploymentCreate: z22.object({
-    project: z22.number().int().positive(),
+  deploymentCreate: z23.object({
+    project: z23.number().int().positive(),
     version: deploymentInputSchema.shape.version,
     environment: deploymentInputSchema.shape.environment,
     name: deploymentInputSchema.shape.name,
@@ -3564,10 +3652,10 @@ var NODE_INPUTS = {
     finishedAt: deploymentInputSchema.shape.finished_at,
     deployId: deploymentInputSchema.shape.deploy_id
   }),
-  ticket: z22.object({
-    scope: z22.enum(["read", "write"]).default("read"),
-    project: z22.number().int().positive().optional(),
-    environment: z22.string().min(1).max(64).optional()
+  ticket: z23.object({
+    scope: z23.enum(["read", "write"]).default("read"),
+    project: z23.number().int().positive().optional(),
+    environment: z23.string().min(1).max(64).optional()
   })
 };
 var N = NODE_INPUTS;
@@ -3755,7 +3843,16 @@ var NODE_OPERATIONS = [
     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."
+    summary: "One metric aggregated per step (avg, sum, min, max, count, rate, p50, p75, p90, p95, 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: "metrics.web_vitals",
+    path: "/v1/projects/{project}/web-vitals",
+    scope: "metrics:read",
+    input: N.webVitals,
+    node: { path: "q/metrics/web-vitals", window: true },
+    summary: "Core Web Vitals of real users (LCP, INP, CLS, FCP, TTFB) in a window of at most 7 days: samples, p75 with its web.dev rating, samples per rating, the distribution, the busiest routes and the elements behind slow samples. Optionally one route. Needs browser SDK `webVitals` and node agent 0.1.40."
   }),
   op({
     ...read,
@@ -3895,10 +3992,10 @@ var NODE_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/privacy.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // ../src/shared/contracts/privacy.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../src/shared/privacy/rules.ts
 var PRIVACY_SCHEMA = 1;
@@ -3928,44 +4025,47 @@ var IPV6_RE = new RegExp(`(^|[^0-9A-Fa-f:])((?:${H}:){7}${H}|(?:${H}:){1,6}:(?:$
 var REMOVE = Symbol("remove");
 
 // ../src/shared/contracts/privacy.ts
-var ruleId = z23.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
-var privacyRuleInputSchema = z23.object({
+var PRIVACY_KEY_MAX_VERSION = 1e6;
+var ruleId = z24.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
+var privacyRuleInputSchema = z24.object({
   id: ruleId,
-  selector: z23.string().min(1).max(PRIVACY_LIMITS.selector),
-  type: z23.enum(PRIVACY_RULE_TYPES),
-  method: z23.enum(PRIVACY_METHODS),
-  pattern: z23.string().min(1).max(PRIVACY_LIMITS.pattern).optional(),
-  ignoreCase: z23.boolean().optional(),
-  replaceWith: z23.string().max(PRIVACY_LIMITS.replaceWith).optional(),
-  enabled: z23.boolean().optional()
-});
-var privacyPolicyInputSchema = z23.object({
-  mode: z23.enum(PRIVACY_MODES),
-  rules: z23.array(privacyRuleInputSchema).max(PRIVACY_LIMITS.rules),
-  allowlist: z23.array(z23.string().min(1).max(PRIVACY_LIMITS.selector)).max(PRIVACY_LIMITS.allowlist)
-});
-var storedPolicySchema = z23.object({
-  schema: z23.literal(PRIVACY_SCHEMA),
-  version: z23.number().int().min(0),
-  mode: z23.enum(PRIVACY_MODES),
-  rules: z23.array(z23.record(z23.string(), z23.unknown())).max(PRIVACY_LIMITS.rules),
-  allowlist: z23.array(z23.string()).max(PRIVACY_LIMITS.allowlist)
-});
-var nodePrivacyBlockSchema = z23.array(z23.object({ project_id: z23.number().int().positive(), policy: z23.unknown() })).max(1000);
-var privacyRollupSchema = z23.object({
-  applied_version: z23.number().int().min(0).nullable(),
-  policy_missing_24h: z23.number().int().nonnegative(),
-  budget_exceeded_24h: z23.number().int().nonnegative(),
-  sdk_versions: z23.array(z23.object({ version: z23.number().int().min(0), last_seen_at: z23.string().datetime() })).max(5)
+  selector: z24.string().min(1).max(PRIVACY_LIMITS.selector),
+  type: z24.enum(PRIVACY_RULE_TYPES),
+  method: z24.enum(PRIVACY_METHODS),
+  pattern: z24.string().min(1).max(PRIVACY_LIMITS.pattern).optional(),
+  ignoreCase: z24.boolean().optional(),
+  replaceWith: z24.string().max(PRIVACY_LIMITS.replaceWith).optional(),
+  enabled: z24.boolean().optional()
+});
+var privacyPolicyInputSchema = z24.object({
+  mode: z24.enum(PRIVACY_MODES),
+  rules: z24.array(privacyRuleInputSchema).max(PRIVACY_LIMITS.rules),
+  allowlist: z24.array(z24.string().min(1).max(PRIVACY_LIMITS.selector)).max(PRIVACY_LIMITS.allowlist)
+});
+var storedPolicySchema = z24.object({
+  schema: z24.literal(PRIVACY_SCHEMA),
+  version: z24.number().int().min(0),
+  mode: z24.enum(PRIVACY_MODES),
+  rules: z24.array(z24.record(z24.string(), z24.unknown())).max(PRIVACY_LIMITS.rules),
+  allowlist: z24.array(z24.string()).max(PRIVACY_LIMITS.allowlist)
+});
+var nodePrivacyBlockSchema = z24.array(z24.object({ project_id: z24.number().int().positive(), policy: z24.unknown() })).max(1000);
+var privacyRollupSchema = z24.object({
+  applied_version: z24.number().int().min(0).nullable(),
+  policy_missing_24h: z24.number().int().nonnegative(),
+  budget_exceeded_24h: z24.number().int().nonnegative(),
+  sdk_versions: z24.array(z24.object({ version: z24.number().int().min(0), last_seen_at: z24.string().datetime() })).max(5),
+  key_version: z24.number().int().min(1).max(PRIVACY_KEY_MAX_VERSION).optional(),
+  key_created_at: z24.string().datetime().nullable().optional()
 });
 
 // ../src/shared/contracts/api-ops/privacy.ts
 var PRIVACY_INPUTS = {
-  get: z24.object({ workspaceId: uuid, projectId }),
-  set: z24.object({
+  get: z25.object({ workspaceId: uuid, projectId }),
+  set: z25.object({
     workspaceId: uuid,
     projectId,
-    expectedVersion: z24.number().int().min(0),
+    expectedVersion: z25.number().int().min(0),
     policy: privacyPolicyInputSchema
   })
 };
@@ -3983,7 +4083,7 @@ var PRIVACY_OPERATIONS = [
     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.",
+    summary: "A project's privacy policy (mode, rules, strict allowlist, version), the built-in detectors that are off, whether user ids are pseudonymised, the pseudonymisation key version (never the key), the last 20 versions and what the node applies, hashes with and counted in the last 24 h.",
     ui: []
   }),
   op({
@@ -4005,10 +4105,10 @@ var PRIVACY_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/projects.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // ../src/shared/contracts/ingest-keys.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var INGEST_KEY_SCOPES = ["traces", "logs", "metrics", "errors", "monitors"];
 var INGEST_KEY_STATES = ["active", "revoked"];
 var INGEST_KEY_LIMITS = {
@@ -4018,92 +4118,92 @@ var INGEST_KEY_LIMITS = {
   edgeCacheSeconds: 60
 };
 var CHECKIN_AUTH_MODES = ["public_or_key", "key_only"];
-var ingestKeyConfigSchema = z25.object({
-  v: z25.literal(1),
-  key_id: z25.guid(),
-  project_public_id: z25.number().int().positive(),
-  project_id: z25.number().int().positive(),
-  workspace_id: z25.guid(),
+var ingestKeyConfigSchema = z26.object({
+  v: z26.literal(1),
+  key_id: z26.guid(),
+  project_public_id: z26.number().int().positive(),
+  project_id: z26.number().int().positive(),
+  workspace_id: z26.guid(),
   node_id: nodeIdSchema,
-  scopes: z25.array(z25.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
-  environments: z25.array(z25.string().max(INGEST_KEY_LIMITS.environmentMaxChars)).max(INGEST_KEY_LIMITS.environmentsMax),
-  expires_at: z25.string().datetime({ offset: true }).nullable(),
-  state: z25.enum(INGEST_KEY_STATES),
-  workspace_status: z25.enum(["active", "suspended", "deleting"]),
-  ingest_kill: z25.boolean(),
-  telemetry_kill: z25.boolean(),
-  telemetry_rate_bytes_per_sec: z25.number().int().positive(),
-  telemetry_burst_bytes: z25.number().int().positive(),
-  traces_monthly_bytes: z25.number().int().positive(),
-  logs_monthly_bytes: z25.number().int().positive(),
-  metrics_monthly_bytes: z25.number().int().positive().optional(),
-  telemetry_buffer_minutes: z25.number().int().min(1).max(1440),
-  revision: z25.number().int().nonnegative()
-});
-var createIngestKeyInputSchema = z25.object({
-  projectId: z25.number().int().positive(),
-  name: z25.string().trim().min(1).max(INGEST_KEY_LIMITS.nameMaxChars).refine((s) => !/[\u0000-\u001f\u007f]/.test(s)),
-  scopes: z25.array(z25.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
-  environments: z25.array(z25.string().trim().min(1).max(INGEST_KEY_LIMITS.environmentMaxChars).regex(/^[^\s/\u0000-\u001f]+$/)).max(INGEST_KEY_LIMITS.environmentsMax),
-  expiresAt: z25.string().datetime({ offset: true }).nullable()
-});
-var ingestKeyRowSchema = z25.object({
-  id: z25.guid(),
-  project_id: z25.number().int().positive(),
-  name: z25.string(),
-  prefix: z25.string(),
-  scopes: z25.array(z25.enum(INGEST_KEY_SCOPES)),
-  environments: z25.array(z25.string()),
-  expires_at: z25.string().nullable(),
-  state: z25.enum(INGEST_KEY_STATES),
-  created_by: z25.guid().nullable(),
-  created_at: z25.string(),
-  revoked_at: z25.string().nullable(),
-  last_used_at: z25.string().nullable()
+  scopes: z26.array(z26.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z26.array(z26.string().max(INGEST_KEY_LIMITS.environmentMaxChars)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expires_at: z26.string().datetime({ offset: true }).nullable(),
+  state: z26.enum(INGEST_KEY_STATES),
+  workspace_status: z26.enum(["active", "suspended", "deleting"]),
+  ingest_kill: z26.boolean(),
+  telemetry_kill: z26.boolean(),
+  telemetry_rate_bytes_per_sec: z26.number().int().positive(),
+  telemetry_burst_bytes: z26.number().int().positive(),
+  traces_monthly_bytes: z26.number().int().positive(),
+  logs_monthly_bytes: z26.number().int().positive(),
+  metrics_monthly_bytes: z26.number().int().positive().optional(),
+  telemetry_buffer_minutes: z26.number().int().min(1).max(1440),
+  revision: z26.number().int().nonnegative()
+});
+var createIngestKeyInputSchema = z26.object({
+  projectId: z26.number().int().positive(),
+  name: z26.string().trim().min(1).max(INGEST_KEY_LIMITS.nameMaxChars).refine((s) => !/[\u0000-\u001f\u007f]/.test(s)),
+  scopes: z26.array(z26.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z26.array(z26.string().trim().min(1).max(INGEST_KEY_LIMITS.environmentMaxChars).regex(/^[^\s/\u0000-\u001f]+$/)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expiresAt: z26.string().datetime({ offset: true }).nullable()
+});
+var ingestKeyRowSchema = z26.object({
+  id: z26.guid(),
+  project_id: z26.number().int().positive(),
+  name: z26.string(),
+  prefix: z26.string(),
+  scopes: z26.array(z26.enum(INGEST_KEY_SCOPES)),
+  environments: z26.array(z26.string()),
+  expires_at: z26.string().nullable(),
+  state: z26.enum(INGEST_KEY_STATES),
+  created_by: z26.guid().nullable(),
+  created_at: z26.string(),
+  revoked_at: z26.string().nullable(),
+  last_used_at: z26.string().nullable()
 });
 
 // ../src/shared/contracts/node-config.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // ../src/shared/contracts/backup.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var BACKUP_KINDS = ["daily", "weekly", "manual", "pre_upgrade"];
-var ageRecipient = z26.string().regex(/^age1[02-9ac-hj-np-z]{58}$/);
-var backupIdSchema = z26.string().regex(/^[a-z0-9-]{8,64}$/);
-var nodeBackupConfigSchema = z26.object({
-  enabled: z26.boolean(),
-  hour_utc: z26.number().int().min(0).max(23),
-  weekly_day: z26.number().int().min(1).max(7),
+var ageRecipient = z27.string().regex(/^age1[02-9ac-hj-np-z]{58}$/);
+var backupIdSchema = z27.string().regex(/^[a-z0-9-]{8,64}$/);
+var nodeBackupConfigSchema = z27.object({
+  enabled: z27.boolean(),
+  hour_utc: z27.number().int().min(0).max(23),
+  weekly_day: z27.number().int().min(1).max(7),
   workspace_recipient: ageRecipient
 });
-var backupCredentialsRequestSchema = z26.object({
-  mode: z26.enum(["upload", "download"]),
+var backupCredentialsRequestSchema = z27.object({
+  mode: z27.enum(["upload", "download"]),
   backup_id: backupIdSchema,
-  source_node_id: z26.guid().optional()
-});
-var backupCredentialsSchema = z26.object({
-  endpoint: z26.string().url(),
-  bucket: z26.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/),
-  prefix: z26.string().regex(/^backups\/[0-9a-f-]{36}\/$/),
-  access_key_id: z26.string().min(8).max(200),
-  secret_access_key: z26.string().min(8).max(200),
-  session_token: z26.string().min(8).max(4000),
-  expires_at: z26.string().datetime()
-});
-var rowCountsSchema = z26.record(z26.string().regex(/^[a-z_][a-z0-9_]{0,63}$/), z26.number().int().nonnegative());
-var backupManifestSchema = z26.object({
-  v: z26.literal(1),
+  source_node_id: z27.guid().optional()
+});
+var backupCredentialsSchema = z27.object({
+  endpoint: z27.string().url(),
+  bucket: z27.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/),
+  prefix: z27.string().regex(/^backups\/[0-9a-f-]{36}\/$/),
+  access_key_id: z27.string().min(8).max(200),
+  secret_access_key: z27.string().min(8).max(200),
+  session_token: z27.string().min(8).max(4000),
+  expires_at: z27.string().datetime()
+});
+var rowCountsSchema = z27.record(z27.string().regex(/^[a-z_][a-z0-9_]{0,63}$/), z27.number().int().nonnegative());
+var backupManifestSchema = z27.object({
+  v: z27.literal(1),
   backup_id: backupIdSchema,
-  node_id: z26.guid(),
-  kind: z26.enum(BACKUP_KINDS),
-  created_at: z26.string().datetime(),
-  object_key: z26.string(),
-  size_bytes: z26.number().int().nonnegative(),
-  sha256: z26.string().regex(/^[0-9a-f]{64}$/),
-  clickhouse_version: z26.string().max(40),
-  schema_version: z26.number().int().nonnegative(),
+  node_id: z27.guid(),
+  kind: z27.enum(BACKUP_KINDS),
+  created_at: z27.string().datetime(),
+  object_key: z27.string(),
+  size_bytes: z27.number().int().nonnegative(),
+  sha256: z27.string().regex(/^[0-9a-f]{64}$/),
+  clickhouse_version: z27.string().max(40),
+  schema_version: z27.number().int().nonnegative(),
   row_counts: rowCountsSchema,
-  recipients: z26.array(z26.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
+  recipients: z27.array(z27.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
 });
 var BACKUP_ERROR_CODES = [
   "CLICKHOUSE_BACKUP_FAILED",
@@ -4117,48 +4217,48 @@ var BACKUP_ERROR_CODES = [
   "RESTORE_FAILED",
   "ROW_COUNT_MISMATCH"
 ];
-var backupReportSchema = z26.object({
+var backupReportSchema = z27.object({
   backup_id: backupIdSchema,
-  kind: z26.enum(BACKUP_KINDS),
-  status: z26.enum(["succeeded", "failed"]),
-  started_at: z26.string().datetime(),
-  finished_at: z26.string().datetime(),
+  kind: z27.enum(BACKUP_KINDS),
+  status: z27.enum(["succeeded", "failed"]),
+  started_at: z27.string().datetime(),
+  finished_at: z27.string().datetime(),
   manifest: backupManifestSchema.nullable(),
-  error_code: z26.enum(BACKUP_ERROR_CODES).nullable()
+  error_code: z27.enum(BACKUP_ERROR_CODES).nullable()
 });
-var drillReportSchema = z26.object({
+var drillReportSchema = z27.object({
   backup_id: backupIdSchema,
-  kind: z26.enum(["weekly_local", "monthly_new_machine"]),
-  status: z26.enum(["passed", "failed"]),
-  finished_at: z26.string().datetime(),
-  detail: z26.string().max(300),
-  error_code: z26.enum(BACKUP_ERROR_CODES).nullable()
+  kind: z27.enum(["weekly_local", "monthly_new_machine"]),
+  status: z27.enum(["passed", "failed"]),
+  finished_at: z27.string().datetime(),
+  detail: z27.string().max(300),
+  error_code: z27.enum(BACKUP_ERROR_CODES).nullable()
 });
-var nodeIdentityEscrowSchema = z26.object({
-  v: z26.literal(1),
-  node_id: z26.guid(),
-  seal: z26.object({
-    publicKey: z26.string().regex(/^[A-Za-z0-9_-]{43}$/),
-    privateKey: z26.string().regex(/^[A-Za-z0-9_-]{43}$/)
+var nodeIdentityEscrowSchema = z27.object({
+  v: z27.literal(1),
+  node_id: z27.guid(),
+  seal: z27.object({
+    publicKey: z27.string().regex(/^[A-Za-z0-9_-]{43}$/),
+    privateKey: z27.string().regex(/^[A-Za-z0-9_-]{43}$/)
   }),
-  created_at: z26.string().datetime()
+  created_at: z27.string().datetime()
 });
-var restoreArgsSchema = z26.object({
-  job_id: z26.guid(),
-  workspace_id: z26.guid(),
-  source_node_id: z26.guid(),
+var restoreArgsSchema = z27.object({
+  job_id: z27.guid(),
+  workspace_id: z27.guid(),
+  source_node_id: z27.guid(),
   manifest: backupManifestSchema,
-  sealed_identity: z26.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
-  mode: z26.enum(["rebuild", "drill"])
+  sealed_identity: z27.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
+  mode: z27.enum(["rebuild", "drill"])
 });
-var restoreReportSchema = z26.object({
-  job_id: z26.guid(),
+var restoreReportSchema = z27.object({
+  job_id: z27.guid(),
   backup_id: backupIdSchema,
-  mode: z26.enum(["rebuild", "drill"]),
-  status: z26.enum(["succeeded", "failed"]),
-  finished_at: z26.string().datetime(),
-  detail: z26.string().max(300),
-  error_code: z26.enum(BACKUP_ERROR_CODES).nullable()
+  mode: z27.enum(["rebuild", "drill"]),
+  status: z27.enum(["succeeded", "failed"]),
+  finished_at: z27.string().datetime(),
+  detail: z27.string().max(300),
+  error_code: z27.enum(BACKUP_ERROR_CODES).nullable()
 });
 
 // ../src/shared/contracts/node-config.ts
@@ -4172,84 +4272,85 @@ var SCRUB_GROUPS = [
   "headers"
 ];
 var MAX_NODE_MONITORS = 5000;
-var kid = z27.string().regex(/^[A-Za-z0-9_-]{1,40}$/);
-var publicKey = z27.string().regex(/^[A-Za-z0-9_-]{43}$/);
-var nodeConfigSchema = z27.object({
-  v: z27.literal(1),
-  config_version: z27.number().int().positive(),
-  node_id: z27.guid(),
-  workspace_id: z27.guid(),
-  workspace_status: z27.enum(["active", "suspended"]),
-  issued_at: z27.string().datetime(),
-  retention_days: z27.number().int().min(1).max(3650),
-  channel: z27.enum(["stable", "canary"]).optional(),
-  projects: z27.array(z27.object({
-    project_id: z27.number().int().positive(),
-    slug: z27.string().max(64),
-    short_prefix: z27.string().regex(/^[A-Z0-9]{1,12}$/),
-    user_id_salt: z27.string().regex(/^[A-Za-z0-9_-]{22,64}$/),
-    scrub_disabled: z27.array(z27.enum(SCRUB_GROUPS)).max(SCRUB_GROUPS.length),
-    upload_tokens: z27.array(z27.object({
-      hash: z27.string().regex(/^[a-f0-9]{64}$/),
-      expires_at: z27.string().datetime(),
-      scopes: z27.array(z27.enum(UPLOAD_SCOPES)).min(1).max(UPLOAD_SCOPES.length).optional()
+var kid = z28.string().regex(/^[A-Za-z0-9_-]{1,40}$/);
+var publicKey = z28.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var nodeConfigSchema = z28.object({
+  v: z28.literal(1),
+  config_version: z28.number().int().positive(),
+  node_id: z28.guid(),
+  workspace_id: z28.guid(),
+  workspace_status: z28.enum(["active", "suspended"]),
+  issued_at: z28.string().datetime(),
+  retention_days: z28.number().int().min(1).max(3650),
+  channel: z28.enum(["stable", "canary"]).optional(),
+  projects: z28.array(z28.object({
+    project_id: z28.number().int().positive(),
+    slug: z28.string().max(64),
+    short_prefix: z28.string().regex(/^[A-Z0-9]{1,12}$/),
+    user_id_salt: z28.string().regex(/^[A-Za-z0-9_-]{22,64}$/),
+    privacy_key_version: z28.number().int().min(1).max(PRIVACY_KEY_MAX_VERSION).optional(),
+    scrub_disabled: z28.array(z28.enum(SCRUB_GROUPS)).max(SCRUB_GROUPS.length),
+    upload_tokens: z28.array(z28.object({
+      hash: z28.string().regex(/^[a-f0-9]{64}$/),
+      expires_at: z28.string().datetime(),
+      scopes: z28.array(z28.enum(UPLOAD_SCOPES)).min(1).max(UPLOAD_SCOPES.length).optional()
     })).max(10).optional()
   })).max(1000),
-  ticket_keys: z27.array(z27.object({ kid, public_key: publicKey, not_after: z27.string().datetime() })).min(1).max(5),
-  control_ops_keys: z27.array(z27.object({ kid, public_key: publicKey })).min(1).max(5),
-  kill_switches: z27.object({ ingest: z27.boolean(), alerts: z27.boolean() }),
+  ticket_keys: z28.array(z28.object({ kid, public_key: publicKey, not_after: z28.string().datetime() })).min(1).max(5),
+  control_ops_keys: z28.array(z28.object({ kid, public_key: publicKey })).min(1).max(5),
+  kill_switches: z28.object({ ingest: z28.boolean(), alerts: z28.boolean() }),
   backup: nodeBackupConfigSchema.optional(),
-  purged_projects: z27.array(z27.number().int().positive()).max(1000).optional(),
-  monitors: z27.array(monitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
-  purged_monitors: z27.array(z27.guid()).max(5000).optional(),
-  telemetry: z27.object({
-    traces_retention_days: z27.number().int().min(1).max(90),
-    logs_retention_days: z27.number().int().min(1).max(90),
-    traces_disk_share: z27.number().min(0.2).max(0.8)
+  purged_projects: z28.array(z28.number().int().positive()).max(1000).optional(),
+  monitors: z28.array(monitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  purged_monitors: z28.array(z28.guid()).max(5000).optional(),
+  telemetry: z28.object({
+    traces_retention_days: z28.number().int().min(1).max(90),
+    logs_retention_days: z28.number().int().min(1).max(90),
+    traces_disk_share: z28.number().min(0.2).max(0.8)
   }).optional(),
   metrics: metricsConfigSchema.optional(),
-  slos: z27.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
-  signal_monitors: z27.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  slos: z28.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
+  signal_monitors: z28.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
   signal_limits: signalLimitsConfigSchema.optional(),
   privacy: nodePrivacyBlockSchema.optional()
 });
-var signedNodeConfigSchema = z27.object({ config: nodeConfigSchema, kid, sig: z27.string() });
+var signedNodeConfigSchema = z28.object({ config: nodeConfigSchema, kid, sig: z28.string() });
 
 // ../src/shared/contracts/api-ops/projects.ts
-var slug = z28.string().regex(/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/);
-var name3 = z28.string().trim().min(1).max(60);
-var label2 = z28.string().trim().min(1).max(40);
-var platform = z28.enum(PLATFORMS);
-var origin = z28.string().trim().toLowerCase().regex(/^https?:\/\/[a-z0-9.-]+(:[0-9]{1,5})?$/).max(200);
-var keyId = z28.number().int().positive();
+var slug = z29.string().regex(/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/);
+var name3 = z29.string().trim().min(1).max(60);
+var label2 = z29.string().trim().min(1).max(40);
+var platform = z29.enum(PLATFORMS);
+var origin = z29.string().trim().toLowerCase().regex(/^https?:\/\/[a-z0-9.-]+(:[0-9]{1,5})?$/).max(200);
+var keyId = z29.number().int().positive();
 var PROJECT_INPUTS = {
-  create: z28.object({ workspaceId: uuid, name: name3, slug, platform }),
-  update: z28.object({ projectId, name: name3, platform, isPinned: z28.boolean() }),
-  updateIntake: z28.object({
+  create: z29.object({ workspaceId: uuid, name: name3, slug, platform }),
+  update: z29.object({ projectId, name: name3, platform, isPinned: z29.boolean() }),
+  updateIntake: z29.object({
     projectId,
-    rateLimit: z28.number().int().positive().nullable(),
-    burst: z28.number().int().positive().nullable(),
-    allowedOrigins: z28.array(origin).max(50)
+    rateLimit: z29.number().int().positive().nullable(),
+    burst: z29.number().int().positive().nullable(),
+    allowedOrigins: z29.array(origin).max(50)
   }),
-  updateObservability: z28.object({
+  updateObservability: z29.object({
     projectId,
-    primaryEnvironment: z28.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
-    allowCodeMonitors: z28.boolean()
+    primaryEnvironment: z29.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
+    allowCodeMonitors: z29.boolean()
   }),
-  setScrub: z28.object({ projectId, group: z28.enum(SCRUB_GROUPS), enabled: z28.boolean() }),
-  setCheckinAuth: z28.object({ projectId, mode: z28.enum(CHECKIN_AUTH_MODES) }),
-  setEnvironmentHidden: z28.object({
+  setScrub: z29.object({ projectId, group: z29.enum(SCRUB_GROUPS), enabled: z29.boolean() }),
+  setCheckinAuth: z29.object({ projectId, mode: z29.enum(CHECKIN_AUTH_MODES) }),
+  setEnvironmentHidden: z29.object({
     projectId,
-    name: z28.string().min(1).max(64),
-    hidden: z28.boolean()
-  }),
-  scheduleDeletion: z28.object({ projectId, confirmSlug: slug }),
-  projectOnly: z28.object({ projectId }),
-  labelled: z28.object({ projectId, label: label2 }),
-  keyOnly: z28.object({ keyId }),
-  tokenOnly: z28.object({ tokenId: keyId }),
+    name: z29.string().min(1).max(64),
+    hidden: z29.boolean()
+  }),
+  scheduleDeletion: z29.object({ projectId, confirmSlug: slug }),
+  projectOnly: z29.object({ projectId }),
+  labelled: z29.object({ projectId, label: label2 }),
+  keyOnly: z29.object({ keyId }),
+  tokenOnly: z29.object({ tokenId: keyId }),
   createIngestKey: createIngestKeyInputSchema,
-  ingestKeyOnly: z28.object({ keyId: uuid })
+  ingestKeyOnly: z29.object({ keyId: uuid })
 };
 var P2 = PROJECT_INPUTS;
 var PROJECT_OPERATIONS = [
@@ -4504,24 +4605,24 @@ var PROJECT_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/reads.ts
-import { z as z29 } from "zod";
-var list = z29.object({ workspaceId: uuid, limit: pageLimit, cursor });
+import { z as z30 } from "zod";
+var list = z30.object({ workspaceId: uuid, limit: pageLimit, cursor });
 var READ_INPUTS = {
-  workspace: z29.object({ workspaceId: uuid }),
+  workspace: z30.object({ workspaceId: uuid }),
   list,
-  projectsGet: z29.object({ workspaceId: uuid, projectId }),
+  projectsGet: z30.object({ workspaceId: uuid, projectId }),
   monitorsList: list.extend({ projectId: projectId.optional() }),
-  monitorsGet: z29.object({ workspaceId: uuid, monitorId: uuid }),
-  uptimeGet: z29.object({ workspaceId: uuid, checkId: uuid }),
-  slosGet: z29.object({ workspaceId: uuid, sloId: uuid }),
+  monitorsGet: z30.object({ workspaceId: uuid, monitorId: uuid }),
+  uptimeGet: z30.object({ workspaceId: uuid, checkId: uuid }),
+  slosGet: z30.object({ workspaceId: uuid, sloId: uuid }),
   alertsList: list.extend({
-    state: z29.enum(["open", "resolved", "all"]).default("all"),
+    state: z30.enum(["open", "resolved", "all"]).default("all"),
     monitorId: uuid.optional()
   }),
-  approvalsGet: z29.object({ workspaceId: uuid, approvalId: uuid }),
+  approvalsGet: z30.object({ workspaceId: uuid, approvalId: uuid }),
   monitorsListTyped: list.extend({
     projectId: projectId.optional(),
-    type: z29.enum(MONITOR_TYPES).optional()
+    type: z30.enum(MONITOR_TYPES).optional()
   })
 };
 var R = READ_INPUTS;
@@ -4805,14 +4906,14 @@ function approvalRequestSchema(operationId, input) {
 }
 
 // ../src/shared/contracts/api-ops/wire.ts
-import { z as z30 } from "zod";
+import { z as z31 } 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 = z30.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
+    js = z31.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
     schemaCache.set(op.input, js);
   }
   return js;
@@ -5026,7 +5127,7 @@ function wireInput(operationId, opts = {}) {
   for (const [k, v] of Object.entries(op.input.shape))
     if (!omit.has(k))
       shape[toSnake(k)] = v;
-  return z31.object(shape);
+  return z32.object(shape);
 }
 var BUDGETS = [
   { stringBytes: MCP_LIMITS.untrustedStringMaxBytes, listMax: MCP_LIMITS.listMax },
@@ -5119,52 +5220,52 @@ function errorResult(o) {
     }
   };
 }
-var TOOL_OUTPUT_SCHEMA = z31.object({
-  untrusted: z31.object({
-    data: z31.unknown(),
-    provenance: z31.object({
-      source: z31.enum(["node", "control_plane", "docs"]),
-      operations: z31.array(z31.string())
+var TOOL_OUTPUT_SCHEMA = z32.object({
+  untrusted: z32.object({
+    data: z32.unknown(),
+    provenance: z32.object({
+      source: z32.enum(["node", "control_plane", "docs"]),
+      operations: z32.array(z32.string())
     })
   }).optional(),
-  doc: z31.object({
-    slug: z31.string(),
-    locale: z31.enum(["en", "vi"]),
-    url: z31.string(),
-    markdown: z31.string(),
-    truncated: z31.boolean()
+  doc: z32.object({
+    slug: z32.string(),
+    locale: z32.enum(["en", "vi"]),
+    url: z32.string(),
+    markdown: z32.string(),
+    truncated: z32.boolean()
   }).optional(),
-  results: z31.array(z31.object({
-    slug: z31.string(),
-    title: z31.string(),
-    description: z31.string(),
-    section: z31.string(),
-    url: z31.string()
+  results: z32.array(z32.object({
+    slug: z32.string(),
+    title: z32.string(),
+    description: z32.string(),
+    section: z32.string(),
+    url: z32.string()
   })).optional(),
-  next_cursor: z31.string().nullable().optional(),
-  complete: z31.boolean().optional(),
-  omitted: z31.array(z31.object({ part: z31.string(), reason: z31.string(), scope: z31.string().optional() })).optional(),
-  truncated: z31.literal(true).optional(),
-  suspicious_unicode: z31.literal(true).optional(),
-  error: z31.object({
-    code: z31.string(),
-    status: z31.number(),
-    detail: z31.string().optional(),
-    scope: z31.string().optional(),
-    retry_after: z31.number().optional()
+  next_cursor: z32.string().nullable().optional(),
+  complete: z32.boolean().optional(),
+  omitted: z32.array(z32.object({ part: z32.string(), reason: z32.string(), scope: z32.string().optional() })).optional(),
+  truncated: z32.literal(true).optional(),
+  suspicious_unicode: z32.literal(true).optional(),
+  error: z32.object({
+    code: z32.string(),
+    status: z32.number(),
+    detail: z32.string().optional(),
+    scope: z32.string().optional(),
+    retry_after: z32.number().optional()
   }).optional(),
-  operations: z31.array(z31.record(z31.string(), z31.unknown())).optional(),
-  operation: z31.record(z31.string(), z31.unknown()).optional(),
-  plan: z31.record(z31.string(), z31.unknown()).optional(),
-  status: z31.enum(["done", "approval_required", "approval_pending", ...APPROVAL_STATES]).optional(),
-  approval: z31.object({
-    approval_id: z31.string(),
-    approval_url: z31.string(),
-    expires_at: z31.string(),
-    state: z31.enum(APPROVAL_STATES),
-    result_code: z31.string().nullable().optional(),
-    result: z31.record(z31.string(), z31.unknown()).optional(),
-    next: z31.string().optional()
+  operations: z32.array(z32.record(z32.string(), z32.unknown())).optional(),
+  operation: z32.record(z32.string(), z32.unknown()).optional(),
+  plan: z32.record(z32.string(), z32.unknown()).optional(),
+  status: z32.enum(["done", "approval_required", "approval_pending", ...APPROVAL_STATES]).optional(),
+  approval: z32.object({
+    approval_id: z32.string(),
+    approval_url: z32.string(),
+    expires_at: z32.string(),
+    state: z32.enum(APPROVAL_STATES),
+    result_code: z32.string().nullable().optional(),
+    result: z32.record(z32.string(), z32.unknown()).optional(),
+    next: z32.string().optional()
   }).optional()
 });
 var spec = (name) => {
@@ -5210,10 +5311,10 @@ var has = (rt, operationId) => {
   return !!op && rt.scopes.includes(op.scope);
 };
 var isoWindow = {
-  start: z31.string().max(40).describe("RFC 3339 start of the window, e.g. 2026-10-26T00:00:00Z. Required with end."),
-  end: z31.string().max(40).describe("RFC 3339 end of the window. The plan limits its length.")
+  start: z32.string().max(40).describe("RFC 3339 start of the window, e.g. 2026-10-26T00:00:00Z. Required with end."),
+  end: z32.string().max(40).describe("RFC 3339 end of the window. The plan limits its length.")
 };
-var traceIdSchema = z31.string().regex(/^[0-9a-fA-F]{32}$/);
+var traceIdSchema = z32.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" },
@@ -5277,8 +5378,8 @@ function describe(op, scopes) {
     destructive: isDestructiveOperation(op)
   };
 }
-var params = z31.record(z31.string(), z31.unknown()).default({}).describe("Operation fields in wire names (snake_case), as describe_operation's args_schema shows.");
-var operationIdArg = z31.string().min(3).max(80).describe("An operation id from search_operations, e.g. `monitors.update`.");
+var params = z32.record(z32.string(), z32.unknown()).default({}).describe("Operation fields in wire names (snake_case), as describe_operation's args_schema shows.");
+var operationIdArg = z32.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,
@@ -5298,7 +5399,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: z31.object({}),
+    input: z32.object({}),
     async run(_args, rt) {
       const [ws, node] = await Promise.all([rt.call("workspace.get", {}), rt.call("node.get", {})]);
       if (!ws.ok)
@@ -5320,9 +5421,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). A resolved issue also carries `fix_status` when the token can read releases: fixed, unverified, not_fixed (with the event that broke it) or unknown, per environment.",
     operations: ["issues.get", "events.get", "issues.fix_status"],
-    input: z31.object({
-      issue_id: z31.number().int().positive().describe("Issue id from search_issues."),
-      include_latest_event: z31.boolean().default(true)
+    input: z32.object({
+      issue_id: z32.number().int().positive().describe("Issue id from search_issues."),
+      include_latest_event: z32.boolean().default(true)
     }),
     async run(args, rt) {
       const omitted = [];
@@ -5363,9 +5464,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: z31.object({
+    input: z32.object({
       trace_id: traceIdSchema.describe("W3C trace id, 32 hex characters."),
-      spans: z31.enum(["none", "errors", "all"]).default("none")
+      spans: z32.enum(["none", "errors", "all"]).default("none")
     }),
     async run(args, rt) {
       const sum = await rt.call("traces.get", { trace_id: args["trace_id"] });
@@ -5397,17 +5498,17 @@ var MCP_TOOL_DEFS = [
     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: z31.object({
-      project: z31.number().int().positive().describe("Numeric project id from list_projects."),
-      name: z31.string().regex(METRIC_NAME_RE).optional().describe("Metric name from the catalog, e.g. http.server.request.duration."),
-      q: z31.string().max(255).optional().describe("Catalog only: part of a metric name."),
-      aggregation: z31.enum(METRIC_AGGREGATIONS).optional(),
+    input: z32.object({
+      project: z32.number().int().positive().describe("Numeric project id from list_projects."),
+      name: z32.string().regex(METRIC_NAME_RE).optional().describe("Metric name from the catalog, e.g. http.server.request.duration."),
+      q: z32.string().max(255).optional().describe("Catalog only: part of a metric name."),
+      aggregation: z32.enum(METRIC_AGGREGATIONS).optional(),
       start: isoWindow.start.optional(),
       end: isoWindow.end.optional(),
-      step: z31.number().int().min(60).max(86400).multipleOf(60).optional().describe("Seconds per point (whole minutes); picked from the window when absent."),
-      attrs: z31.string().max(2000).optional(),
-      group_by: z31.string().max(600).optional(),
-      environment: z31.string().max(2000).optional().describe("Comma-separated environments.")
+      step: z32.number().int().min(60).max(86400).multipleOf(60).optional().describe("Seconds per point (whole minutes); picked from the window when absent."),
+      attrs: z32.string().max(2000).optional(),
+      group_by: z32.string().max(600).optional(),
+      environment: z32.string().max(2000).optional().describe("Comma-separated environments.")
     }),
     async run(args, rt) {
       const scope = {
@@ -5462,8 +5563,8 @@ var MCP_TOOL_DEFS = [
     title: "Release health",
     description: "What changed with a release (spec 13). With `version`: that release in one environment against the previous one (or `compare`) — three lists for its first 24 hours: new issues, regressed issues and increased issues (≥ 2× events per hour and ≥ 10 events), up to 50 each with hourly sparklines, plus its deploy markers. Without `version`: the project's releases, newest deploy first, with those three counts. `environment` defaults to production (else the busiest). Whether a resolved issue is really fixed: get_issue returns its fix status.",
     operations: ["releases.list", "releases.health"],
-    input: z31.object({
-      project: z31.number().int().positive().describe("Numeric project id from list_projects."),
+    input: z32.object({
+      project: z32.number().int().positive().describe("Numeric project id from list_projects."),
       version: releaseNameSchema.optional().describe("Release name exactly as the SDK sends it, e.g. web@1.4.2."),
       environment: environmentNameSchema.optional().describe("One environment, e.g. production."),
       compare: releaseNameSchema.optional().describe("With version: compare against this release instead of the previous one.")
@@ -5495,11 +5596,11 @@ var MCP_TOOL_DEFS = [
     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: z31.object({
+    input: z32.object({
       trace_id: traceIdSchema.optional(),
-      run_id: z31.string().min(1).max(128).optional(),
+      run_id: z32.string().min(1).max(128).optional(),
       ...isoWindow,
-      project: z31.string().max(2000).optional().describe("Comma-separated project ids.")
+      project: z32.string().max(2000).optional().describe("Comma-separated project ids.")
     }),
     async run(args, rt) {
       const trace = args["trace_id"];
@@ -5558,10 +5659,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: z31.object({
-      kind: z31.enum(["all", "cron", "uptime", "slo"]).default("all"),
-      project_id: z31.number().int().positive().optional(),
-      limit: z31.number().int().min(1).max(200).default(50)
+    input: z32.object({
+      kind: z32.enum(["all", "cron", "uptime", "slo"]).default("all"),
+      project_id: z32.number().int().positive().optional(),
+      limit: z32.number().int().min(1).max(200).default(50)
     }),
     async run(args, rt) {
       const kinds = args["kind"] && args["kind"] !== "all" ? [args["kind"]] : ["cron", "uptime", "slo"];
@@ -5596,10 +5697,10 @@ var MCP_TOOL_DEFS = [
       "monitors.occurrences",
       "monitors.backtest"
     ],
-    input: z31.object({
-      kind: z31.enum(["cron", "uptime", "slo"]),
-      id: z31.guid(),
-      backtest: z31.boolean().default(false)
+    input: z32.object({
+      kind: z32.enum(["cron", "uptime", "slo"]),
+      id: z32.guid(),
+      backtest: z32.boolean().default(false)
     }),
     async run(args, rt) {
       const k = MONITOR_KINDS2[args["kind"]];
@@ -5659,9 +5760,9 @@ var MCP_TOOL_DEFS = [
     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: z31.object({
-      project_id: z31.number().int().positive(),
-      idempotency_key: z31.string().min(8).max(255).optional()
+    input: z32.object({
+      project_id: z32.number().int().positive(),
+      idempotency_key: z32.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() });
@@ -5679,9 +5780,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: z31.object({
-      query: z31.string().min(1).max(200).describe("Words such as `rotate dsn key`, `heartbeat monitor`, `slack alert`."),
-      limit: z31.number().int().min(1).max(20).default(10)
+    input: z32.object({
+      query: z32.string().min(1).max(200).describe("Words such as `rotate dsn key`, `heartbeat monitor`, `slack alert`."),
+      limit: z32.number().int().min(1).max(20).default(10)
     }),
     async run(args, rt) {
       const q = words(String(args["query"]));
@@ -5709,7 +5810,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: z31.object({ operation_id: operationIdArg }),
+    input: z32.object({ operation_id: operationIdArg }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -5738,7 +5839,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: z31.object({ operation_id: operationIdArg, params }),
+    input: z32.object({ operation_id: operationIdArg, params }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -5787,11 +5888,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: z31.object({
+    input: z32.object({
       operation_id: operationIdArg,
       params,
-      idempotency_key: z31.string().min(8).max(255).describe("Unique per change; reuse it to retry or to fetch the result."),
-      if_match: z31.string().max(200).optional().describe("ETag from plan_change, for operations that need it.")
+      idempotency_key: z32.string().min(8).max(255).describe("Unique per change; reuse it to retry or to fetch the result."),
+      if_match: z32.string().max(200).optional().describe("ETag from plan_change, for operations that need it.")
     }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
@@ -5852,7 +5953,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: z31.object({ approval_id: z31.guid().describe("approval_id from apply_change.") }),
+    input: z32.object({ approval_id: z32.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)
@@ -5872,10 +5973,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: z31.object({
-      query: z31.string().min(1).max(200),
-      locale: z31.enum(["en", "vi"]).default("en"),
-      limit: z31.number().int().min(1).max(10).default(5)
+    input: z32.object({
+      query: z32.string().min(1).max(200),
+      locale: z32.enum(["en", "vi"]).default("en"),
+      limit: z32.number().int().min(1).max(10).default(5)
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -5891,9 +5992,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: z31.object({
-      slug: z31.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
-      locale: z31.enum(["en", "vi"]).default("en")
+    input: z32.object({
+      slug: z32.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
+      locale: z32.enum(["en", "vi"]).default("en")
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -6087,7 +6188,7 @@ function findToken(env = process.env, keychain = keychainToken) {
 }
 
 // packages/mcp/src/cli.ts
-var PACKAGE_VERSION = "0.6.0";
+var PACKAGE_VERSION = "0.7.1";
 var HELP = `belvador-mcp ${PACKAGE_VERSION} — Belvador MCP server (stdio)
 
 Usage: npx -y @belvador/mcp [--toolsets=${MCP_DEFAULT_TOOLSETS.join(",")}]