@belvador/mcp 0.7.1 → 0.8.0

package/dist/cli.js

@@ -96,47 +96,6 @@ var API_LIMITS = {
 };
 var idempotencyKeySchema = z.string().min(API_LIMITS.idempotencyKeyMin).max(API_LIMITS.idempotencyKeyMax).regex(/^[\x21-\x7e]+$/);
 var pageLimitSchema = z.coerce.number().int().min(1).max(API_LIMITS.pageMax).default(API_LIMITS.pageDefault);
-var API_ERROR_STATUS = {
-  API_CREDENTIAL_INVALID: 401,
-  API_SCOPE_INSUFFICIENT: 403,
-  API_FORBIDDEN: 403,
-  APPROVAL_REQUIRED: 403,
-  APPROVAL_EXPIRED: 410,
-  APPROVAL_REJECTED: 403,
-  APPROVAL_PARAMS_MISMATCH: 409,
-  APPROVAL_OUTCOME_UNKNOWN: 409,
-  IDEMPOTENCY_KEY_REUSED: 422,
-  IDEMPOTENCY_IN_PROGRESS: 409,
-  PRECONDITION_REQUIRED: 428,
-  PRECONDITION_FAILED: 412,
-  QUERY_WINDOW_REQUIRED: 400,
-  QUERY_WINDOW_TOO_LARGE: 400,
-  CURSOR_INVALID: 400,
-  NODE_OFFLINE: 503,
-  TOKEN_LIMIT: 409,
-  TOKEN_LIFETIME_INVALID: 400,
-  SCOPE_UNKNOWN: 400,
-  OAUTH_CLIENT_INVALID: 400,
-  MONITOR_SELECTOR_INVALID: 400,
-  OCCURRENCE_DUE_INVALID: 400,
-  OCCURRENCE_LIMIT: 409,
-  MAINTENANCE_INVALID: 400,
-  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,
-  NODE_BUSY: 429,
-  QUERY_TIMEOUT: 422
-};
-var API_ERROR_CODES = Object.keys(API_ERROR_STATUS);
 var API_ORIGIN = "https://api.belvador.dev";
 var PROTECTED_RESOURCE_METADATA_URL = `${API_ORIGIN}/.well-known/oauth-protected-resource`;
 var createCredentialInputSchema = z.object({
@@ -255,7 +214,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 z32 } from "zod";
+import { z as z34 } from "zod";
 
 // ../src/shared/contracts/api-ops/access.ts
 import { z as z3 } from "zod";
@@ -1215,9 +1174,14 @@ import { z as z12 } from "zod";
 import { z as z10 } from "zod";
 
 // ../src/shared/contracts/vocab/telemetry.ts
+var SEVERITIES = ["trace", "debug", "info", "warn", "error", "fatal"];
+var TRACE_ID_RE = /^[0-9a-f]{32}$/;
+var SPAN_ID_RE = /^[0-9a-f]{16}$/;
 var TELEMETRY_MAX_WINDOW_MS = 7 * 24 * 3600 * 1000;
 var ATTR_OPS = ["=", "!=", "exists"];
 var ATTR_FILTERS_MAX = 5;
+var ATTR_KEY_RE = /^[A-Za-z0-9_.:\-/@]{1,256}$/;
+var LOG_BUILTIN_FACETS = ["service", "severity", "environment"];
 var TELEMETRY_PLAN_DEFAULTS = {
   traces_retention_days: 7,
   logs_retention_days: 7,
@@ -1666,7 +1630,7 @@ var NUMERIC_OPS = new Set(["lt", "le", "gt", "ge"]);
 var VALUELESS_OPS = new Set(["exists", "not_exists"]);
 var COMPARATORS = ["lt", "gt", "outside"];
 var MISSING_DATA_POLICIES = ["alert", "keep", "resolve", "treat_as_zero"];
-var SEVERITIES = ["critical", "high", "medium", "low"];
+var SEVERITIES2 = ["critical", "high", "medium", "low"];
 var OCCURRENCE_STATES = [
   "pending",
   "in_progress",
@@ -1755,7 +1719,7 @@ 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: z12.enum(SEVERITIES),
+  severity: z12.enum(SEVERITIES2),
   recovery_threshold: recovery
 };
 var countSettingsSchema = z12.object({
@@ -1957,7 +1921,7 @@ var incidentRuleInputSchema = z14.object({
   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),
+  minSeverity: z14.enum(SEVERITIES2),
   groupBy: z14.enum(INCIDENT_GROUP_BY),
   windowMinutes: z14.number().int().min(5).max(240),
   recoveryHoldMinutes: z14.number().int().min(0).max(1440)
@@ -2092,6 +2056,7 @@ var INCIDENT_OPERATIONS = [
     input: I.workspace,
     workspace: true,
     idempotency: "none",
+    paged: true,
     mcp: "investigate",
     summary: "Rules that turn alerts into incidents: match, grouping, window and recovery wait.",
     ui: []
@@ -2137,6 +2102,7 @@ var INCIDENT_OPERATIONS = [
     input: I.workspace,
     workspace: true,
     idempotency: "none",
+    paged: true,
     mcp: "investigate",
     summary: "Notification policies: quiet hours, digest, fallback chain and escalation.",
     ui: []
@@ -3158,7 +3124,7 @@ var MONITOR_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/node-data.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../src/shared/contracts/release-health.ts
 import { z as z21 } from "zod";
@@ -3416,8 +3382,310 @@ var fixStatusSchema = z21.object({
   verify_hours: z21.number()
 });
 
-// ../src/shared/contracts/web-vitals.ts
+// ../src/shared/contracts/telemetry.ts
 import { z as z22 } from "zod";
+var TELEMETRY_SIGNALS = ["traces", "logs", "metrics"];
+var TELEMETRY_EDGE_REASONS = [
+  "accepted",
+  "rate_limited",
+  "over_quota",
+  "too_large",
+  "unsupported",
+  "buffer_full",
+  "expired",
+  "auth"
+];
+var TELEMETRY_NODE_REASONS = [
+  "accepted",
+  "malformed",
+  "out_of_window",
+  "scope",
+  "dropped_attributes",
+  "truncated",
+  "evicted_early",
+  "unsupported_type",
+  "cardinality_limited",
+  "sdk_delivery"
+];
+var TELEMETRY_REASONS = [
+  ...TELEMETRY_EDGE_REASONS,
+  ...TELEMETRY_NODE_REASONS.filter((r) => r !== "accepted")
+];
+var TELEMETRY_LIMITS = {
+  edgeBufferNodeMaxBytes: 512 * 1024 * 1024,
+  edgeBufferMetricsMaxBytes: 64 * 1024 * 1024,
+  drainShareWhileErrorsWait: 0.5,
+  nodeSpoolMaxBytes: 1024 * 1024 * 1024,
+  nodeSpoolMaxAgeMs: 30 * 60 * 1000,
+  nodeOverloadRatio: 0.85,
+  diskBudgetRatio: 0.3,
+  diskShareMetrics: 0.1,
+  diskSplitTracesDefault: 0.5,
+  diskSplitMin: 0.2,
+  diskSplitMax: 0.8,
+  diskCheckIntervalMs: 5 * 60 * 1000,
+  servicesPerProject: 200,
+  serviceNameMaxChars: 128,
+  keyUsedReportMs: 60 * 60 * 1000
+};
+var TELEMETRY_QUERY = {
+  maxWindowMs: TELEMETRY_MAX_WINDOW_MS,
+  spansDefaultWindowMs: 3600 * 1000,
+  logsDefaultWindowMs: 15 * 60 * 1000,
+  substringMaxWindowMs: 15 * 60 * 1000,
+  spansPageSize: 100,
+  logsPageSize: 200,
+  logsPageMaxBytes: 2 * 1024 * 1024,
+  waterfallMaxSpans: 1e4,
+  waterfallMaxBytes: 8 * 1024 * 1024,
+  waterfallFallbackWindowMs: 15 * 60 * 1000,
+  histogramMaxBuckets: 300,
+  facetsMaxValues: 50,
+  facetsMaxKeys: 5,
+  aroundMaxRows: 100,
+  aroundWindowMs: 5 * 60 * 1000,
+  attrFiltersMax: ATTR_FILTERS_MAX,
+  timeBudgetMs: {
+    waterfall: 1000,
+    spans: 1500,
+    logs: 1000,
+    histogram: 1000,
+    facets: 500,
+    around: 500
+  },
+  maxMemoryBytes: 256 * 1024 * 1024,
+  maxThreads: 2,
+  busyWaitMs: 2000,
+  issueLogsWindowMs: 2 * 60 * 1000
+};
+var INCOMPLETE_REASONS = ["time_budget", "row_cap", "byte_cap", "window"];
+var SPAN_KINDS = [
+  "unspecified",
+  "internal",
+  "server",
+  "client",
+  "producer",
+  "consumer"
+];
+var SPAN_STATUSES = ["unset", "ok", "error"];
+var SOURCE_PROTOCOLS = ["otlp", "sentry_log"];
+var traceId = z22.string().regex(TRACE_ID_RE);
+var spanId = z22.string().regex(SPAN_ID_RE);
+var optSpanId = z22.union([spanId, z22.literal("")]);
+var ts2 = z22.string().max(40);
+var count3 = z22.coerce.number().int().nonnegative().catch(0);
+var label2 = z22.string().max(256);
+var attrValue = z22.lazy(() => z22.union([
+  z22.string().max(70000),
+  z22.number(),
+  z22.boolean(),
+  z22.null(),
+  z22.array(attrValue).max(256),
+  z22.record(z22.string(), attrValue)
+]));
+var attrs = z22.record(z22.string().max(256), attrValue).catch({});
+var spanRowSchema = z22.object({
+  project_id: z22.number().int().positive(),
+  trace_id: traceId,
+  span_id: spanId,
+  parent_span_id: optSpanId,
+  service: label2,
+  operation: z22.string().max(1024),
+  kind: z22.enum(SPAN_KINDS).catch("unspecified"),
+  status: z22.enum(SPAN_STATUSES).catch("unset"),
+  start: ts2,
+  duration_ns: z22.coerce.number().nonnegative().catch(0),
+  environment: z22.string().max(64).catch("")
+});
+var traceSummarySchema = z22.object({
+  project_id: z22.number().int().positive(),
+  trace_id: traceId,
+  root_service: label2.catch(""),
+  root_operation: z22.string().max(1024).catch(""),
+  has_root: z22.boolean().catch(false),
+  start: ts2,
+  duration_ns: z22.coerce.number().nonnegative().catch(0),
+  spans: count3,
+  errors: count3,
+  services: count3,
+  environment: z22.string().max(64).catch("")
+});
+var completeness2 = {
+  complete: z22.boolean(),
+  reason: z22.enum(INCOMPLETE_REASONS).optional().catch(undefined)
+};
+var spanListSchema = z22.object({
+  mode: z22.enum(["spans", "traces"]),
+  spans: z22.array(spanRowSchema).max(TELEMETRY_QUERY.spansPageSize).catch([]),
+  traces: z22.array(traceSummarySchema).max(TELEMETRY_QUERY.spansPageSize).catch([]),
+  next_cursor: z22.string().max(512).nullable(),
+  ...completeness2
+});
+var spanHistogramSchema = z22.object({
+  bucket_ms: z22.number().int().positive(),
+  buckets: z22.array(z22.object({
+    t: ts2,
+    spans: count3,
+    errors: count3,
+    p50_ns: z22.coerce.number().nonnegative().catch(0),
+    p95_ns: z22.coerce.number().nonnegative().catch(0)
+  })).max(TELEMETRY_QUERY.histogramMaxBuckets),
+  ...completeness2
+});
+var spanEventSchema = z22.object({
+  time: ts2,
+  name: z22.string().max(1024),
+  attributes: attrs
+});
+var spanLinkSchema = z22.object({ trace_id: traceId, span_id: spanId, attributes: attrs });
+var spanDetailSchema = spanRowSchema.extend({
+  status_message: z22.string().max(4096).catch(""),
+  trace_state: z22.string().max(512).catch(""),
+  scope_name: z22.string().max(256).catch(""),
+  scope_version: z22.string().max(64).catch(""),
+  attributes: attrs,
+  resource: attrs,
+  events: z22.array(spanEventSchema).max(128).catch([]),
+  links: z22.array(spanLinkSchema).max(128).catch([]),
+  dropped_attributes_count: count3,
+  dropped_events_count: count3,
+  dropped_links_count: count3,
+  sampling_probability: z22.number().min(0).max(1).nullable().catch(null)
+});
+var waterfallSchema = z22.object({
+  trace_id: traceId,
+  spans: z22.array(spanDetailSchema).max(TELEMETRY_QUERY.waterfallMaxSpans),
+  missing_parents: z22.array(spanId).max(TELEMETRY_QUERY.waterfallMaxSpans).catch([]),
+  errors: z22.array(z22.object({
+    project_id: z22.number().int().positive(),
+    event_id: z22.string().regex(/^[0-9a-f]{32}$/),
+    span_id: optSpanId.catch(""),
+    issue_id: z22.number().int().positive(),
+    title: z22.string().max(2000).catch(""),
+    ts: ts2
+  })).max(200).catch([]),
+  log_counts: z22.record(spanId, count3).catch({}),
+  ...completeness2
+});
+var traceBriefSchema = z22.object({
+  trace_id: traceId,
+  spans: count3,
+  errors: count3,
+  start: ts2.nullable(),
+  end: ts2.nullable()
+});
+var BODY_KINDS = ["string", "json", "empty"];
+var logRowSchema = z22.object({
+  log_id: z22.guid(),
+  project_id: z22.number().int().positive(),
+  ts: ts2,
+  observed_ts: ts2.catch(""),
+  service: label2,
+  environment: z22.string().max(64).catch(""),
+  severity_number: z22.number().int().min(0).max(24).catch(0),
+  severity_text: z22.string().max(32).catch(""),
+  body: z22.string().max(70000).catch(""),
+  body_kind: z22.enum(BODY_KINDS).catch("string"),
+  trace_id: z22.union([traceId, z22.literal("")]).catch(""),
+  span_id: optSpanId.catch(""),
+  event_name: z22.string().max(256).catch(""),
+  scope_name: z22.string().max(256).catch(""),
+  source_protocol: z22.enum(SOURCE_PROTOCOLS).catch("otlp"),
+  attributes: attrs,
+  resource: attrs
+});
+var logListSchema = z22.object({
+  logs: z22.array(logRowSchema).max(TELEMETRY_QUERY.logsPageSize),
+  next_cursor: z22.string().max(512).nullable(),
+  ...completeness2
+});
+var logHistogramSchema = z22.object({
+  bucket_ms: z22.number().int().positive(),
+  buckets: z22.array(z22.object({
+    t: ts2,
+    counts: z22.partialRecord(z22.enum([...SEVERITIES, "unspecified"]), count3).catch({})
+  })).max(TELEMETRY_QUERY.histogramMaxBuckets),
+  ...completeness2
+});
+var logFacetsSchema = z22.object({
+  facets: z22.array(z22.object({
+    key: z22.string().max(256),
+    values: z22.array(z22.object({ value: z22.string().max(512), count: count3 })).max(TELEMETRY_QUERY.facetsMaxValues),
+    estimated: z22.boolean().catch(false)
+  })).max(TELEMETRY_QUERY.facetsMaxKeys),
+  ...completeness2
+});
+var telemetryUsageSchema = z22.object({
+  days: z22.array(z22.object({
+    day: z22.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    signal: z22.enum(TELEMETRY_SIGNALS),
+    reason: z22.enum(TELEMETRY_REASONS),
+    records: count3,
+    bytes: count3
+  })).max(31 * TELEMETRY_SIGNALS.length * TELEMETRY_REASONS.length),
+  retention_effective_days: z22.object({
+    traces: z22.number().int().nonnegative(),
+    logs: z22.number().int().nonnegative(),
+    metrics: z22.number().int().nonnegative().optional()
+  }),
+  disk: z22.object({
+    budget_bytes: count3,
+    traces_bytes: count3,
+    logs_bytes: count3,
+    metrics_bytes: count3.optional(),
+    traces_share: z22.number().min(0).max(1)
+  }).nullable().catch(null)
+});
+var SIGNAL_STALE_MS = 24 * 3600 * 1000;
+var sdkLabel = z22.string().max(64);
+var serviceSeenSchema = z22.object({
+  project_id: z22.number().int().positive(),
+  environment: z22.string().max(64),
+  service_name: z22.string().max(TELEMETRY_LIMITS.serviceNameMaxChars),
+  sdk_language: sdkLabel,
+  sdk_name: sdkLabel,
+  sdk_version: sdkLabel,
+  signals: z22.array(z22.enum(TELEMETRY_SIGNALS)).min(1).max(TELEMETRY_SIGNALS.length),
+  first_seen: z22.number().int().positive(),
+  last_seen: z22.number().int().positive()
+});
+var servicesSeenReportSchema = z22.object({
+  project_id: z22.number().int().positive(),
+  services: z22.array(serviceSeenSchema.omit({ project_id: true })).max(TELEMETRY_LIMITS.servicesPerProject)
+});
+var telemetryUsageReportSchema = z22.object({
+  project_id: z22.number().int().positive(),
+  day: z22.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  rows: z22.array(z22.object({
+    signal: z22.enum(TELEMETRY_SIGNALS),
+    reason: z22.enum(TELEMETRY_REASONS),
+    records: z22.number().int().nonnegative(),
+    bytes: z22.number().int().nonnegative()
+  })).max(TELEMETRY_SIGNALS.length * TELEMETRY_REASONS.length),
+  retention_effective_days: z22.object({
+    traces: z22.number().int().nonnegative(),
+    logs: z22.number().int().nonnegative(),
+    metrics: z22.number().int().nonnegative().optional()
+  }).optional()
+});
+var ingestKeyUsedSchema = z22.object({
+  key_id: z22.guid(),
+  project_id: z22.number().int().positive(),
+  used_at: z22.string().datetime()
+});
+var telemetryReceiptSchema = z22.object({
+  project_id: z22.number().int().positive(),
+  verification_id: z22.string().regex(/^bv1_[0-9a-f]{32}$/),
+  signal: z22.enum(TELEMETRY_SIGNALS),
+  environment: z22.string().max(64),
+  service_name: z22.string().max(TELEMETRY_LIMITS.serviceNameMaxChars),
+  sdk_name: sdkLabel,
+  sdk_version: sdkLabel,
+  received_at: z22.string().datetime()
+});
+
+// ../src/shared/contracts/web-vitals.ts
+import { z as z23 } from "zod";
 
 // ../src/shared/contracts/vocab/web-vitals.ts
 var WEB_VITAL_NAMES = ["LCP", "INP", "CLS", "FCP", "TTFB"];
@@ -3436,214 +3704,222 @@ var WEB_VITAL_LIMITS = {
   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(),
+var ratingCounts = z23.object({
+  good: z23.number().int().nonnegative(),
+  needs_improvement: z23.number().int().nonnegative(),
+  poor: z23.number().int().nonnegative()
+});
+var webVitalSummarySchema = z23.object({
+  name: z23.enum(WEB_VITAL_NAMES),
+  metric: z23.string(),
+  unit: z23.enum(["ms", "1"]),
+  samples: z23.number().int().nonnegative(),
+  p75: z23.number().nullable(),
+  rating: z23.enum(WEB_VITAL_RATINGS).nullable(),
+  estimate: z23.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()
+  distribution: z23.array(z23.object({ le: z23.number().nullable(), count: z23.number().int().nonnegative() })),
+  routes: z23.array(z23.object({
+    path: z23.string(),
+    samples: z23.number().int().nonnegative(),
+    p75: z23.number().nullable(),
+    rating: z23.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() }))
+  routes_total: z23.number().int().nonnegative(),
+  attribution: z23.array(z23.object({ target: z23.string(), samples: z23.number().int().nonnegative(), p75: z23.number().nullable() }))
 });
-var webVitalsSummarySchema = z22.object({
-  from: z22.string(),
-  to: z22.string(),
-  path: z22.string().nullable(),
-  vitals: z22.array(webVitalSummarySchema),
-  complete: z22.boolean()
+var webVitalsSummarySchema = z23.object({
+  from: z23.string(),
+  to: z23.string(),
+  path: z23.string().nullable(),
+  vitals: z23.array(webVitalSummarySchema),
+  complete: z23.boolean()
 });
 
 // ../src/shared/contracts/api-ops/node-data.ts
-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 issueId = z24.number().int().positive();
+var csv = z24.string().min(1).max(2000);
+var projectIds2 = z24.string().max(2000).regex(/^[1-9][0-9]{0,15}(?:,[1-9][0-9]{0,15}){0,99}$/, "comma-separated project ids");
+var name2 = z24.string().min(1).max(256);
+var period = z24.enum(["1h", "24h", "7d", "14d", "30d"]);
+var nodeCursor = z24.string().min(1).max(600).optional();
 var windowFields = {
-  start: z23.string().max(40).optional(),
-  end: z23.string().max(40).optional()
+  start: z24.string().max(40).optional(),
+  end: z24.string().max(40).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 traceId2 = z24.string().regex(/^[0-9a-fA-F]{32}$/);
+var spanId2 = z24.string().regex(/^[0-9a-fA-F]{16}$/);
+var attrs2 = z24.string().max(2000).optional();
+var facetKey = ATTR_KEY_RE.source.slice(1, -1);
+var facetKeysRe = new RegExp(`^${facetKey}(?:,${facetKey}){0,${TELEMETRY_QUERY.facetsMaxKeys - 1}}$`);
 var telemetryCommon = {
   ...windowFields,
   project: projectIds2.optional(),
   environment: csv.optional(),
   service: csv.optional(),
-  attrs
+  attrs: attrs2
 };
-var issueChange = z23.union([
-  z23.object({
-    action: z23.literal("resolve"),
-    inNextRelease: z23.boolean().optional(),
+var issueChange = z24.union([
+  z24.object({
+    action: z24.literal("resolve"),
+    inNextRelease: z24.boolean().optional(),
     inRelease: releaseNameSchema.optional()
   }),
-  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"]) })
+  z24.object({ action: z24.literal("unresolve") }),
+  z24.object({ action: z24.literal("archive"), mode: z24.enum(["until_escalating", "forever"]) }),
+  z24.object({
+    action: z24.literal("archive"),
+    mode: z24.literal("until_condition"),
+    events: z24.number().int().min(1).max(1e6).optional(),
+    users: z24.number().int().min(1).max(1e5).optional(),
+    until: z24.string().datetime().optional()
+  }),
+  z24.object({ action: z24.literal("assign"), userId: z24.guid().nullable() }),
+  z24.object({ action: z24.literal("priority"), priority: z24.enum(["low", "medium", "high"]) })
 ]);
 var NODE_INPUTS = {
-  issuesList: z23.object({
+  issuesList: z24.object({
     project: projectIds2.optional(),
-    status: z23.enum(["unresolved", "resolved", "archived", "all"]).optional(),
+    status: z24.enum(["unresolved", "resolved", "archived", "all"]).optional(),
     level: csv.optional(),
     priority: csv.optional(),
     environment: csv.optional(),
     release: csv.optional(),
-    assignee: z23.string().max(64).optional(),
+    assignee: z24.string().max(64).optional(),
     period: period.optional(),
-    q: z23.string().max(200).optional(),
-    sort: z23.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
+    q: z24.string().max(200).optional(),
+    sort: z24.enum(["last_seen", "first_seen", "events", "users", "priority"]).optional(),
     cursor: nodeCursor,
-    limit: z23.number().int().min(1).max(100).optional()
+    limit: z24.number().int().min(1).max(100).optional()
   }),
-  issue: z23.object({ issueId }),
-  issueStats: z23.object({ issueId, range: z23.enum(["24h", "30d"]).optional() }),
-  issueEvents: z23.object({ issueId, cursor: nodeCursor }),
-  issueEvent: z23.object({
+  issue: z24.object({ issueId }),
+  issueStats: z24.object({ issueId, range: z24.enum(["24h", "30d"]).optional() }),
+  issueEvents: z24.object({ issueId, cursor: nodeCursor }),
+  issueEvent: z24.object({
     issueId,
-    eventId: z23.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
+    eventId: z24.string().regex(/^([0-9a-f]{32}|latest|oldest)$/)
   }),
-  issueUpdate: z23.object({ issueId, change: issueChange }),
-  issuesBulk: z23.object({
-    issueIds: z23.array(issueId).min(1).max(100),
+  issueUpdate: z24.object({ issueId, change: issueChange }),
+  issuesBulk: z24.object({
+    issueIds: z24.array(issueId).min(1).max(100),
     action: issueChange
   }),
-  spansList: z23.object({
+  spansList: z24.object({
     ...telemetryCommon,
-    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(),
+    operation: z24.string().min(1).max(1024).optional(),
+    status: z24.enum(["unset", "ok", "error"]).optional(),
+    kind: z24.enum(["internal", "server", "client", "producer", "consumer"]).optional(),
+    minDurationMs: z24.number().min(0).max(86400000).optional(),
+    maxDurationMs: z24.number().min(0).max(86400000).optional(),
+    mode: z24.enum(["spans", "traces"]).optional(),
     cursor: nodeCursor
   }),
-  spansHistogram: z23.object({
+  spansHistogram: z24.object({
     ...telemetryCommon,
-    operation: z23.string().min(1).max(1024).optional(),
-    status: z23.enum(["unset", "ok", "error"]).optional()
+    operation: z24.string().min(1).max(1024).optional(),
+    status: z24.enum(["unset", "ok", "error"]).optional()
   }),
-  trace: z23.object({ traceId }),
-  traceSpans: z23.object({ traceId, errorsOnly: z23.enum(["1"]).optional(), ...windowFields }),
-  span: z23.object({ traceId, spanId, ...windowFields }),
-  logsList: z23.object({
+  trace: z24.object({ traceId: traceId2 }),
+  traceSpans: z24.object({ traceId: traceId2, errorsOnly: z24.enum(["1"]).optional(), ...windowFields }),
+  span: z24.object({ traceId: traceId2, spanId: spanId2, ...windowFields }),
+  logsList: z24.object({
     ...telemetryCommon,
-    severityMin: z23.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
-    traceId: traceId.optional(),
-    spanId: spanId.optional(),
-    q: z23.string().max(500).optional(),
-    order: z23.enum(["asc", "desc"]).optional(),
+    severityMin: z24.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    traceId: traceId2.optional(),
+    spanId: spanId2.optional(),
+    q: z24.string().max(500).optional(),
+    order: z24.enum(["asc", "desc"]).optional(),
     cursor: nodeCursor
   }),
-  logsFacets: z23.object({
+  logsHistogram: z24.object({
     ...telemetryCommon,
-    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(),
+    severityMin: z24.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    q: z24.string().max(500).optional()
+  }),
+  logsFacets: z24.object({
+    ...telemetryCommon,
+    severityMin: z24.enum(["trace", "debug", "info", "warn", "error", "fatal"]).optional(),
+    q: z24.string().max(500).optional(),
+    keys: z24.string().regex(facetKeysRe, `up to ${TELEMETRY_QUERY.facetsMaxKeys} comma-separated keys`).default(LOG_BUILTIN_FACETS.join(","))
+  }),
+  logAround: z24.object({
+    logId: z24.guid(),
+    at: z24.string().max(40),
+    same: z24.enum(["service", "trace"]).optional(),
+    before: z24.number().int().min(0).max(200).optional(),
+    after: z24.number().int().min(0).max(200).optional()
+  }),
+  metricsNames: z24.object({
+    project: z24.number().int().positive(),
     environment: csv.optional(),
-    q: z23.string().max(255).optional()
+    q: z24.string().max(255).optional()
   }),
-  metricsSeries: z23.object({
-    project: z23.number().int().positive(),
-    name: z23.string().regex(METRIC_NAME_RE),
+  metricsSeries: z24.object({
+    project: z24.number().int().positive(),
+    name: z24.string().regex(METRIC_NAME_RE),
     environment: csv.optional(),
-    attrs,
-    cursor: z23.string().regex(/^[0-9a-f]{16}$/).optional()
+    attrs: attrs2,
+    cursor: z24.string().regex(/^[0-9a-f]{16}$/).optional()
   }),
-  metricsQuery: z23.object({
-    project: z23.number().int().positive(),
-    name: z23.string().regex(METRIC_NAME_RE),
-    aggregation: z23.enum(METRIC_AGGREGATIONS),
+  metricsQuery: z24.object({
+    project: z24.number().int().positive(),
+    name: z24.string().regex(METRIC_NAME_RE),
+    aggregation: z24.enum(METRIC_AGGREGATIONS),
     ...windowFields,
-    step: z23.number().int().min(METRIC_QUERY.minStepSeconds).max(METRIC_QUERY.maxStepSeconds).multipleOf(60).optional(),
-    attrs,
-    groupBy: z23.string().min(1).max(600).optional(),
+    step: z24.number().int().min(METRIC_QUERY.minStepSeconds).max(METRIC_QUERY.maxStepSeconds).multipleOf(60).optional(),
+    attrs: attrs2,
+    groupBy: z24.string().min(1).max(600).optional(),
     environment: csv.optional()
   }),
-  telemetryUsage: z23.object({
+  telemetryUsage: z24.object({
     project: projectIds2.optional(),
-    days: z23.number().int().min(1).max(31).optional()
+    days: z24.number().int().min(1).max(31).optional()
   }),
-  monitorSignal: z23.object({
-    monitorId: z23.guid(),
-    hours: z23.number().int().min(1).max(24).optional()
+  monitorSignal: z24.object({
+    monitorId: z24.guid(),
+    hours: z24.number().int().min(1).max(24).optional()
   }),
-  monitorOccurrences: z23.object({
-    monitorId: z23.guid(),
-    state: z23.enum(["open", "finished", "all"]).optional(),
-    environment: z23.string().min(1).max(64).optional(),
+  monitorOccurrences: z24.object({
+    monitorId: z24.guid(),
+    state: z24.enum(["open", "finished", "all"]).optional(),
+    environment: z24.string().min(1).max(64).optional(),
     cursor: nodeCursor
   }),
-  monitorBacktest: z23.object({
-    project: z23.number().int().positive(),
+  monitorBacktest: z24.object({
+    project: z24.number().int().positive(),
     settings: backtestSettingsSchema
   }),
-  occurrenceCreate: z23.object({
-    project: z23.number().int().positive(),
+  occurrenceCreate: z24.object({
+    project: z24.number().int().positive(),
     monitorSlug: occurrenceInputSchema.shape.monitor_slug,
     occurrenceId: occurrenceInputSchema.shape.occurrence_id,
     dueAt: occurrenceInputSchema.shape.due_at,
     environment: occurrenceInputSchema.shape.environment
   }),
-  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()
+  occurrenceCancel: z24.object({
+    project: z24.number().int().positive(),
+    monitorSlug: z24.string().regex(SLUG_RE),
+    occurrenceId: z24.string().regex(OCCURRENCE_ID_RE),
+    environment: z24.string().min(1).max(64).optional()
   }),
-  webVitals: z23.object({
-    project: z23.number().int().positive(),
+  webVitals: z24.object({
+    project: z24.number().int().positive(),
     ...windowFields,
     environment: csv.optional(),
-    path: z23.string().max(WEB_VITAL_LIMITS.pathMaxChars).regex(/^(?:\/[^\s?#]*|other)$/).optional()
+    path: z24.string().max(WEB_VITAL_LIMITS.pathMaxChars).regex(/^(?:\/[^\s?#]*|other)$/).optional()
   }),
-  releasesList: z23.object({
-    project: z23.number().int().positive(),
+  releasesList: z24.object({
+    project: z24.number().int().positive(),
     environment: environmentNameSchema.optional()
   }),
-  releaseHealth: z23.object({
-    project: z23.number().int().positive(),
+  releaseHealth: z24.object({
+    project: z24.number().int().positive(),
     version: releaseNameSchema,
     environment: environmentNameSchema.optional(),
     compare: releaseNameSchema.optional()
   }),
-  deploymentCreate: z23.object({
-    project: z23.number().int().positive(),
+  deploymentCreate: z24.object({
+    project: z24.number().int().positive(),
     version: deploymentInputSchema.shape.version,
     environment: deploymentInputSchema.shape.environment,
     name: deploymentInputSchema.shape.name,
@@ -3652,10 +3928,10 @@ var NODE_INPUTS = {
     finishedAt: deploymentInputSchema.shape.finished_at,
     deployId: deploymentInputSchema.shape.deploy_id
   }),
-  ticket: z23.object({
-    scope: z23.enum(["read", "write"]).default("read"),
-    project: z23.number().int().positive().optional(),
-    environment: z23.string().min(1).max(64).optional()
+  ticket: z24.object({
+    scope: z24.enum(["read", "write"]).default("read"),
+    project: z24.number().int().positive().optional(),
+    environment: z24.string().min(1).max(64).optional()
   })
 };
 var N = NODE_INPUTS;
@@ -3740,7 +4016,7 @@ var NODE_OPERATIONS = [
     path: "/v1/spans",
     scope: "traces:read",
     input: N.spansList,
-    node: { path: "q/spans", list: "spans", window: true },
+    node: { path: "q/spans", list: "spans", modeLists: ["traces"], window: true },
     paged: true,
     summary: "Spans (or whole traces with `mode=traces`) in a window of at most 7 days."
   }),
@@ -3795,7 +4071,7 @@ var NODE_OPERATIONS = [
     id: "logs.histogram",
     path: "/v1/logs/histogram",
     scope: "logs:read",
-    input: N.logsFacets,
+    input: N.logsHistogram,
     node: { path: "q/logs/histogram", window: true },
     summary: "Log counts by severity over a window."
   }),
@@ -3992,10 +4268,10 @@ var NODE_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/privacy.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../src/shared/contracts/privacy.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // ../src/shared/privacy/rules.ts
 var PRIVACY_SCHEMA = 1;
@@ -4026,46 +4302,46 @@ var REMOVE = Symbol("remove");
 
 // ../src/shared/contracts/privacy.ts
 var PRIVACY_KEY_MAX_VERSION = 1e6;
-var ruleId = z24.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
-var privacyRuleInputSchema = z24.object({
+var ruleId = z25.string().regex(/^[A-Za-z0-9_-]{1,64}$/);
+var privacyRuleInputSchema = z25.object({
   id: ruleId,
-  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()
+  selector: z25.string().min(1).max(PRIVACY_LIMITS.selector),
+  type: z25.enum(PRIVACY_RULE_TYPES),
+  method: z25.enum(PRIVACY_METHODS),
+  pattern: z25.string().min(1).max(PRIVACY_LIMITS.pattern).optional(),
+  ignoreCase: z25.boolean().optional(),
+  replaceWith: z25.string().max(PRIVACY_LIMITS.replaceWith).optional(),
+  enabled: z25.boolean().optional()
+});
+var privacyPolicyInputSchema = z25.object({
+  mode: z25.enum(PRIVACY_MODES),
+  rules: z25.array(privacyRuleInputSchema).max(PRIVACY_LIMITS.rules),
+  allowlist: z25.array(z25.string().min(1).max(PRIVACY_LIMITS.selector)).max(PRIVACY_LIMITS.allowlist)
+});
+var storedPolicySchema = z25.object({
+  schema: z25.literal(PRIVACY_SCHEMA),
+  version: z25.number().int().min(0),
+  mode: z25.enum(PRIVACY_MODES),
+  rules: z25.array(z25.record(z25.string(), z25.unknown())).max(PRIVACY_LIMITS.rules),
+  allowlist: z25.array(z25.string()).max(PRIVACY_LIMITS.allowlist)
+});
+var nodePrivacyBlockSchema = z25.array(z25.object({ project_id: z25.number().int().positive(), policy: z25.unknown() })).max(1000);
+var privacyRollupSchema = z25.object({
+  applied_version: z25.number().int().min(0).nullable(),
+  policy_missing_24h: z25.number().int().nonnegative(),
+  budget_exceeded_24h: z25.number().int().nonnegative(),
+  sdk_versions: z25.array(z25.object({ version: z25.number().int().min(0), last_seen_at: z25.string().datetime() })).max(5),
+  key_version: z25.number().int().min(1).max(PRIVACY_KEY_MAX_VERSION).optional(),
+  key_created_at: z25.string().datetime().nullable().optional()
 });
 
 // ../src/shared/contracts/api-ops/privacy.ts
 var PRIVACY_INPUTS = {
-  get: z25.object({ workspaceId: uuid, projectId }),
-  set: z25.object({
+  get: z26.object({ workspaceId: uuid, projectId }),
+  set: z26.object({
     workspaceId: uuid,
     projectId,
-    expectedVersion: z25.number().int().min(0),
+    expectedVersion: z26.number().int().min(0),
     policy: privacyPolicyInputSchema
   })
 };
@@ -4105,105 +4381,109 @@ var PRIVACY_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/projects.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // ../src/shared/contracts/ingest-keys.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var INGEST_KEY_SCOPES = ["traces", "logs", "metrics", "errors", "monitors"];
 var INGEST_KEY_STATES = ["active", "revoked"];
 var INGEST_KEY_LIMITS = {
   nameMaxChars: 80,
   environmentsMax: 20,
   environmentMaxChars: 64,
-  edgeCacheSeconds: 60
+  revocationSeconds: 60,
+  publishIntervalSeconds: 10,
+  kvCacheTtlSeconds: 30,
+  isolateCacheSeconds: 15
 };
+var INGEST_KEY_REVOCATION_WORST_SECONDS = INGEST_KEY_LIMITS.publishIntervalSeconds + INGEST_KEY_LIMITS.kvCacheTtlSeconds + INGEST_KEY_LIMITS.isolateCacheSeconds;
 var CHECKIN_AUTH_MODES = ["public_or_key", "key_only"];
-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(),
+var ingestKeyConfigSchema = z27.object({
+  v: z27.literal(1),
+  key_id: z27.guid(),
+  project_public_id: z27.number().int().positive(),
+  project_id: z27.number().int().positive(),
+  workspace_id: z27.guid(),
   node_id: nodeIdSchema,
-  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()
+  scopes: z27.array(z27.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z27.array(z27.string().max(INGEST_KEY_LIMITS.environmentMaxChars)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expires_at: z27.string().datetime({ offset: true }).nullable(),
+  state: z27.enum(INGEST_KEY_STATES),
+  workspace_status: z27.enum(["active", "suspended", "deleting"]),
+  ingest_kill: z27.boolean(),
+  telemetry_kill: z27.boolean(),
+  telemetry_rate_bytes_per_sec: z27.number().int().positive(),
+  telemetry_burst_bytes: z27.number().int().positive(),
+  traces_monthly_bytes: z27.number().int().positive(),
+  logs_monthly_bytes: z27.number().int().positive(),
+  metrics_monthly_bytes: z27.number().int().positive().optional(),
+  telemetry_buffer_minutes: z27.number().int().min(1).max(1440),
+  revision: z27.number().int().nonnegative()
+});
+var createIngestKeyInputSchema = z27.object({
+  projectId: z27.number().int().positive(),
+  name: z27.string().trim().min(1).max(INGEST_KEY_LIMITS.nameMaxChars).refine((s) => !/[\u0000-\u001f\u007f]/.test(s)),
+  scopes: z27.array(z27.enum(INGEST_KEY_SCOPES)).min(1).max(INGEST_KEY_SCOPES.length),
+  environments: z27.array(z27.string().trim().min(1).max(INGEST_KEY_LIMITS.environmentMaxChars).regex(/^[^\s/\u0000-\u001f]+$/)).max(INGEST_KEY_LIMITS.environmentsMax),
+  expiresAt: z27.string().datetime({ offset: true }).nullable()
+});
+var ingestKeyRowSchema = z27.object({
+  id: z27.guid(),
+  project_id: z27.number().int().positive(),
+  name: z27.string(),
+  prefix: z27.string(),
+  scopes: z27.array(z27.enum(INGEST_KEY_SCOPES)),
+  environments: z27.array(z27.string()),
+  expires_at: z27.string().nullable(),
+  state: z27.enum(INGEST_KEY_STATES),
+  created_by: z27.guid().nullable(),
+  created_at: z27.string(),
+  revoked_at: z27.string().nullable(),
+  last_used_at: z27.string().nullable()
 });
 
 // ../src/shared/contracts/node-config.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // ../src/shared/contracts/backup.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var BACKUP_KINDS = ["daily", "weekly", "manual", "pre_upgrade"];
-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),
+var ageRecipient = z28.string().regex(/^age1[02-9ac-hj-np-z]{58}$/);
+var backupIdSchema = z28.string().regex(/^[a-z0-9-]{8,64}$/);
+var nodeBackupConfigSchema = z28.object({
+  enabled: z28.boolean(),
+  hour_utc: z28.number().int().min(0).max(23),
+  weekly_day: z28.number().int().min(1).max(7),
   workspace_recipient: ageRecipient
 });
-var backupCredentialsRequestSchema = z27.object({
-  mode: z27.enum(["upload", "download"]),
+var backupCredentialsRequestSchema = z28.object({
+  mode: z28.enum(["upload", "download"]),
   backup_id: backupIdSchema,
-  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),
+  source_node_id: z28.guid().optional()
+});
+var backupCredentialsSchema = z28.object({
+  endpoint: z28.string().url(),
+  bucket: z28.string().regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/),
+  prefix: z28.string().regex(/^backups\/[0-9a-f-]{36}\/$/),
+  access_key_id: z28.string().min(8).max(200),
+  secret_access_key: z28.string().min(8).max(200),
+  session_token: z28.string().min(8).max(4000),
+  expires_at: z28.string().datetime()
+});
+var rowCountsSchema = z28.record(z28.string().regex(/^[a-z_][a-z0-9_]{0,63}$/), z28.number().int().nonnegative());
+var backupManifestSchema = z28.object({
+  v: z28.literal(1),
   backup_id: backupIdSchema,
-  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(),
+  node_id: z28.guid(),
+  kind: z28.enum(BACKUP_KINDS),
+  created_at: z28.string().datetime(),
+  object_key: z28.string(),
+  size_bytes: z28.number().int().nonnegative(),
+  sha256: z28.string().regex(/^[0-9a-f]{64}$/),
+  clickhouse_version: z28.string().max(40),
+  schema_version: z28.number().int().nonnegative(),
   row_counts: rowCountsSchema,
-  recipients: z27.array(z27.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
+  recipients: z28.array(z28.string().regex(/^[0-9a-f]{8}$/)).min(1).max(4)
 });
 var BACKUP_ERROR_CODES = [
   "CLICKHOUSE_BACKUP_FAILED",
@@ -4217,51 +4497,51 @@ var BACKUP_ERROR_CODES = [
   "RESTORE_FAILED",
   "ROW_COUNT_MISMATCH"
 ];
-var backupReportSchema = z27.object({
+var backupReportSchema = z28.object({
   backup_id: backupIdSchema,
-  kind: z27.enum(BACKUP_KINDS),
-  status: z27.enum(["succeeded", "failed"]),
-  started_at: z27.string().datetime(),
-  finished_at: z27.string().datetime(),
+  kind: z28.enum(BACKUP_KINDS),
+  status: z28.enum(["succeeded", "failed"]),
+  started_at: z28.string().datetime(),
+  finished_at: z28.string().datetime(),
   manifest: backupManifestSchema.nullable(),
-  error_code: z27.enum(BACKUP_ERROR_CODES).nullable()
+  error_code: z28.enum(BACKUP_ERROR_CODES).nullable()
 });
-var drillReportSchema = z27.object({
+var drillReportSchema = z28.object({
   backup_id: backupIdSchema,
-  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()
+  kind: z28.enum(["weekly_local", "monthly_new_machine"]),
+  status: z28.enum(["passed", "failed"]),
+  finished_at: z28.string().datetime(),
+  detail: z28.string().max(300),
+  error_code: z28.enum(BACKUP_ERROR_CODES).nullable()
 });
-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}$/)
+var nodeIdentityEscrowSchema = z28.object({
+  v: z28.literal(1),
+  node_id: z28.guid(),
+  seal: z28.object({
+    publicKey: z28.string().regex(/^[A-Za-z0-9_-]{43}$/),
+    privateKey: z28.string().regex(/^[A-Za-z0-9_-]{43}$/)
   }),
-  created_at: z27.string().datetime()
+  created_at: z28.string().datetime()
 });
-var restoreArgsSchema = z27.object({
-  job_id: z27.guid(),
-  workspace_id: z27.guid(),
-  source_node_id: z27.guid(),
+var restoreArgsSchema = z28.object({
+  job_id: z28.guid(),
+  workspace_id: z28.guid(),
+  source_node_id: z28.guid(),
   manifest: backupManifestSchema,
-  sealed_identity: z27.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
-  mode: z27.enum(["rebuild", "drill"])
+  sealed_identity: z28.string().regex(/^[A-Za-z0-9_-]{40,2000}$/),
+  mode: z28.enum(["rebuild", "drill"])
 });
-var restoreReportSchema = z27.object({
-  job_id: z27.guid(),
+var restoreReportSchema = z28.object({
+  job_id: z28.guid(),
   backup_id: backupIdSchema,
-  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()
+  mode: z28.enum(["rebuild", "drill"]),
+  status: z28.enum(["succeeded", "failed"]),
+  finished_at: z28.string().datetime(),
+  detail: z28.string().max(300),
+  error_code: z28.enum(BACKUP_ERROR_CODES).nullable()
 });
 
-// ../src/shared/contracts/node-config.ts
+// ../src/shared/contracts/vocab/node-config.ts
 var SCRUB_GROUPS = [
   "credentials",
   "cards",
@@ -4271,86 +4551,88 @@ var SCRUB_GROUPS = [
   "user_id",
   "headers"
 ];
+
+// ../src/shared/contracts/node-config.ts
 var MAX_NODE_MONITORS = 5000;
-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()
+var kid = z29.string().regex(/^[A-Za-z0-9_-]{1,40}$/);
+var publicKey = z29.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var nodeConfigSchema = z29.object({
+  v: z29.literal(1),
+  config_version: z29.number().int().positive(),
+  node_id: z29.guid(),
+  workspace_id: z29.guid(),
+  workspace_status: z29.enum(["active", "suspended"]),
+  issued_at: z29.string().datetime(),
+  retention_days: z29.number().int().min(1).max(3650),
+  channel: z29.enum(["stable", "canary"]).optional(),
+  projects: z29.array(z29.object({
+    project_id: z29.number().int().positive(),
+    slug: z29.string().max(64),
+    short_prefix: z29.string().regex(/^[A-Z0-9]{1,12}$/),
+    user_id_salt: z29.string().regex(/^[A-Za-z0-9_-]{22,64}$/),
+    privacy_key_version: z29.number().int().min(1).max(PRIVACY_KEY_MAX_VERSION).optional(),
+    scrub_disabled: z29.array(z29.enum(SCRUB_GROUPS)).max(SCRUB_GROUPS.length),
+    upload_tokens: z29.array(z29.object({
+      hash: z29.string().regex(/^[a-f0-9]{64}$/),
+      expires_at: z29.string().datetime(),
+      scopes: z29.array(z29.enum(UPLOAD_SCOPES)).min(1).max(UPLOAD_SCOPES.length).optional()
     })).max(10).optional()
   })).max(1000),
-  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() }),
+  ticket_keys: z29.array(z29.object({ kid, public_key: publicKey, not_after: z29.string().datetime() })).min(1).max(5),
+  control_ops_keys: z29.array(z29.object({ kid, public_key: publicKey })).min(1).max(5),
+  kill_switches: z29.object({ ingest: z29.boolean(), alerts: z29.boolean() }),
   backup: nodeBackupConfigSchema.optional(),
-  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)
+  purged_projects: z29.array(z29.number().int().positive()).max(1000).optional(),
+  monitors: z29.array(monitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  purged_monitors: z29.array(z29.guid()).max(5000).optional(),
+  telemetry: z29.object({
+    traces_retention_days: z29.number().int().min(1).max(90),
+    logs_retention_days: z29.number().int().min(1).max(90),
+    traces_disk_share: z29.number().min(0.2).max(0.8)
   }).optional(),
   metrics: metricsConfigSchema.optional(),
-  slos: z28.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
-  signal_monitors: z28.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
+  slos: z29.array(nodeSloSchema).max(SLO_LIMITS.maxNodeSlos).optional(),
+  signal_monitors: z29.array(signalMonitorDefinitionSchema).max(MAX_NODE_MONITORS).optional(),
   signal_limits: signalLimitsConfigSchema.optional(),
   privacy: nodePrivacyBlockSchema.optional()
 });
-var signedNodeConfigSchema = z28.object({ config: nodeConfigSchema, kid, sig: z28.string() });
+var signedNodeConfigSchema = z29.object({ config: nodeConfigSchema, kid, sig: z29.string() });
 
 // ../src/shared/contracts/api-ops/projects.ts
-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 slug = z30.string().regex(/^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/);
+var name3 = z30.string().trim().min(1).max(60);
+var label3 = z30.string().trim().min(1).max(40);
+var platform = z30.enum(PLATFORMS);
+var origin = z30.string().trim().toLowerCase().regex(/^https?:\/\/[a-z0-9.-]+(:[0-9]{1,5})?$/).max(200);
+var keyId = z30.number().int().positive();
 var PROJECT_INPUTS = {
-  create: z29.object({ workspaceId: uuid, name: name3, slug, platform }),
-  update: z29.object({ projectId, name: name3, platform, isPinned: z29.boolean() }),
-  updateIntake: z29.object({
+  create: z30.object({ workspaceId: uuid, name: name3, slug, platform }),
+  update: z30.object({ projectId, name: name3, platform, isPinned: z30.boolean() }),
+  updateIntake: z30.object({
     projectId,
-    rateLimit: z29.number().int().positive().nullable(),
-    burst: z29.number().int().positive().nullable(),
-    allowedOrigins: z29.array(origin).max(50)
+    rateLimit: z30.number().int().positive().nullable(),
+    burst: z30.number().int().positive().nullable(),
+    allowedOrigins: z30.array(origin).max(50)
   }),
-  updateObservability: z29.object({
+  updateObservability: z30.object({
     projectId,
-    primaryEnvironment: z29.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
-    allowCodeMonitors: z29.boolean()
+    primaryEnvironment: z30.string().trim().min(1).max(64).refine((v) => v !== "*" && ENVIRONMENT_RE.test(v)),
+    allowCodeMonitors: z30.boolean()
   }),
-  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({
+  setScrub: z30.object({ projectId, group: z30.enum(SCRUB_GROUPS), enabled: z30.boolean() }),
+  setCheckinAuth: z30.object({ projectId, mode: z30.enum(CHECKIN_AUTH_MODES) }),
+  setEnvironmentHidden: z30.object({
     projectId,
-    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 }),
+    name: z30.string().min(1).max(64),
+    hidden: z30.boolean()
+  }),
+  scheduleDeletion: z30.object({ projectId, confirmSlug: slug }),
+  projectOnly: z30.object({ projectId }),
+  labelled: z30.object({ projectId, label: label3 }),
+  keyOnly: z30.object({ keyId }),
+  tokenOnly: z30.object({ tokenId: keyId }),
   createIngestKey: createIngestKeyInputSchema,
-  ingestKeyOnly: z29.object({ keyId: uuid })
+  ingestKeyOnly: z30.object({ keyId: uuid })
 };
 var P2 = PROJECT_INPUTS;
 var PROJECT_OPERATIONS = [
@@ -4605,24 +4887,24 @@ var PROJECT_OPERATIONS = [
 ];
 
 // ../src/shared/contracts/api-ops/reads.ts
-import { z as z30 } from "zod";
-var list = z30.object({ workspaceId: uuid, limit: pageLimit, cursor });
+import { z as z31 } from "zod";
+var list = z31.object({ workspaceId: uuid, limit: pageLimit, cursor });
 var READ_INPUTS = {
-  workspace: z30.object({ workspaceId: uuid }),
+  workspace: z31.object({ workspaceId: uuid }),
   list,
-  projectsGet: z30.object({ workspaceId: uuid, projectId }),
+  projectsGet: z31.object({ workspaceId: uuid, projectId }),
   monitorsList: list.extend({ projectId: projectId.optional() }),
-  monitorsGet: z30.object({ workspaceId: uuid, monitorId: uuid }),
-  uptimeGet: z30.object({ workspaceId: uuid, checkId: uuid }),
-  slosGet: z30.object({ workspaceId: uuid, sloId: uuid }),
+  monitorsGet: z31.object({ workspaceId: uuid, monitorId: uuid }),
+  uptimeGet: z31.object({ workspaceId: uuid, checkId: uuid }),
+  slosGet: z31.object({ workspaceId: uuid, sloId: uuid }),
   alertsList: list.extend({
-    state: z30.enum(["open", "resolved", "all"]).default("all"),
+    state: z31.enum(["open", "resolved", "all"]).default("all"),
     monitorId: uuid.optional()
   }),
-  approvalsGet: z30.object({ workspaceId: uuid, approvalId: uuid }),
+  approvalsGet: z31.object({ workspaceId: uuid, approvalId: uuid }),
   monitorsListTyped: list.extend({
     projectId: projectId.optional(),
-    type: z30.enum(MONITOR_TYPES).optional()
+    type: z31.enum(MONITOR_TYPES).optional()
   })
 };
 var R = READ_INPUTS;
@@ -4905,15 +5187,18 @@ function approvalRequestSchema(operationId, input) {
   return input.omit(Object.fromEntries(human.map((k) => [k, true])));
 }
 
+// ../src/shared/contracts/api-ops/openapi.ts
+import { z as z33 } from "zod";
+
 // ../src/shared/contracts/api-ops/wire.ts
-import { z as z31 } from "zod";
+import { z as z32 } 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 = z31.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
+    js = z32.toJSONSchema(op.input, { io: "input", unrepresentable: "any" });
     schemaCache.set(op.input, js);
   }
   return js;
@@ -5127,7 +5412,7 @@ function wireInput(operationId, opts = {}) {
   for (const [k, v] of Object.entries(op.input.shape))
     if (!omit.has(k))
       shape[toSnake(k)] = v;
-  return z32.object(shape);
+  return z34.object(shape);
 }
 var BUDGETS = [
   { stringBytes: MCP_LIMITS.untrustedStringMaxBytes, listMax: MCP_LIMITS.listMax },
@@ -5220,52 +5505,52 @@ function errorResult(o) {
     }
   };
 }
-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())
+var TOOL_OUTPUT_SCHEMA = z34.object({
+  untrusted: z34.object({
+    data: z34.unknown(),
+    provenance: z34.object({
+      source: z34.enum(["node", "control_plane", "docs"]),
+      operations: z34.array(z34.string())
     })
   }).optional(),
-  doc: z32.object({
-    slug: z32.string(),
-    locale: z32.enum(["en", "vi"]),
-    url: z32.string(),
-    markdown: z32.string(),
-    truncated: z32.boolean()
+  doc: z34.object({
+    slug: z34.string(),
+    locale: z34.enum(["en", "vi"]),
+    url: z34.string(),
+    markdown: z34.string(),
+    truncated: z34.boolean()
   }).optional(),
-  results: z32.array(z32.object({
-    slug: z32.string(),
-    title: z32.string(),
-    description: z32.string(),
-    section: z32.string(),
-    url: z32.string()
+  results: z34.array(z34.object({
+    slug: z34.string(),
+    title: z34.string(),
+    description: z34.string(),
+    section: z34.string(),
+    url: z34.string()
   })).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()
+  next_cursor: z34.string().nullable().optional(),
+  complete: z34.boolean().optional(),
+  omitted: z34.array(z34.object({ part: z34.string(), reason: z34.string(), scope: z34.string().optional() })).optional(),
+  truncated: z34.literal(true).optional(),
+  suspicious_unicode: z34.literal(true).optional(),
+  error: z34.object({
+    code: z34.string(),
+    status: z34.number(),
+    detail: z34.string().optional(),
+    scope: z34.string().optional(),
+    retry_after: z34.number().optional()
   }).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()
+  operations: z34.array(z34.record(z34.string(), z34.unknown())).optional(),
+  operation: z34.record(z34.string(), z34.unknown()).optional(),
+  plan: z34.record(z34.string(), z34.unknown()).optional(),
+  status: z34.enum(["done", "approval_required", "approval_pending", ...APPROVAL_STATES]).optional(),
+  approval: z34.object({
+    approval_id: z34.string(),
+    approval_url: z34.string(),
+    expires_at: z34.string(),
+    state: z34.enum(APPROVAL_STATES),
+    result_code: z34.string().nullable().optional(),
+    result: z34.record(z34.string(), z34.unknown()).optional(),
+    next: z34.string().optional()
   }).optional()
 });
 var spec = (name) => {
@@ -5311,10 +5596,10 @@ var has = (rt, operationId) => {
   return !!op && rt.scopes.includes(op.scope);
 };
 var isoWindow = {
-  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.")
+  start: z34.string().max(40).describe("RFC 3339 start of the window, e.g. 2026-10-26T00:00:00Z. Required with end."),
+  end: z34.string().max(40).describe("RFC 3339 end of the window. The plan limits its length.")
 };
-var traceIdSchema = z32.string().regex(/^[0-9a-fA-F]{32}$/);
+var traceIdSchema = z34.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" },
@@ -5378,8 +5663,8 @@ function describe(op, scopes) {
     destructive: isDestructiveOperation(op)
   };
 }
-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`.");
+var params = z34.record(z34.string(), z34.unknown()).default({}).describe("Operation fields in wire names (snake_case), as describe_operation's args_schema shows.");
+var operationIdArg = z34.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,
@@ -5399,7 +5684,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: z32.object({}),
+    input: z34.object({}),
     async run(_args, rt) {
       const [ws, node] = await Promise.all([rt.call("workspace.get", {}), rt.call("node.get", {})]);
       if (!ws.ok)
@@ -5421,9 +5706,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: z32.object({
-      issue_id: z32.number().int().positive().describe("Issue id from search_issues."),
-      include_latest_event: z32.boolean().default(true)
+    input: z34.object({
+      issue_id: z34.number().int().positive().describe("Issue id from search_issues."),
+      include_latest_event: z34.boolean().default(true)
     }),
     async run(args, rt) {
       const omitted = [];
@@ -5464,9 +5749,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: z32.object({
+    input: z34.object({
       trace_id: traceIdSchema.describe("W3C trace id, 32 hex characters."),
-      spans: z32.enum(["none", "errors", "all"]).default("none")
+      spans: z34.enum(["none", "errors", "all"]).default("none")
     }),
     async run(args, rt) {
       const sum = await rt.call("traces.get", { trace_id: args["trace_id"] });
@@ -5498,17 +5783,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: 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(),
+    input: z34.object({
+      project: z34.number().int().positive().describe("Numeric project id from list_projects."),
+      name: z34.string().regex(METRIC_NAME_RE).optional().describe("Metric name from the catalog, e.g. http.server.request.duration."),
+      q: z34.string().max(255).optional().describe("Catalog only: part of a metric name."),
+      aggregation: z34.enum(METRIC_AGGREGATIONS).optional(),
       start: isoWindow.start.optional(),
       end: isoWindow.end.optional(),
-      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.")
+      step: z34.number().int().min(60).max(86400).multipleOf(60).optional().describe("Seconds per point (whole minutes); picked from the window when absent."),
+      attrs: z34.string().max(2000).optional(),
+      group_by: z34.string().max(600).optional(),
+      environment: z34.string().max(2000).optional().describe("Comma-separated environments.")
     }),
     async run(args, rt) {
       const scope = {
@@ -5563,8 +5848,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: z32.object({
-      project: z32.number().int().positive().describe("Numeric project id from list_projects."),
+    input: z34.object({
+      project: z34.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.")
@@ -5596,11 +5881,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: z32.object({
+    input: z34.object({
       trace_id: traceIdSchema.optional(),
-      run_id: z32.string().min(1).max(128).optional(),
+      run_id: z34.string().min(1).max(128).optional(),
       ...isoWindow,
-      project: z32.string().max(2000).optional().describe("Comma-separated project ids.")
+      project: z34.string().max(2000).optional().describe("Comma-separated project ids.")
     }),
     async run(args, rt) {
       const trace = args["trace_id"];
@@ -5659,10 +5944,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: 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)
+    input: z34.object({
+      kind: z34.enum(["all", "cron", "uptime", "slo"]).default("all"),
+      project_id: z34.number().int().positive().optional(),
+      limit: z34.number().int().min(1).max(200).default(50)
     }),
     async run(args, rt) {
       const kinds = args["kind"] && args["kind"] !== "all" ? [args["kind"]] : ["cron", "uptime", "slo"];
@@ -5697,10 +5982,10 @@ var MCP_TOOL_DEFS = [
       "monitors.occurrences",
       "monitors.backtest"
     ],
-    input: z32.object({
-      kind: z32.enum(["cron", "uptime", "slo"]),
-      id: z32.guid(),
-      backtest: z32.boolean().default(false)
+    input: z34.object({
+      kind: z34.enum(["cron", "uptime", "slo"]),
+      id: z34.guid(),
+      backtest: z34.boolean().default(false)
     }),
     async run(args, rt) {
       const k = MONITOR_KINDS2[args["kind"]];
@@ -5760,9 +6045,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: z32.object({
-      project_id: z32.number().int().positive(),
-      idempotency_key: z32.string().min(8).max(255).optional()
+    input: z34.object({
+      project_id: z34.number().int().positive(),
+      idempotency_key: z34.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() });
@@ -5780,9 +6065,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: 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)
+    input: z34.object({
+      query: z34.string().min(1).max(200).describe("Words such as `rotate dsn key`, `heartbeat monitor`, `slack alert`."),
+      limit: z34.number().int().min(1).max(20).default(10)
     }),
     async run(args, rt) {
       const q = words(String(args["query"]));
@@ -5810,7 +6095,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: z32.object({ operation_id: operationIdArg }),
+    input: z34.object({ operation_id: operationIdArg }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -5839,7 +6124,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: z32.object({ operation_id: operationIdArg, params }),
+    input: z34.object({ operation_id: operationIdArg, params }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
       if (!op || op.method === "GET")
@@ -5888,11 +6173,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: z32.object({
+    input: z34.object({
       operation_id: operationIdArg,
       params,
-      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.")
+      idempotency_key: z34.string().min(8).max(255).describe("Unique per change; reuse it to retry or to fetch the result."),
+      if_match: z34.string().max(200).optional().describe("ETag from plan_change, for operations that need it.")
     }),
     async run(args, rt) {
       const op = configureOp(args["operation_id"]);
@@ -5953,7 +6238,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: z32.object({ approval_id: z32.guid().describe("approval_id from apply_change.") }),
+    input: z34.object({ approval_id: z34.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)
@@ -5973,10 +6258,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: 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)
+    input: z34.object({
+      query: z34.string().min(1).max(200),
+      locale: z34.enum(["en", "vi"]).default("en"),
+      limit: z34.number().int().min(1).max(10).default(5)
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -5992,9 +6277,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: z32.object({
-      slug: z32.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
-      locale: z32.enum(["en", "vi"]).default("en")
+    input: z34.object({
+      slug: z34.string().regex(/^[a-z0-9][a-z0-9/-]{0,120}$/),
+      locale: z34.enum(["en", "vi"]).default("en")
     }),
     async run(args, rt) {
       const locale = args["locale"] ?? "en";
@@ -6188,7 +6473,7 @@ function findToken(env = process.env, keychain = keychainToken) {
 }
 
 // packages/mcp/src/cli.ts
-var PACKAGE_VERSION = "0.7.1";
+var PACKAGE_VERSION = "0.8.0";
 var HELP = `belvador-mcp ${PACKAGE_VERSION} — Belvador MCP server (stdio)
 
 Usage: npx -y @belvador/mcp [--toolsets=${MCP_DEFAULT_TOOLSETS.join(",")}]