saturndocs 0.1.0

package/dist/chunk-GYRVGWDM.js

@@ -0,0 +1,3499 @@
+// ../management-client/dist/index.js
+import { z as z3 } from "zod";
+import { z as z22 } from "zod";
+import { z as z32 } from "zod";
+
+// ../owner-contract/dist/index.js
+import { z as z2 } from "zod";
+
+// ../control-abi/dist/index.js
+var HOSTNAME_TRANSITIONS = Object.freeze({ unclaimed: Object.freeze(["claimed"]), claimed: Object.freeze(["unclaimed"]) });
+var OWNER_NOTIFICATION_EVENTS = [
+  "suggestion_created",
+  "suggestion_published",
+  "analysis_failed",
+  "release_failed",
+  /** A revision the reviewer asked for, or a hand edit, is back in the queue (#151, #154). */
+  "revision_landed",
+  /** An open question the agent raised has gone unanswered for long enough that the session nudged (F-12.13). */
+  "question_unanswered"
+];
+var OWNER_NOTIFICATION_MODES = ["immediate", "off"];
+var MAX_QUESTION_ID_CHARS = 64;
+var SUGGESTION_DISMISS_REASONS = ["not_needed", "wrong_pages", "inaccurate", "manual", "other"];
+var REQUEST_THREAD_AUTHORS = ["owner", "agent", "platform"];
+var REQUEST_THREAD_KINDS = ["request", "understood", "question", "answer", "draft", "no_change", "failed"];
+var GIT_CONNECTION_TRANSITIONS = Object.freeze({ active: Object.freeze(["broken"]), broken: Object.freeze(["active"]) });
+var GIT_CONNECTION_UNIQUENESS = Object.freeze({ activeSite: ["siteId"], activeSource: ["provider", "installationId", "repositoryId", "branch", "docsRoot"] });
+var DEFAULT_SKIP_LABELS = Object.freeze(["no-docs", "skip-docs"]);
+var DEFAULT_IGNORE_GLOBS = Object.freeze(["**/*.test.*", "**/__tests__/**", "**/*.lock", "**/node_modules/**", ".github/**"]);
+var DEFAULT_SKIP_AUTHORS = Object.freeze(["*[bot]"]);
+var ENFORCEMENT = Object.freeze({ ownership: "d1_transaction", heads: "d1_transaction", hostname: "d1_transaction", gitConnections: "d1_transaction", webhookDeliveries: "d1_transaction", tombstone: "d1_transaction", jobRelations: "d1_transaction", records: "d1_transaction", sourceBlobs: "r2_ordering", releaseObjects: "r2_ordering" });
+
+// ../owner-contract/dist/index.js
+import { z } from "zod";
+var MANAGEMENT_SCOPES = ["manage:read", "manage:write", "manage:approve", "manage:access"];
+var ManagementCredential = z.object({
+  token_id: z.string(),
+  site_id: z.string(),
+  label: z.string(),
+  scopes: z.array(z.enum(MANAGEMENT_SCOPES)),
+  status: z.enum(["active", "revoked", "expired", "inactive"]),
+  issuer: z.string(),
+  parent_token_id: z.string().nullable(),
+  created_at: z.string(),
+  expires_at: z.string(),
+  last_used_at: z.string().nullable()
+});
+var ManagementCredentials = z.object({ site_id: z.string(), credentials: z.array(ManagementCredential) });
+var CreateManagementCredential = z.object({
+  label: z.string().trim().min(1).max(80),
+  scopes: z.array(z.enum(MANAGEMENT_SCOPES)).min(1).max(4).refine((scopes) => new Set(scopes).size === scopes.length, "Permissions must be unique"),
+  expires_at: z.iso.datetime()
+}).strict();
+var IssuedManagementCredential = z.object({ credential: ManagementCredential, token: z.string() });
+var OWNER_PREFIX = "/__gs-portal";
+var MAX_SESSION_EVIDENCE = 20;
+var OWNER_PATHS = {
+  login: `${OWNER_PREFIX}/login`,
+  magicRequest: `${OWNER_PREFIX}/magic/request`,
+  magicVerify: `${OWNER_PREFIX}/magic/verify`,
+  logout: `${OWNER_PREFIX}/logout`,
+  switch: `${OWNER_PREFIX}/switch`,
+  site: `${OWNER_PREFIX}/site`,
+  sites: `${OWNER_PREFIX}/sites`,
+  suggestions: `${OWNER_PREFIX}/suggestions`,
+  suggestion: (id) => `${OWNER_PREFIX}/suggestions/${encodeURIComponent(id)}`,
+  suggestionAction: (id, action) => `${OWNER_PREFIX}/suggestions/${encodeURIComponent(id)}/${action}`,
+  suggestionSession: (id) => `${OWNER_PREFIX}/suggestions/${encodeURIComponent(id)}/session`,
+  suggestionSessionSocket: (id) => `${OWNER_PREFIX}/suggestions/${encodeURIComponent(id)}/session/ws`,
+  requests: `${OWNER_PREFIX}/requests`,
+  requestRetry: (jobId) => `${OWNER_PREFIX}/requests/${encodeURIComponent(jobId)}/retry`,
+  requestThread: (jobId) => `${OWNER_PREFIX}/requests/${encodeURIComponent(jobId)}/thread`,
+  suggestionPreview: (id) => `${OWNER_PREFIX}/suggestions/${encodeURIComponent(id)}/preview`,
+  activity: `${OWNER_PREFIX}/activity`,
+  activitySummary: `${OWNER_PREFIX}/activity/summary`,
+  analytics: `${OWNER_PREFIX}/analytics`,
+  gaps: `${OWNER_PREFIX}/gaps`,
+  gapWork: `${OWNER_PREFIX}/gaps/work`,
+  pages: `${OWNER_PREFIX}/pages`,
+  releases: `${OWNER_PREFIX}/releases`,
+  metrics: `${OWNER_PREFIX}/metrics`,
+  domains: `${OWNER_PREFIX}/domains`,
+  domain: (hostname) => `${OWNER_PREFIX}/domains/${encodeURIComponent(hostname)}`,
+  readers: `${OWNER_PREFIX}/readers`,
+  reader: (entry) => `${OWNER_PREFIX}/readers/${encodeURIComponent(entry)}`,
+  readersRotate: `${OWNER_PREFIX}/readers/rotate`,
+  buildRetry: `${OWNER_PREFIX}/builds/retry`,
+  build: `${OWNER_PREFIX}/builds`,
+  notifications: `${OWNER_PREFIX}/notifications`,
+  owners: `${OWNER_PREFIX}/owners`,
+  owner: (email) => `${OWNER_PREFIX}/owners/${encodeURIComponent(email)}`,
+  settingsProposal: `${OWNER_PREFIX}/settings/proposal`,
+  settingsApprove: `${OWNER_PREFIX}/settings/proposal/approve`,
+  settingsUpdate: `${OWNER_PREFIX}/settings/proposal/update`,
+  settingsGeneral: `${OWNER_PREFIX}/settings/general`,
+  settingsInstructions: `${OWNER_PREFIX}/settings/instructions`,
+  settingsAssistant: `${OWNER_PREFIX}/settings/assistant`,
+  docsRepo: `${OWNER_PREFIX}/docs-repo`,
+  docsRepoReconnect: `${OWNER_PREFIX}/docs-repo/reconnect`,
+  productConnections: `${OWNER_PREFIX}/product-connections`,
+  productConnection: (id) => `${OWNER_PREFIX}/product-connections/${encodeURIComponent(id)}`,
+  productConnectionAction: (id, action) => `${OWNER_PREFIX}/product-connections/${encodeURIComponent(id)}/${action}`,
+  productConnectionAnalyse: (id) => `${OWNER_PREFIX}/product-connections/${encodeURIComponent(id)}/analyse`,
+  githubInstall: `${OWNER_PREFIX}/github/install`,
+  githubSetup: `${OWNER_PREFIX}/github/setup`,
+  githubRepositories: `${OWNER_PREFIX}/github/repositories`,
+  slackInstall: `${OWNER_PREFIX}/slack/install`
+};
+var SESSION_TURN_ID = z2.string().min(1).max(256);
+var SESSION_FRAME_SEQUENCE = z2.number().int().nonnegative();
+var SessionSocketStart = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("start"),
+  turnId: SESSION_TURN_ID,
+  message: z2.string().trim().min(1).max(2e3),
+  questionId: z2.string().trim().min(1).max(128).nullable().optional()
+});
+var SessionSocketResume = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("resume"),
+  turnId: SESSION_TURN_ID,
+  after: SESSION_FRAME_SEQUENCE
+});
+var SessionSocketClientFrame = z2.discriminatedUnion("type", [SessionSocketStart, SessionSocketResume]);
+var SessionEvidence = z2.object({
+  document: z2.string().min(1).max(1e3),
+  title: z2.string().min(1).max(1e3),
+  url: z2.string().min(1).max(4e3)
+});
+var SessionSocketDelta = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("delta"),
+  turnId: SESSION_TURN_ID,
+  seq: SESSION_FRAME_SEQUENCE,
+  text: z2.string().min(1)
+});
+var SessionSocketReset = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("reset"),
+  turnId: SESSION_TURN_ID,
+  seq: SESSION_FRAME_SEQUENCE
+});
+var SessionSocketDone = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("done"),
+  turnId: SESSION_TURN_ID,
+  seq: SESSION_FRAME_SEQUENCE,
+  answer: z2.string().max(2e3),
+  evidence: z2.array(SessionEvidence).max(MAX_SESSION_EVIDENCE),
+  startedRevision: z2.boolean()
+});
+var SessionSocketError = z2.object({
+  v: z2.literal(1),
+  type: z2.literal("error"),
+  turnId: SESSION_TURN_ID,
+  code: z2.enum(["conflict", "invalid", "interrupted", "unavailable"]),
+  retryable: z2.boolean(),
+  message: z2.string()
+});
+var SessionSocketServerFrame = z2.discriminatedUnion("type", [SessionSocketDelta, SessionSocketReset, SessionSocketDone, SessionSocketError]);
+var SUGGESTION_TABS = ["pending", "revising", "published", "dismissed", "failed"];
+var SUGGESTION_ROW_STATES = ["pending_review", "changes_requested", "revising", "publishing", "published", "dismissed", "failed", "superseded"];
+var MERGE_MODES = ["review", "slack_approval", "autonomous"];
+var CONNECTION_STATES = ["active", "paused", "broken"];
+var CONNECTION_BROKEN_REASONS = ["uninstalled", "repository_transferred", "branch_deleted"];
+var INSTALLATION_HEALTH = ["healthy", "stale", "broken"];
+var SKIP_REASONS = ["no_matching_connection", "branch_mismatch", "connection_paused", "connection_broken", "no_watched_paths", "deleted_ref", "bot_author", "skip_label", "invalid_sha"];
+var ACTIVITY_OPERATIONS = ["product_push", "manual_request", "git_push", "rebuild", "bundle_upload"];
+var CONFIDENCES = ["high", "medium", "low"];
+var TRIAGES = ["user_facing", "internal", "unclear"];
+var PAGE_CHANGE_OPS = ["create", "update", "delete"];
+var MAX_REQUEST_CHANGES_NOTE_CHARS = 4e3;
+var MAX_SESSION_MESSAGE_CHARS = 2e3;
+var MAX_INSTRUCTIONS_CHARS = 8e3;
+var isoString = z2.string();
+var nullableString = z2.string().nullable();
+var sha = z2.string().regex(/^[0-9a-f]{40}$/u);
+var ErrorEnvelope = z2.object({
+  error: z2.string(),
+  message: z2.string().optional()
+});
+var ActiveRelease = z2.object({
+  release_id: z2.string(),
+  state: z2.string(),
+  generation: z2.number().int(),
+  activated_at: nullableString
+});
+var LatestJob = z2.object({
+  state: z2.string(),
+  error_code: nullableString,
+  error_message: nullableString,
+  updated_at: isoString
+});
+var UsageMeter = z2.object({ used: z2.number(), limit: z2.number() });
+var PortalUsage = z2.object({
+  analyses_this_month: UsageMeter.optional(),
+  storage_bytes: UsageMeter.optional(),
+  concurrent_jobs: UsageMeter.optional()
+});
+var SlackConnection = z2.object({
+  team_id: z2.string(),
+  channel_id: z2.string(),
+  connected_at: nullableString,
+  // True for a connection installed before the app could read who clicks; every click is refused until Slack is reconnected.
+  needs_reconnect: z2.boolean().optional()
+});
+var Installation = z2.object({
+  installation_id: z2.number().int(),
+  account_login: nullableString,
+  state: z2.string(),
+  last_delivery_at: nullableString,
+  health: z2.enum(INSTALLATION_HEALTH),
+  linked: z2.boolean().optional(),
+  reinstall_url: nullableString
+});
+var DocsRepo = z2.object({
+  installation_id: z2.number().int(),
+  repository_id: z2.number().int(),
+  repository: nullableString,
+  branch: z2.string(),
+  docs_root: z2.string(),
+  state: z2.enum(["active", "broken"]),
+  broken_reason: nullableString
+});
+var ProductConnection = z2.object({
+  connection_id: z2.string(),
+  installation_id: z2.number().int(),
+  repository: nullableString,
+  branch: z2.string(),
+  watch_globs: z2.array(z2.string()),
+  state: z2.enum(CONNECTION_STATES),
+  broken_reason: z2.enum(CONNECTION_BROKEN_REASONS).nullable(),
+  merge_mode: z2.enum(MERGE_MODES),
+  last_event_at: nullableString
+});
+var ProductConnectionRules = ProductConnection.omit({ last_event_at: true }).extend({
+  last_event_at: nullableString.optional(),
+  repository_id: z2.number().int(),
+  ignore_globs: z2.array(z2.string()),
+  skip_authors: z2.array(z2.string()),
+  skip_labels: z2.array(z2.string()),
+  connection_generation: z2.number().int()
+});
+var OWNER_ROLES = ["owner", "viewer"];
+var OwnerRole = z2.enum(OWNER_ROLES);
+var PortalSite = z2.object({
+  site_id: z2.string(),
+  role: OwnerRole.optional(),
+  hostnames: z2.array(z2.string()),
+  active_release: ActiveRelease.nullable(),
+  latest_job: LatestJob.nullable(),
+  latest_authoring_job: LatestJob.nullable().optional(),
+  reader_status: z2.enum(["published", "unpublished", "unknown"]).optional(),
+  connections: z2.array(ProductConnection),
+  docs_repo: DocsRepo.nullable(),
+  installations: z2.array(Installation).optional(),
+  slack: SlackConnection.nullable().optional(),
+  usage: PortalUsage.optional()
+});
+var SiteSummary = z2.object({ site_id: z2.string(), primary_host: z2.string().nullable() });
+var SitesResponse = z2.object({ current: z2.string(), sites: z2.array(SiteSummary) });
+var RationaleEntry = z2.object({ change: z2.string(), affects: z2.array(z2.string()) });
+var PreviewBlock = z2.object({
+  kind: z2.enum(["title", "heading", "text", "code", "callout", "unchanged"]),
+  op: z2.enum(["added", "modified", "removed"]).nullable().optional(),
+  text: z2.string().optional(),
+  subtitle: nullableString.optional(),
+  label: nullableString.optional(),
+  previously: nullableString.optional(),
+  count: z2.number().int().optional()
+});
+var DiffLine = z2.object({
+  op: z2.enum(["context", "add", "del", "skip"]),
+  before_line: z2.number().int().nullable().optional(),
+  after_line: z2.number().int().nullable().optional(),
+  text: z2.string().optional(),
+  count: z2.number().int().optional()
+});
+var PageChange = z2.object({
+  path: z2.string(),
+  op: z2.enum(PAGE_CHANGE_OPS),
+  reason: nullableString.optional(),
+  url: nullableString.optional(),
+  before: nullableString.optional(),
+  after: nullableString.optional(),
+  added_lines: z2.number().int().optional(),
+  removed_lines: z2.number().int().optional(),
+  blocks: z2.array(PreviewBlock).optional(),
+  diff: z2.array(DiffLine).optional(),
+  truncated: z2.boolean().optional()
+});
+var ReferencedPage = z2.object({
+  title: z2.string(),
+  url: z2.string(),
+  note: nullableString.optional(),
+  changed: z2.boolean().optional()
+});
+var ThreadEntry = z2.object({
+  entry_id: z2.string(),
+  kind: z2.enum(["note", "revision", "event"]),
+  author: nullableString.optional(),
+  body: nullableString.optional(),
+  revision: z2.number().int(),
+  created_at: isoString,
+  evidence: z2.array(SessionEvidence).max(MAX_SESSION_EVIDENCE).optional()
+});
+var RevisionEntry = z2.object({
+  n: z2.number().int(),
+  label: z2.string(),
+  sub: nullableString.optional(),
+  current: z2.boolean().optional()
+});
+var Provenance = z2.object({
+  outcome: z2.string(),
+  triage: z2.enum(TRIAGES).nullable().optional(),
+  confidence: z2.enum(CONFIDENCES).nullable().optional(),
+  reason: z2.string(),
+  model: nullableString.optional(),
+  prompt_tokens: z2.number().int().nullable().optional(),
+  completion_tokens: z2.number().int().nullable().optional(),
+  duration_ms: z2.number().int().nullable().optional(),
+  log: z2.array(z2.string()),
+  created_at: isoString,
+  analysis_job_id: nullableString.optional(),
+  analysis_revision: z2.number().int().nullable().optional()
+});
+var SuggestionPublication = z2.object({
+  job_id: z2.string(),
+  state: z2.string(),
+  error_code: nullableString,
+  error_message: nullableString,
+  release_id: nullableString,
+  generation: z2.number().int().nullable(),
+  activated_at: nullableString
+});
+var SuggestionRecord = z2.object({
+  publication: SuggestionPublication.nullable().optional(),
+  request_thread_id: nullableString.optional(),
+  suggestion_id: z2.string(),
+  pr_number: z2.number().int().nullable(),
+  head_branch: z2.string(),
+  base_sha: z2.string(),
+  state: z2.enum(SUGGESTION_ROW_STATES),
+  created_at: isoString,
+  updated_at: isoString,
+  title: nullableString.optional(),
+  summary: nullableString.optional(),
+  repository: nullableString.optional(),
+  repository_id: z2.number().int().nullable().optional(),
+  commit_sha: nullableString.optional(),
+  source_pr_number: z2.number().int().nullable().optional(),
+  request: nullableString.optional(),
+  requested_by: nullableString.optional(),
+  confidence: z2.enum(CONFIDENCES).nullable().optional(),
+  revision: z2.number().int().nullable().optional(),
+  pages_count: z2.number().int().nullable().optional(),
+  first_path: nullableString.optional(),
+  job_id: nullableString.optional(),
+  error_code: nullableString.optional(),
+  error_message: nullableString.optional(),
+  reviewer: nullableString.optional(),
+  head_sha: nullableString.optional(),
+  head_edited_by: nullableString.optional(),
+  files_changed_url: nullableString.optional(),
+  snapshots_available: z2.boolean().optional(),
+  merge_commit_sha: nullableString.optional(),
+  failure_reason: nullableString.optional(),
+  /** Which step failed. A `revision` failure must not offer a merge retry (#360). */
+  failure_kind: z2.enum(["merge", "rebase", "revision", "build"]).nullable().optional(),
+  dismiss_reason: nullableString.optional(),
+  dismiss_note: nullableString.optional(),
+  pages: z2.array(PageChange).optional(),
+  rationale: z2.array(RationaleEntry).optional(),
+  open_questions: z2.array(z2.string()).optional(),
+  questions: z2.array(z2.object({
+    question_id: z2.string(),
+    body: z2.string(),
+    origin: z2.enum(["agent", "verifier", "lint"]),
+    answered_at: isoString.nullable(),
+    answer_entry_id: nullableString,
+    outcome: z2.enum(["talk", "revision"]).nullable()
+  })).optional(),
+  references: z2.array(ReferencedPage).optional(),
+  thread: z2.array(ThreadEntry).optional(),
+  revisions: z2.array(RevisionEntry).optional(),
+  provenance: Provenance.nullable().optional(),
+  merge_mode: z2.enum(MERGE_MODES).nullable().optional()
+});
+var SuggestionCounts = z2.object({
+  pending: z2.number().int(),
+  revising: z2.number().int(),
+  published: z2.number().int(),
+  dismissed: z2.number().int(),
+  failed: z2.number().int()
+});
+var SuggestionsQuery = z2.object({
+  state: z2.enum(SUGGESTION_TABS).default("pending"),
+  cursor: z2.string().optional(),
+  limit: z2.coerce.number().int().positive().optional()
+});
+var SuggestionsPage = z2.object({
+  site_id: z2.string(),
+  state: z2.enum(SUGGESTION_TABS),
+  counts: SuggestionCounts,
+  suggestions: z2.array(SuggestionRecord),
+  next_cursor: nullableString
+});
+var SuggestionDetailResponse = z2.object({ site_id: z2.string(), suggestion: SuggestionRecord });
+var ExpectedHashes = z2.object({
+  expected_base_sha: sha.optional(),
+  expected_head_sha: sha.optional()
+});
+var DismissBody = ExpectedHashes.extend({
+  reason: z2.enum(SUGGESTION_DISMISS_REASONS),
+  note: z2.string().max(MAX_REQUEST_CHANGES_NOTE_CHARS).nullable().optional()
+});
+var RequestChangesBody = z2.object({ note: z2.string().min(1).max(MAX_REQUEST_CHANGES_NOTE_CHARS) });
+var RetryBody = z2.object({});
+var SessionMessageBody = z2.object({
+  message: z2.string().min(1).max(MAX_SESSION_MESSAGE_CHARS),
+  question_id: z2.string().min(1).max(MAX_QUESTION_ID_CHARS).optional()
+});
+var SessionResponse = z2.object({
+  answer: z2.string().min(1).max(2e3),
+  evidence: z2.array(SessionEvidence).max(MAX_SESSION_EVIDENCE),
+  startedRevision: z2.boolean()
+});
+var SuggestionThreadEntry = z2.object({
+  entry_id: z2.string(),
+  kind: z2.string(),
+  author: nullableString,
+  body: z2.string(),
+  revision: z2.number().int(),
+  created_at: isoString,
+  evidence: z2.array(SessionEvidence).max(MAX_SESSION_EVIDENCE).optional()
+});
+var SuggestionThread = z2.object({ entries: z2.array(SuggestionThreadEntry) });
+var ActivityRelease = z2.object({ release_id: z2.string(), generation: z2.number().int().nullable() });
+var ActivityEvent = z2.object({
+  id: z2.string(),
+  operation: z2.enum(ACTIVITY_OPERATIONS),
+  state: z2.string(),
+  outcome_code: nullableString,
+  error_code: nullableString,
+  error_message: nullableString,
+  repository: nullableString,
+  commit_sha: nullableString,
+  commit_message: nullableString,
+  actor: nullableString,
+  suggestion_id: nullableString,
+  pr_number: z2.number().int().nullable(),
+  triage: z2.enum(TRIAGES).nullable().optional(),
+  pages_considered: nullableString.optional(),
+  skip_reason: z2.enum(SKIP_REASONS).nullable().optional(),
+  reason: nullableString.optional(),
+  release: ActivityRelease.nullable().optional(),
+  pusher: nullableString.optional(),
+  created_at: isoString,
+  updated_at: isoString
+});
+var ACTIVITY_OUTCOME_FILTERS = ["suggestion", "nochange", "skipped", "failed", "published"];
+var ActivitySummary = z2.object({ site_id: z2.string(), since: isoString, until: isoString, total: z2.number().int().nonnegative(), counts: z2.record(z2.string(), z2.number().int().nonnegative()) });
+var ActivityQuery = z2.object({
+  outcome: z2.enum(ACTIVITY_OUTCOME_FILTERS).optional(),
+  repo: z2.string().min(1).max(200).optional(),
+  from: z2.iso.date().optional(),
+  to: z2.iso.date().optional(),
+  cursor: z2.string().optional(),
+  limit: z2.coerce.number().int().positive().optional()
+});
+var AnalyticsTotals = z2.object({
+  page_views: z2.number().int().nonnegative(),
+  agent_reads: z2.number().int().nonnegative(),
+  assistant_questions: z2.number().int().nonnegative(),
+  not_found: z2.number().int().nonnegative()
+});
+var AnalyticsResponse = z2.object({
+  site_id: z2.string(),
+  days: z2.union([z2.literal(7), z2.literal(30), z2.literal(90)]),
+  totals: AnalyticsTotals,
+  previous: AnalyticsTotals.nullable(),
+  series: z2.array(z2.object({ day: z2.string(), page_views: z2.number().int().nonnegative(), agent_reads: z2.number().int().nonnegative(), assistant_questions: z2.number().int().nonnegative() })),
+  top_pages: z2.array(z2.object({ path: z2.string(), count: z2.number().int().nonnegative() })),
+  top_missing: z2.array(z2.object({ path: z2.string(), count: z2.number().int().nonnegative() })),
+  ratings: z2.object({ count: z2.number().int().nonnegative(), positive: z2.number().int().nonnegative() }),
+  assistant: z2.object({ answered: z2.number().int().nonnegative(), unanswered: z2.number().int().nonnegative() }).optional(),
+  top_unanswered: z2.array(z2.object({ path: z2.string(), count: z2.number().int().nonnegative() })).optional()
+});
+var GapWork = z2.object({
+  key: z2.string().regex(/^[a-f0-9]{64}$/u),
+  source_key: z2.string().min(1).max(8192),
+  state: z2.enum(["open", "in_progress", "resolved", "ignored"]),
+  classification: z2.enum(["auto", "actionable", "noise"]),
+  note: z2.string().max(2e3),
+  version: z2.number().int().nonnegative(),
+  request_epoch: z2.number().int().nonnegative(),
+  updated_by: z2.string().nullable(),
+  updated_at: z2.string().nullable(),
+  submission_id: z2.string(),
+  request_id: z2.string().nullable()
+});
+var GapWorkWrite = GapWork.pick({ key: true, source_key: true, state: true, classification: true, note: true }).extend({
+  expected_version: z2.number().int().nonnegative(),
+  restart_request: z2.boolean().optional()
+});
+var GapWorkPage = z2.object({ site_id: z2.string(), items: z2.array(GapWork), next_cursor: z2.string().nullable() });
+var GapWorkResponse = z2.object({ site_id: z2.string(), item: GapWork });
+var GapsResponse = z2.object({
+  site_id: z2.string(),
+  days: z2.union([z2.literal(7), z2.literal(30), z2.literal(90)]),
+  /** Whether the edge figures were read; the records below are present either way. */
+  traffic: z2.enum(["ready", "not_configured", "failed"]),
+  /** The most requested addresses first; `_truncated` says more were requested than are shown. */
+  /** @deprecated Missing-address discovery was removed; servers return an empty array. */
+  missing_pages: z2.array(z2.object({ path: z2.string(), hits: z2.number().int().nonnegative(), last_seen: z2.string() })),
+  missing_pages_truncated: z2.boolean(),
+  work: z2.array(GapWork).optional(),
+  /** @deprecated Missing-address classification was removed; servers return an empty array. */
+  scanner_noise: z2.array(z2.object({ path: z2.string(), reason: z2.string() })).optional(),
+  unanswered_next_cursor: z2.string().nullable().optional(),
+  feedback_next_cursor: z2.string().nullable().optional(),
+  ratings_truncated: z2.boolean().optional(),
+  /** `from` is the page of this site readers were observed coming from; a redirect may sit between it and `to`. */
+  broken_links: z2.array(z2.object({ from: z2.string(), to: z2.string(), hits: z2.number().int().nonnegative(), last_seen: z2.string() })),
+  broken_links_truncated: z2.boolean(),
+  unanswered: z2.array(z2.object({ id: z2.string(), path: z2.string(), question: z2.string(), asked_at: z2.string() })),
+  feedback: z2.array(z2.object({ id: z2.string(), path: z2.string(), score: z2.union([z2.literal(0), z2.literal(1)]), comment: nullableString, created_at: z2.string() })),
+  /** Every rating in the range by page, the pages readers found least helpful first. */
+  ratings: z2.array(z2.object({ path: z2.string(), helpful: z2.number().int().nonnegative(), not_helpful: z2.number().int().nonnegative() }))
+});
+var UpdateRequestEvidence = z2.object({
+  gap_source: z2.string().min(1).max(8192).optional(),
+  gap_key: z2.string().regex(/^[a-f0-9]{64}$/u).optional(),
+  gap_epoch: z2.number().int().nonnegative().optional(),
+  kind: z2.enum(["missing_page", "broken_link", "unanswered_question", "page_feedback"]),
+  text: z2.string().min(1).max(1e3),
+  path: z2.string().max(400).nullable()
+});
+var PagesResponse = z2.union([
+  z2.object({ site_id: z2.string(), days: z2.union([z2.literal(7), z2.literal(30), z2.literal(90)]), unavailable: z2.literal("no_release") }),
+  z2.object({
+    site_id: z2.string(),
+    days: z2.union([z2.literal(7), z2.literal(30), z2.literal(90)]),
+    /** `partial` when the edge had more address counts than one answer holds, so some reads are missing from the counts. */
+    traffic: z2.enum(["ready", "partial", "not_configured", "failed"]),
+    release_id: z2.string(),
+    pages: z2.array(z2.object({
+      /** The page's source path in the docs repository, under the pages directory. */
+      path: z2.string(),
+      /** Where readers read it on the site. */
+      url: z2.string(),
+      /** The source on GitHub at the commit the live release was built from; null when the site is not connected that way. */
+      source_url: nullableString,
+      views: z2.number().int().nonnegative(),
+      agent_reads: z2.number().int().nonnegative()
+    }))
+  })
+]);
+var ReleaseRecord = z2.object({
+  release_id: z2.string(),
+  state: z2.string(),
+  built_at: z2.string(),
+  /** The digest of the release's object manifest; null until the build was verified. */
+  digest: nullableString,
+  source_revision_id: z2.string(),
+  git_commit: nullableString,
+  /** When readers last started seeing it, from the activation record; null when it never went live. */
+  activated_at: nullableString,
+  generation: z2.number().int().nullable(),
+  job: z2.object({ job_id: z2.string(), operation: nullableString, commit_sha: nullableString, requested_by: nullableString })
+});
+var ReleasesPage = z2.object({
+  site_id: z2.string(),
+  active_release_id: nullableString,
+  active_release_status: z2.enum(["known", "unknown"]).optional(),
+  releases: z2.array(ReleaseRecord),
+  next_cursor: nullableString
+});
+var UpdateRequestBody = z2.object({
+  submission_id: z2.string().uuid(),
+  request: z2.string().min(1).max(4e3),
+  page: z2.string().max(400).optional(),
+  /** What the site recorded a reader hitting, sent beside the request and kept apart from it: a report, never an instruction. */
+  evidence: UpdateRequestEvidence.optional(),
+  /** The root job of the thread these words answer. Absent starts a new request; a thread not waiting on an answer is refused with `thread_closed`. */
+  thread: z2.string().max(200).optional()
+});
+var UpdateRequestResponse = z2.object({
+  job_id: z2.string(),
+  state: z2.literal("queued")
+});
+var REQUEST_STATES = ["queued", "running", "succeeded", "failed", "timed_out", "cancelled"];
+var RequestRecord = z2.object({
+  job_id: z2.string(),
+  /** The owner's own words, as they were sent. */
+  request: z2.string(),
+  page: nullableString,
+  requested_by: nullableString,
+  state: z2.enum(REQUEST_STATES),
+  outcome_code: nullableString,
+  error_code: nullableString,
+  error_message: nullableString,
+  /** The sentence the agent wrote about this request; null until it has concluded something. */
+  reason: nullableString,
+  suggestion_id: nullableString,
+  pr_number: z2.number().int().nullable(),
+  attempt: z2.number().int().nullable(),
+  /** The job this conversation started with; its own id when the request started one. Rows that share it are one thread. */
+  thread_id: z2.string(),
+  created_at: isoString,
+  updated_at: isoString
+});
+var RequestThreadEntry = z2.object({
+  entry_id: z2.string(),
+  job_id: z2.string(),
+  seq: z2.number().int(),
+  /** Which run of that job wrote the turn. A retry keeps the job's id, so this is the only thing telling two attempts apart. */
+  attempt: z2.number().int(),
+  author: z2.enum(REQUEST_THREAD_AUTHORS),
+  kind: z2.enum(REQUEST_THREAD_KINDS),
+  body: z2.string(),
+  /** Set on a `draft` entry: the suggestion the request produced. */
+  suggestion_id: nullableString,
+  created_at: isoString
+});
+var RequestThreadSummary = z2.object({
+  thread_id: z2.string(),
+  /** The job the conversation started with, whose words name it. */
+  root: RequestRecord,
+  /** The newest job of the thread, whose state and outcome the card reports. */
+  latest: RequestRecord,
+  /** True only while the last turn is a question, which is the one state an owner may reply in. */
+  open: z2.boolean(),
+  /** How many turns the conversation has, including any older than the ones carried here. */
+  turns: z2.number().int().nonnegative(),
+  /** The newest turns, oldest first, with the words that started the thread kept whatever else falls outside. */
+  entries: z2.array(RequestThreadEntry)
+});
+var RequestsPage = z2.object({
+  site_id: z2.string(),
+  /** Newest original request first; replies never move a conversation between pages. */
+  threads: z2.array(RequestThreadSummary),
+  page_cursor: nullableString,
+  next_cursor: nullableString,
+  has_newer: z2.boolean(),
+  /** Every request of this site that failed or timed out, and every conversation waiting on an answer. Read only for a caller that asked for them. */
+  failed: z2.number().int().nonnegative().optional(),
+  waiting: z2.number().int().nonnegative().optional()
+});
+var RequestThread = z2.object({
+  root: RequestRecord,
+  thread_id: z2.string(),
+  site_id: z2.string(),
+  /** Oldest first. */
+  entries: z2.array(RequestThreadEntry),
+  /** True only while the last entry is a question, which is the one state an owner may reply in. */
+  open: z2.boolean(),
+  /** The newest job of the thread, in the listing's own shape. */
+  latest_job: RequestRecord
+});
+var MAX_REQUEST_THREADS = 100;
+var RequestRetryResponse = z2.object({
+  job_id: z2.string(),
+  state: z2.literal("queued"),
+  attempt: z2.number().int().nullable()
+});
+var SuggestionPreviewResponse = z2.object({
+  state: z2.enum(["none", "building", "ready", "failed"]),
+  /** The site's own address with the link's token; the browser that opens it sees the preview for a day. */
+  url: nullableString,
+  /** The address that ends the preview in that browser. */
+  leave_url: nullableString,
+  revision: z2.number().int().nullable(),
+  /** Whether the preview was built for the suggestion's current revision. */
+  current: z2.boolean(),
+  error: nullableString
+});
+var LoopMetricsResponse = z2.object({
+  site_id: z2.string(),
+  days: z2.union([z2.literal(7), z2.literal(30), z2.literal(90)]),
+  opened: z2.number().int().nonnegative(),
+  reviewed: z2.number().int().nonnegative(),
+  published: z2.number().int().nonnegative(),
+  dismissed: z2.number().int().nonnegative(),
+  awaiting_review: z2.number().int().nonnegative(),
+  oldest_awaiting_at: nullableString,
+  median_hours_to_review: z2.number().nonnegative().nullable(),
+  median_hours_to_publish: z2.number().nonnegative().nullable()
+});
+var ActivityPage = z2.object({
+  site_id: z2.string(),
+  events: z2.array(ActivityEvent),
+  next_cursor: nullableString
+});
+var NotificationsResponse = z2.object({
+  site_id: z2.string(),
+  notifications: z2.record(z2.string(), z2.string())
+});
+var NotificationPut = z2.object({
+  event: z2.enum(OWNER_NOTIFICATION_EVENTS),
+  mode: z2.enum(OWNER_NOTIFICATION_MODES)
+});
+var OwnerRow = z2.object({ email: z2.string(), role: OwnerRole.optional(), added_at: isoString, you: z2.boolean() });
+var OwnersResponse = z2.object({ site_id: z2.string(), owners: z2.array(OwnerRow) });
+var OwnerResponse = z2.object({ owner: OwnerRow });
+var AddOwnerBody = z2.object({ email: z2.string().min(3).max(320), role: OwnerRole.optional() });
+var OwnerRoleBody = z2.object({ role: OwnerRole });
+var RemoveOwnerResponse = z2.object({ removed: z2.string(), signed_out: z2.boolean() });
+var PendingSettingsPr = z2.object({ pr_number: z2.number().int(), html_url: z2.string() });
+var LogoValue = z2.union([z2.string(), z2.object({ light: z2.string().optional(), dark: z2.string().optional() })]);
+var RedirectEntry = z2.object({ source: z2.string(), destination: z2.string(), permanent: z2.boolean().optional() });
+var MAX_REDIRECTS = 500;
+var SettingsValues = z2.object({
+  name: nullableString.optional(),
+  colors: z2.object({ primary: nullableString }).optional(),
+  logo: LogoValue.nullable().optional(),
+  favicon: nullableString.optional(),
+  instructions: nullableString.optional(),
+  redirects: z2.array(RedirectEntry).optional(),
+  assistant: z2.object({ greeting: nullableString, suggested_questions: z2.array(z2.string()), instructions: nullableString }).optional()
+});
+var GeneralSettings = SettingsValues.extend({
+  site_id: z2.string(),
+  unavailable: z2.enum(["no_release", "no_repository"]).optional(),
+  revision: z2.string().nullable().optional(),
+  source: z2.enum(["repository", "proposal"]).nullable().optional(),
+  published: SettingsValues.nullable().optional(),
+  docs_repo: z2.object({ repository: nullableString, branch: z2.string(), docs_root: z2.string().optional() }).nullable().optional(),
+  pending_pr: PendingSettingsPr.nullable().optional()
+});
+var MAX_ASSISTANT_GREETING_CHARS = 200;
+var MAX_ASSISTANT_SUGGESTED_QUESTIONS = 6;
+var MAX_ASSISTANT_SUGGESTED_QUESTION_CHARS = 160;
+var MAX_ASSISTANT_INSTRUCTIONS_CHARS = 4e3;
+var BuildOutcome = z2.object({
+  job_id: z2.string(),
+  commit_sha: z2.string(),
+  state: z2.enum(["queued", "running", "retrying"])
+});
+var AnalyseOutcome = z2.object({
+  job_id: z2.string(),
+  commit_sha: z2.string(),
+  before_sha: z2.string(),
+  running: z2.boolean(),
+  /** Where the range starts: after the last analysis, the same range again under other rules, or the head's own parent. */
+  range: z2.enum(["since_last", "same_again", "parent"]).optional()
+});
+var AssistantSettingsBody = z2.object({
+  greeting: z2.string().max(MAX_ASSISTANT_GREETING_CHARS).nullable().optional(),
+  suggested_questions: z2.array(z2.string().max(MAX_ASSISTANT_SUGGESTED_QUESTION_CHARS).refine((question) => !/[\r\n]/u.test(question), { message: "a suggested question is one line" })).max(MAX_ASSISTANT_SUGGESTED_QUESTIONS).nullable().optional(),
+  instructions: z2.string().max(MAX_ASSISTANT_INSTRUCTIONS_CHARS).nullable().optional()
+});
+var GeneralSettingsJsonBody = z2.object({
+  name: z2.string().optional(),
+  primary_color: z2.string().optional(),
+  logo: LogoValue.optional(),
+  favicon: z2.string().optional(),
+  redirects: z2.array(RedirectEntry).max(MAX_REDIRECTS).optional()
+});
+var DOMAIN_STATUSES = ["active", "pending", "unknown"];
+var DomainRecord = z2.object({
+  hostname: z2.string(),
+  kind: z2.enum(["platform", "custom"]),
+  status: z2.enum(DOMAIN_STATUSES),
+  ssl_status: nullableString,
+  errors: z2.array(z2.string())
+});
+var DomainsResponse = z2.object({ site_id: z2.string(), configured: z2.boolean(), cname_target: z2.string(), domains: z2.array(DomainRecord) });
+var AddDomainBody = z2.object({ hostname: z2.string().min(3).max(253) });
+var AddDomainResponse = z2.object({ domain: DomainRecord, cname_target: z2.string() });
+var RemoveDomainResponse = z2.object({ hostname: z2.string(), deleted: z2.boolean() });
+var READER_ROLES = ["reader", "admin"];
+var ReaderRole = z2.enum(READER_ROLES);
+var ReaderRecord = z2.object({ entry: z2.string(), groups: z2.array(z2.string()), role: ReaderRole, added_at: z2.string(), updated_at: z2.string() });
+var ReaderPosture = z2.object({ release: z2.enum(["none", "unreadable", "known"]), require_sign_in: z2.boolean(), public_paths: z2.array(z2.string()), other_sign_in_methods: z2.boolean() });
+var ReadersResponse = z2.object({ site_id: z2.string(), enabled: z2.boolean(), readers: z2.array(ReaderRecord), known_groups: z2.array(z2.string()), cap: z2.number().int(), revocation_pending: z2.boolean().optional(), posture: ReaderPosture.optional() });
+var WriteReaderBody = z2.object({ entry: z2.string().min(3).max(320), groups: z2.array(z2.string()).optional(), role: ReaderRole.optional(), confirm: z2.boolean().optional() });
+var WriteReaderResponse = z2.object({ reader: ReaderRecord, enabled: z2.boolean(), rotated: z2.boolean(), created: z2.boolean(), revocation_incomplete: z2.boolean().optional() });
+var RemoveReaderResponse = z2.object({ entry: z2.string(), deleted: z2.boolean(), enabled: z2.boolean(), revocation_incomplete: z2.boolean().optional() });
+var ClearReadersResponse = z2.object({ deleted: z2.number().int(), enabled: z2.boolean(), revocation_incomplete: z2.boolean().optional() });
+var RotateReadersResponse = z2.object({ rotated: z2.boolean() });
+var SettingsWriteResponse = z2.object({ revision: z2.string().optional(), pending_pr: PendingSettingsPr.nullable().optional() });
+var InstructionsBody = z2.object({ instructions: z2.string().max(MAX_INSTRUCTIONS_CHARS) });
+var DocsRepoSettings = z2.object({ docs_repo: DocsRepo.nullable(), pages_count: z2.number().int().nullable() });
+var DocsRepoConnectBody = z2.object({
+  installation_id: z2.number().int(),
+  repository_id: z2.number().int(),
+  branch: z2.string().min(1),
+  docs_root: z2.string()
+});
+var ProductConnectionsResponse = z2.object({ site_id: z2.string().optional(), product_connections: z2.array(ProductConnectionRules) });
+var ProductConnectionCreateBody = z2.object({
+  installation_id: z2.number().int(),
+  repository_id: z2.number().int(),
+  branch: z2.string().optional(),
+  watch_globs: z2.array(z2.string()),
+  ignore_globs: z2.array(z2.string()).optional(),
+  skip_authors: z2.array(z2.string()).optional(),
+  skip_labels: z2.array(z2.string()).optional(),
+  merge_mode: z2.enum(MERGE_MODES).optional()
+});
+var ProductConnectionPatchBody = z2.object({
+  watch_globs: z2.array(z2.string()).optional(),
+  ignore_globs: z2.array(z2.string()).optional(),
+  skip_authors: z2.array(z2.string()).optional(),
+  skip_labels: z2.array(z2.string()).optional(),
+  merge_mode: z2.enum(MERGE_MODES).optional()
+});
+var ProductConnectionWriteResponse = z2.object({
+  product_connection: ProductConnectionRules.optional(),
+  dry_run: z2.boolean().optional(),
+  stranded_jobs: z2.number().int().optional()
+});
+var GrantedRepository = z2.object({ id: z2.number().int(), full_name: z2.string(), default_branch: z2.string().optional() });
+var RepositoriesQuery = z2.object({ installation_id: z2.coerce.number().int() });
+var RepositoriesResponse = z2.object({ installation_id: z2.number().int(), repositories: z2.array(GrantedRepository) });
+var SettingsApproval = z2.object({
+  revision: z2.string(),
+  pr_number: z2.number().int(),
+  head_sha: z2.string(),
+  repository_id: z2.number().int(),
+  actor: z2.string(),
+  state: z2.enum(["pending", "merged", "failed"]),
+  merge_commit_sha: z2.string().nullable(),
+  error: z2.string().nullable(),
+  created_at: z2.string()
+});
+var SettingsProposalResponse = z2.object({
+  site_id: z2.string(),
+  revision: z2.string(),
+  proposal: z2.object({
+    number: z2.number().int(),
+    url: z2.string(),
+    head_sha: z2.string(),
+    base_sha: z2.string(),
+    before: z2.record(z2.string(), z2.unknown()),
+    after: z2.record(z2.string(), z2.unknown()),
+    files: z2.array(z2.object({ path: z2.string(), status: z2.string(), sha: z2.string() })),
+    can_approve: z2.boolean(),
+    can_update: z2.boolean(),
+    blocked_reason: z2.string().nullable()
+  }).nullable(),
+  latest_approval: SettingsApproval.nullable(),
+  publication: SuggestionPublication.nullable().optional()
+});
+var SettingsApprovalResponse = z2.object({ site_id: z2.string(), approval: SettingsApproval });
+var SettingsUpdateResponse = z2.object({ site_id: z2.string(), state: z2.literal("updating") });
+var OperationFailure = z2.object({ error: z2.string().optional(), message: z2.string().optional(), reason: z2.string().optional() });
+var ApproveOutcome = OperationFailure.extend({
+  state: z2.enum(["publishing", "revising", "failed"]).optional(),
+  pr_number: z2.number().int().nullable().optional(),
+  merge_commit_sha: z2.string().nullable().optional(),
+  failure: z2.string().optional(),
+  failure_reason: z2.string().optional()
+});
+var DismissOutcome = OperationFailure.extend({ state: z2.literal("dismissed").optional(), pr_number: z2.number().int().nullable().optional(), pull_request_closed: z2.boolean().optional() });
+var RequestChangesOutcome = OperationFailure.extend({ state: z2.literal("revising").optional(), pr_number: z2.number().int().nullable().optional(), revision: z2.number().int().optional(), already_requested: z2.boolean().optional() });
+
+// ../management-client/dist/index.js
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+var EXIT = {
+  success: 0,
+  invalid_input: 2,
+  unauthorized: 3,
+  conflict: 4,
+  service_failure: 5,
+  wait_timeout: 6,
+  interrupted: 130
+};
+var EXIT_CODES = Object.freeze(Object.values(EXIT));
+var EXIT_MEANINGS = Object.freeze({
+  success: "The command did what it names, including a read of work that failed and a question the agent asked back.",
+  invalid_input: "The client refused the arguments before any request left the process.",
+  unauthorized: "The server refused the credential or the permission, without a guess at which.",
+  conflict: "State moved: a stale reviewed revision, a replayed submission with other words, or work that is not in a retryable state.",
+  service_failure: "Transport, the service, or the remote work itself failed, including a wait that ended in that failure.",
+  wait_timeout: "A wait reached its deadline with the work still running. The remote work continues.",
+  interrupted: "Local interruption. Nothing remote was cancelled."
+});
+var MUTATION_OUTCOMES = ["not_submitted", "known", "unknown"];
+var CLIENT_ERROR_CODES = [
+  "invalid_input",
+  "unauthorized",
+  "forbidden",
+  "not_found",
+  "stale_review",
+  "conflict",
+  "rate_limited",
+  "service_unavailable",
+  "transport_failure",
+  "remote_failure",
+  "unknown_outcome",
+  "wait_timeout",
+  "interrupted"
+];
+var CLIENT_ERROR_CATEGORIES = Object.freeze({
+  invalid_input: { exit: EXIT.invalid_input, retryable: false, mutation: "not_submitted", meaning: "The client or the server rejected the arguments. Nothing was written." },
+  unauthorized: { exit: EXIT.unauthorized, retryable: false, mutation: "not_submitted", meaning: "The server refused the credential. The refusal is opaque and is reported as given." },
+  forbidden: { exit: EXIT.unauthorized, retryable: false, mutation: "not_submitted", meaning: "The credential is known and this operation is not granted to it." },
+  not_found: { exit: EXIT.conflict, retryable: false, mutation: "not_submitted", meaning: "The named identity is not this site's, or does not exist." },
+  stale_review: { exit: EXIT.conflict, retryable: false, mutation: "not_submitted", meaning: "The reviewed base or head no longer matches the suggestion. Review again; never resend with current hashes." },
+  conflict: { exit: EXIT.conflict, retryable: false, mutation: "not_submitted", meaning: "State moved: a closed thread, a replayed submission with other words, or work that is not retryable." },
+  rate_limited: { exit: EXIT.service_failure, retryable: true, mutation: "not_submitted", meaning: "The site's allowance is spent. The server's retry-after is the only wait the client honours." },
+  service_unavailable: { exit: EXIT.service_failure, retryable: true, mutation: "not_submitted", meaning: "The service could not answer. A read may be sent again within the deadline." },
+  transport_failure: { exit: EXIT.service_failure, retryable: true, mutation: "unknown", meaning: "The request did not complete. A write in flight may or may not have been accepted." },
+  remote_failure: { exit: EXIT.service_failure, retryable: false, mutation: "known", meaning: "A wait followed remote work to a failure. The work itself failed; the call did not." },
+  unknown_outcome: { exit: EXIT.service_failure, retryable: false, mutation: "unknown", meaning: "A write was accepted but its result could not be read. Reconcile by reading before sending anything again." },
+  wait_timeout: { exit: EXIT.wait_timeout, retryable: false, mutation: "known", meaning: "The deadline passed with the work still running. Nothing remote was cancelled." },
+  interrupted: { exit: EXIT.interrupted, retryable: false, mutation: "unknown", meaning: "Local interruption. Nothing remote was cancelled." }
+});
+var OPAQUE_UNAUTHORIZED_MESSAGE = "The server refused this credential and did not say why. Check that SATURNDOCS_MANAGEMENT_TOKEN is set, names this site, and holds the permission this command needs.";
+var ServerFault = z3.object({
+  status: z3.number().int().nullable(),
+  /** `error` as the server sent it; never invented. */
+  code: z3.string().nullable(),
+  message: z3.string().nullable(),
+  /** Seconds, from the server's retry-after. */
+  retry_after: z3.number().int().nonnegative().nullable(),
+  correlation_id: z3.string().nullable()
+});
+var ClientError = z3.object({
+  code: z3.enum(CLIENT_ERROR_CODES),
+  message: z3.string().min(1),
+  retryable: z3.boolean(),
+  mutation: z3.enum(MUTATION_OUTCOMES),
+  exit: z3.union([z3.literal(0), z3.literal(2), z3.literal(3), z3.literal(4), z3.literal(5), z3.literal(6), z3.literal(130)]),
+  server: ServerFault.nullable()
+});
+function serverCode(body) {
+  if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+  const value = body.error;
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function classifyRefusal(refusal, context = {}) {
+  const { status } = refusal;
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return context.exactReview === true ? "stale_review" : "not_found";
+  if (status === 429) return "rate_limited";
+  if (status === 400 || status === 422) return "invalid_input";
+  if (status === 409 || status === 412 || status === 428) return "conflict";
+  if (status >= 500) return "service_unavailable";
+  return "conflict";
+}
+function serverFault(refusal, retryAfter = null, correlationId = null) {
+  const body = refusal.body === null || typeof refusal.body !== "object" ? {} : refusal.body;
+  const message = body.message;
+  const reason = body.reason;
+  return {
+    status: refusal.status,
+    code: serverCode(refusal.body),
+    message: typeof message === "string" ? message : typeof reason === "string" ? reason : null,
+    retry_after: retryAfter,
+    correlation_id: correlationId
+  };
+}
+var CLIENT_SCHEMA_VERSION = "saturndocs.cli/v1";
+var LIMITATION_CODES = [
+  "page_bounded",
+  "output_truncated",
+  "content_unavailable",
+  "review_incomplete",
+  "hand_edited",
+  "cleanup_incomplete",
+  "activation_unknown",
+  "section_unavailable"
+];
+var ClientLimitation = z22.object({
+  code: z22.enum(LIMITATION_CODES),
+  message: z22.string().min(1),
+  /** The part of `data` the limitation applies to, as a dotted path. */
+  at: z22.string().nullable()
+});
+var ClientRecovery = z22.object({
+  /** A command line the caller can run, with no request text or credential in it. */
+  command: z22.string().nullable(),
+  /** The submission id and payload to replay under, when a write's outcome is uncertain. */
+  replay: z22.object({ submission_id: z22.string(), stdin: z22.boolean() }).nullable(),
+  message: z22.string().min(1)
+});
+var DurableIds = z22.object({
+  submission_id: z22.string().optional(),
+  thread_id: z22.string().optional(),
+  job_id: z22.string().optional(),
+  attempt: z22.number().int().nullable().optional(),
+  suggestion_id: z22.string().optional(),
+  base_sha: z22.string().optional(),
+  head_sha: z22.string().optional(),
+  release_id: z22.string().optional(),
+  pr_number: z22.number().int().nullable().optional()
+});
+var envelope = {
+  schema_version: z22.literal(CLIENT_SCHEMA_VERSION),
+  command: z22.string().min(1),
+  /** The site the operation was verified against; null only where no site applies, such as local schema. */
+  site_id: z22.string().nullable(),
+  ids: DurableIds,
+  limitations: z22.array(ClientLimitation),
+  recovery: ClientRecovery.nullable()
+};
+var ClientSuccess = z22.object({ ...envelope, ok: z22.literal(true), data: z22.unknown() });
+var ClientFailure = z22.object({ ...envelope, ok: z22.literal(false), error: ClientError, data: z22.unknown().optional() });
+var ClientResult = z22.discriminatedUnion("ok", [ClientSuccess, ClientFailure]);
+function exitForResult(result) {
+  return result.ok ? EXIT.success : result.error.exit;
+}
+var SitesResponse2 = SitesResponse.loose();
+var PortalSite2 = PortalSite.loose();
+var PagesResponse2 = PagesResponse;
+var ActivityPage2 = ActivityPage.loose();
+var ReleasesPage2 = ReleasesPage.loose();
+var RequestsPage2 = RequestsPage.loose();
+var RequestThread2 = RequestThread.loose();
+var UpdateRequestResponse2 = UpdateRequestResponse.loose();
+var RequestRetryResponse2 = RequestRetryResponse.loose();
+var SuggestionsPage2 = SuggestionsPage.loose();
+var SuggestionDetailResponse2 = SuggestionDetailResponse.loose();
+var SuggestionThread2 = SuggestionThread.loose();
+var SessionResponse2 = SessionResponse.loose();
+var SuggestionPreviewResponse2 = SuggestionPreviewResponse.loose();
+var ApproveOutcome2 = ApproveOutcome.loose();
+var DismissOutcome2 = DismissOutcome.loose();
+var RequestChangesOutcome2 = RequestChangesOutcome.loose();
+var ErrorEnvelope2 = ErrorEnvelope.loose();
+var DocsRepoSettings2 = DocsRepoSettings.loose();
+var ProductConnectionsResponse2 = ProductConnectionsResponse.loose();
+var MANAGEMENT_SCOPES2 = MANAGEMENT_SCOPES;
+var SHA = /^[0-9a-f]{40}$/u;
+var ExactReviewInput = z32.object({
+  expected_base_sha: z32.string().regex(SHA),
+  expected_head_sha: z32.string().regex(SHA)
+});
+var DismissInput = ExactReviewInput.extend({
+  reason: DismissBody.shape.reason,
+  note: z32.string().max(MAX_REQUEST_CHANGES_NOTE_CHARS).nullable().optional()
+});
+var AnalysisRetryAccepted = z32.object({
+  retried: z32.literal(true),
+  job_id: z32.string().min(1),
+  attempt: z32.number().int().nullable(),
+  budget_tokens: z32.number().int().optional()
+}).loose();
+var NotRetryable = z32.object({
+  error: z32.literal("not_retryable"),
+  /** The sentence that says what failed and what to do instead; the analysis path sends it as `reason`. */
+  reason: z32.string().optional(),
+  message: z32.string().optional()
+}).loose();
+var PublicationRetryOutcome = ApproveOutcome2;
+var SuggestionRetryResponse = z32.union([AnalysisRetryAccepted, NotRetryable, PublicationRetryOutcome]);
+var CURSOR = { name: "cursor", kind: "string", note: "The opaque next_cursor of the preceding page. A cursor the server did not mint is refused, not restarted from the top." };
+var P0_OPERATIONS = {
+  "sites.list": {
+    path: "/v1/sites",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [],
+    response: SitesResponse2,
+    note: "Discovery. A presented credential resolves to one site; primary_host is null on that answer."
+  },
+  "site.get": {
+    path: "/site",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [],
+    response: PortalSite2,
+    note: "Served at /v1/sites/{site} with no suffix."
+  },
+  "docs-repo.get": { path: "/docs-repo", method: "GET", permission: "manage:read", mutation: false, query: [], response: DocsRepoSettings2, note: "Composed into site detail for connection information." },
+  "product-connections.list": { path: "/product-connections", method: "GET", permission: "manage:read", mutation: false, query: [], response: ProductConnectionsResponse2, note: "Composed into site detail for connection information." },
+  "pages.list": {
+    path: "/pages",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [{ name: "days", kind: "enum", values: ["7", "30", "90"], note: "Traffic window." }],
+    response: PagesResponse2,
+    note: "Answers `unavailable: no_release` when the site has never published, which is not an empty page list."
+  },
+  "activity.list": {
+    path: "/activity",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [
+      CURSOR,
+      { name: "job_id", kind: "string", max: 200, note: "Exact read. Handled by the activity route and absent from the published query metadata; a wrong length is 400 invalid_job_id." },
+      { name: "outcome", kind: "enum", values: ["suggestion", "nochange", "skipped", "failed", "published"], note: "Filter." },
+      { name: "repo", kind: "string", max: 200, note: "Full repository name." },
+      { name: "from", kind: "string", note: "Inclusive UTC date; from later than to is 400." },
+      { name: "to", kind: "string", note: "Inclusive UTC date." },
+      { name: "limit", kind: "integer", max: 100, note: "Server ceiling; a larger value is clamped, not refused." }
+    ],
+    response: ActivityPage2,
+    note: "An exact job read comes from the jobs alone, so a queued job is found however many events came after it."
+  },
+  "releases.list": {
+    path: "/releases",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [
+      CURSOR,
+      { name: "release_id", kind: "string", max: 200, note: "Exact read, including a release older than the first page." },
+      { name: "limit", kind: "integer", max: 50, note: "Outside 1..50 is 400 invalid_limit, not clamped." }
+    ],
+    response: ReleasesPage2,
+    note: "active_release_status is `unknown` when the activation record could not be read; that is not 'not active'."
+  },
+  "requests.list": {
+    path: "/requests",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [
+      CURSOR,
+      { name: "view", kind: "enum", values: ["threads"], note: "Required for conversations; without it the route answers the flat job listing." },
+      { name: "limit", kind: "integer", max: 100, note: "Thread page size." },
+      { name: "attention", kind: "enum", values: ["1"], note: "Adds the site's failed and waiting counts." }
+    ],
+    response: RequestsPage2,
+    note: "Threads page by the original request, so a reply never moves a conversation between pages."
+  },
+  "requests.thread": { path: "/requests/{job}/thread", method: "GET", permission: "manage:read", mutation: false, query: [], response: RequestThread2, note: "Any job of the thread names it. Carries root, latest_job, and entries oldest first." },
+  "requests.create": {
+    path: "/requests",
+    method: "POST",
+    permission: "manage:write",
+    mutation: true,
+    query: [],
+    response: UpdateRequestResponse2,
+    note: "202 with the queued job. The same submission_id with the same payload recovers that job; with other words it is 409 submission_conflict."
+  },
+  "requests.retry": {
+    path: "/requests/{job}/retry",
+    method: "POST",
+    permission: "manage:write",
+    mutation: true,
+    query: [],
+    response: RequestRetryResponse2,
+    note: "Targets the failed job and keeps its id, so `attempt` is the only thing telling two runs apart. It may be null."
+  },
+  "suggestions.list": {
+    path: "/suggestions",
+    method: "GET",
+    permission: "manage:read",
+    mutation: false,
+    query: [CURSOR, { name: "state", kind: "enum", values: ["pending", "revising", "published", "dismissed", "failed"], note: "Tab; defaults to pending." }],
+    response: SuggestionsPage2,
+    note: "Counts come from the server; a bounded list is never a site total."
+  },
+  "suggestions.get": { path: "/suggestions/{suggestion}", method: "GET", permission: "manage:read", mutation: false, query: [], response: SuggestionDetailResponse2, note: "Carries base_sha, head_sha, revision, questions, publication, and page content when the server has it." },
+  "suggestions.session.read": { path: "/suggestions/{suggestion}/session", method: "GET", permission: "manage:read", mutation: false, query: [], response: SuggestionThread2, note: "The conversation transcript." },
+  "suggestions.session.post": { path: "/suggestions/{suggestion}/session", method: "POST", permission: "manage:write", mutation: true, query: [], response: SessionResponse2, note: "startedRevision says whether the answer queued a revision. question_id is a suggestion question, never a request thread." },
+  "suggestions.request-changes": { path: "/suggestions/{suggestion}/request-changes", method: "POST", permission: "manage:write", mutation: true, query: [], response: RequestChangesOutcome2, note: "already_requested means the earlier revision is the live one; this call changed nothing." },
+  "suggestions.preview.read": { path: "/suggestions/{suggestion}/preview", method: "GET", permission: "manage:read", mutation: false, query: [], response: SuggestionPreviewResponse2, note: "Read-only. `current` false means the preview is not of the suggestion's current revision." },
+  "suggestions.preview.create": { path: "/suggestions/{suggestion}/preview", method: "POST", permission: "manage:write", mutation: true, query: [], response: SuggestionPreviewResponse2, note: "Builds a preview. Only an explicit --create reaches here." },
+  "suggestions.approve": { path: "/suggestions/{suggestion}/approve", method: "POST", permission: "manage:approve", mutation: true, query: [], response: ApproveOutcome2, note: "A head or base that moved is answered 404 by the merge path, which is a stale review and not a missing suggestion." },
+  "suggestions.dismiss": { path: "/suggestions/{suggestion}/dismiss", method: "POST", permission: "manage:write", mutation: true, query: [], response: DismissOutcome2, note: "pull_request_closed false is a completed dismissal with incomplete cleanup." },
+  "suggestions.retry": { path: "/suggestions/{suggestion}/retry", method: "POST", permission: "manage:approve", mutation: true, query: [], response: SuggestionRetryResponse, note: "Analysis retry answers with the job and attempt; publication retry answers with the approval outcome; a failed revision is 409 not_retryable." }
+};
+var P0_OPERATION_KEYS = Object.keys(P0_OPERATIONS);
+function operationOf(key) {
+  return P0_OPERATIONS[key];
+}
+function operationPath(key, siteId, params = {}) {
+  const operation = P0_OPERATIONS[key];
+  if (operation.path === "/v1/sites") return "/v1/sites";
+  const rest = operation.path === "/site" ? "" : operation.path.replace(/\{([^}]+)\}/gu, (_all, name) => {
+    const value = params[name];
+    if (value === void 0 || value === "") throw new Error(`Missing path parameter ${name} for ${key}`);
+    return encodeURIComponent(value);
+  });
+  return `/v1/sites/${encodeURIComponent(siteId)}${rest}`;
+}
+var REQUEST_WAIT_TABLE = Object.freeze([
+  { state: "queued", entry: null, decision: "continue", outcome: "working", exit: EXIT.success, note: "Still admitted; nothing to report yet." },
+  { state: "running", entry: null, decision: "continue", outcome: "working", exit: EXIT.success, note: "Drafting." },
+  { state: "succeeded", entry: "draft", decision: "stop", outcome: "drafted", exit: EXIT.success, note: "The suggestion the request produced is named on the entry." },
+  { state: "succeeded", entry: "question", decision: "stop", outcome: "question", exit: EXIT.success, note: "The agent asked back. Answering is a reply on the root thread, not a new request." },
+  { state: "succeeded", entry: "no_change", decision: "stop", outcome: "no_change", exit: EXIT.success, note: "Concluded that nothing needed changing. This is a result, not a failure." },
+  { state: "succeeded", entry: "other", decision: "stop", outcome: "outcome_unknown", exit: EXIT.service_failure, note: "Terminal with no entry that says what came of it; read the thread rather than assume." },
+  { state: "succeeded", entry: null, decision: "stop", outcome: "outcome_unknown", exit: EXIT.service_failure, note: "Terminal with no matching entry at all. Never wait forever on this." },
+  { state: "failed", entry: "failed", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "The work failed. Reading it exits 0; waiting on it exits 5." },
+  { state: "failed", entry: null, decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Failed before it wrote an entry." },
+  { state: "failed", entry: "other", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Failed after some other turn." },
+  { state: "timed_out", entry: null, decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Ran out of time server-side. Retryable as a failure is." },
+  { state: "timed_out", entry: "other", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Ran out of time server-side." },
+  { state: "timed_out", entry: "failed", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Ran out of time server-side." },
+  { state: "cancelled", entry: null, decision: "stop", outcome: "cancelled", exit: EXIT.service_failure, note: "Cancelled or superseded. Not retryable; ask again instead." },
+  { state: "cancelled", entry: "other", decision: "stop", outcome: "cancelled", exit: EXIT.service_failure, note: "Cancelled or superseded." },
+  { state: "cancelled", entry: "failed", decision: "stop", outcome: "cancelled", exit: EXIT.service_failure, note: "Cancelled or superseded." }
+]);
+var ENTRY_KINDS = /* @__PURE__ */ new Set(["draft", "question", "no_change", "failed"]);
+function classifyRequestWait(thread) {
+  const latest = thread.latest_job;
+  const mine = thread.entries.filter((entry2) => entry2.job_id === latest.job_id && (latest.attempt === null || entry2.attempt === latest.attempt));
+  const newest = mine.at(-1);
+  const entry = newest === void 0 ? null : ENTRY_KINDS.has(newest.kind) ? newest.kind : "other";
+  const rule = REQUEST_WAIT_TABLE.find((row) => row.state === latest.state && row.entry === entry) ?? REQUEST_WAIT_TABLE.find((row) => row.state === latest.state && row.entry === null);
+  if (rule === void 0) throw new Error(`No request wait rule for state ${latest.state}`);
+  return { job_id: latest.job_id, attempt: latest.attempt, entry, rule, suggestion_id: newest?.suggestion_id ?? null };
+}
+var SUGGESTION_WAIT_TARGETS = ["reviewable", "published"];
+var SUGGESTION_WAIT_TABLE = Object.freeze([
+  { target: "reviewable", state: "pending_review", decision: "stop", outcome: "reviewable", exit: EXIT.success, note: "Ready to read. Review limitations travel with the result." },
+  { target: "reviewable", state: "changes_requested", decision: "continue", outcome: "working", exit: EXIT.success, note: "A revision was asked for and has not started." },
+  { target: "reviewable", state: "revising", decision: "continue", outcome: "working", exit: EXIT.success, note: "Being revised." },
+  { target: "reviewable", state: "publishing", decision: "stop", outcome: "no_longer_reviewable", exit: EXIT.conflict, note: "Already approved by someone; there is nothing left to review." },
+  { target: "reviewable", state: "published", decision: "stop", outcome: "no_longer_reviewable", exit: EXIT.conflict, note: "Already published." },
+  { target: "reviewable", state: "dismissed", decision: "stop", outcome: "dismissed", exit: EXIT.conflict, note: "Dismissed. Nothing to review." },
+  { target: "reviewable", state: "superseded", decision: "stop", outcome: "superseded", exit: EXIT.conflict, note: "A newer suggestion replaced it. Approving this one would publish the older revision." },
+  { target: "reviewable", state: "failed", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "The work behind it failed." },
+  { target: "published", state: "pending_review", decision: "continue", outcome: "working", exit: EXIT.success, note: "The approval may not be recorded yet." },
+  { target: "published", state: "changes_requested", decision: "stop", outcome: "review_required", exit: EXIT.conflict, note: "A revision was asked for, so the reviewed revision will not publish. Review the new one." },
+  { target: "published", state: "revising", decision: "stop", outcome: "review_required", exit: EXIT.conflict, note: "Approval led to another revision. Never approve the new draft automatically." },
+  { target: "published", state: "publishing", decision: "continue", outcome: "working", exit: EXIT.success, note: "Merged and building." },
+  { target: "published", state: "published", decision: "continue", outcome: "working", exit: EXIT.success, note: "State alone is not activation; the linked release decides." },
+  { target: "published", state: "dismissed", decision: "stop", outcome: "dismissed", exit: EXIT.conflict, note: "Dismissed instead of published." },
+  { target: "published", state: "superseded", decision: "stop", outcome: "superseded", exit: EXIT.conflict, note: "Replaced before it published." },
+  { target: "published", state: "failed", decision: "stop", outcome: "failed", exit: EXIT.service_failure, note: "Publication failed." }
+]);
+var ACTIVATION_TABLE = Object.freeze([
+  { linked: false, activated: false, active: "unknown", decision: "continue", outcome: "working", exit: EXIT.success, note: "No release is linked yet." },
+  { linked: true, activated: false, active: "unknown", decision: "continue", outcome: "working", exit: EXIT.success, note: "Built, never activated. Not published." },
+  { linked: true, activated: false, active: "other", decision: "continue", outcome: "working", exit: EXIT.success, note: "Built, never activated." },
+  { linked: true, activated: false, active: "this", decision: "continue", outcome: "working", exit: EXIT.success, note: "Named active with no activation record; wait for the record rather than claim it." },
+  { linked: true, activated: true, active: "this", decision: "stop", outcome: "published_active", exit: EXIT.success, note: "Activated and serving readers now." },
+  { linked: true, activated: true, active: "other", decision: "stop", outcome: "published_historical", exit: EXIT.success, note: "It did go live; a later release is serving readers now." },
+  { linked: true, activated: true, active: "unknown", decision: "stop", outcome: "published_activation_unknown", exit: EXIT.success, note: "It did go live; whether it is serving readers now could not be read." }
+]);
+function classifyActivation(input) {
+  const linked = input.release_id !== null;
+  const activated = linked && input.activated_at !== null;
+  const active = input.active_release_status === "unknown" ? "unknown" : input.active_release_id !== null && input.active_release_id === input.release_id ? "this" : "other";
+  const rule = ACTIVATION_TABLE.find((row) => row.linked === linked && row.activated === activated && row.active === active) ?? ACTIVATION_TABLE.find((row) => row.linked === linked && row.activated === activated);
+  if (rule === void 0) throw new Error("No activation rule for the given release state");
+  return rule;
+}
+function classifySuggestionWait(target, suggestion, activation) {
+  const rule = SUGGESTION_WAIT_TABLE.find((row) => row.target === target && row.state === suggestion.state);
+  if (rule === void 0) throw new Error(`No suggestion wait rule for ${target}/${suggestion.state}`);
+  if (target !== "published" || rule.decision === "stop" || activation === void 0) {
+    return { rule, activation: null, decision: rule.decision, outcome: rule.outcome, exit: rule.exit };
+  }
+  const activationRule = classifyActivation(activation);
+  return { rule, activation: activationRule, decision: activationRule.decision, outcome: activationRule.outcome, exit: activationRule.exit };
+}
+var GLOBAL = Object.freeze([
+  { name: "--json", value: "boolean", required: false, description: "One result object and a newline on stdout. Diagnostics stay on stderr." },
+  { name: "--site", value: "string", required: false, description: "The site to act on. Required for every remote mutation." },
+  { name: "--api", value: "string", required: false, description: "Management API origin." },
+  { name: "--no-input", value: "boolean", required: false, description: "Never read from a terminal." },
+  { name: "--timeout", value: "integer", required: false, description: "Seconds a wait or a request may take." }
+]);
+var GLOBAL_FLAGS = GLOBAL;
+var TEXT = Object.freeze([
+  { name: "--file", value: "string", required: false, description: "Read the text from a path, or from stdin with -." },
+  { name: "--text", value: "string", required: false, description: "The text itself. Mutually exclusive with --file." }
+]);
+var WAIT = Object.freeze([
+  { name: "--timeout", value: "integer", required: false, description: "Seconds. Must be positive and finite; it bounds backoff and the request in flight alike." }
+]);
+var READ_EXITS = Object.freeze([EXIT.success, EXIT.invalid_input, EXIT.unauthorized, EXIT.conflict, EXIT.service_failure, EXIT.interrupted]);
+var WRITE_EXITS = READ_EXITS;
+var WAIT_EXITS = Object.freeze([...READ_EXITS, EXIT.wait_timeout]);
+var REQUEST_TEXT_LIMIT = 4e3;
+var SESSION_MESSAGE_LIMIT = 2e3;
+var REVISION_NOTE_LIMIT = 4e3;
+var cursor = { name: "--cursor", value: "string", required: false, description: "The next_cursor of the preceding page. One page is read per invocation." };
+var limit = { name: "--limit", value: "integer", required: false, description: "Page size, within the operation's server ceiling." };
+var P0_COMMANDS = [
+  { name: "auth status", operation: "sites.list", operations: ["sites.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "Verify read access and report the credential's own site. Says nothing about scopes the server did not return." },
+  { name: "sites list", operation: "sites.list", operations: ["sites.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "The sites the presented credential resolves to." },
+  { name: "sites get", operation: "site.get", operations: ["site.get", "docs-repo.get", "product-connections.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [{ name: "--connections", value: "boolean", required: false, description: "Also read the documentation repository and watched repositories." }], exits: READ_EXITS, summary: "One site's status, hostnames, publication, and usage." },
+  { name: "pages list", operation: "pages.list", operations: ["pages.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [{ name: "--days", value: "integer", required: false, description: "Traffic window: 7, 30, or 90." }], exits: READ_EXITS, summary: "Published pages of the live release. An unpublished site is not an empty list." },
+  { name: "status", operation: null, operations: ["site.get", "requests.list", "suggestions.list", "activity.list"], permission: "manage:read", mutation: false, requires_site: true, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "Bounded briefing. Each section reports available, empty, or unavailable on its own." },
+  { name: "schema", operation: null, operations: [], permission: null, mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: [EXIT.success, EXIT.invalid_input, EXIT.interrupted], summary: "Versioned command metadata, locally. No credential and no network." },
+  { name: "manage", operation: null, operations: [], permission: null, mutation: false, requires_site: true, text_input: "optional", text_limit: null, flags: [{ name: "--data", value: "string", required: false, description: "JSON body, or @path to read one." }, { name: "--file", value: "string", required: false, description: "A multipart file part, repeatable." }, { name: "--revision", value: "string", required: false, description: "The quoted settings revision for If-Match." }], exits: WRITE_EXITS, summary: "One existing management operation chosen by the caller, under the same target and precondition rules as every other command." },
+  { name: "requests create", operation: "requests.create", operations: ["requests.create"], permission: "manage:write", mutation: true, requires_site: true, text_input: "required", text_limit: REQUEST_TEXT_LIMIT, flags: [...TEXT, { name: "--submission-id", value: "string", required: true, description: "A UUID the caller keeps. Replaying it with the same payload recovers the same job." }, { name: "--page", value: "string", required: false, description: "The page the request is about." }], exits: WRITE_EXITS, summary: "Submit a documentation request and return its queued job and root thread." },
+  { name: "requests reply", operation: "requests.create", operations: ["requests.create"], permission: "manage:write", mutation: true, requires_site: true, text_input: "required", text_limit: REQUEST_TEXT_LIMIT, flags: [...TEXT, { name: "--thread", value: "string", required: true, description: "The root job of the conversation being answered." }, { name: "--submission-id", value: "string", required: true, description: "A UUID the caller keeps, so a lost answer replays instead of duplicating." }], exits: WRITE_EXITS, summary: "Answer a clarification. The root thread is kept; a new job comes back." },
+  { name: "requests list", operation: "requests.list", operations: ["requests.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [cursor, limit], exits: READ_EXITS, summary: "Conversations, newest original request first." },
+  { name: "requests get", operation: "requests.thread", operations: ["requests.thread"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "One conversation with its root, its latest job and attempt, and up to its newest 100 turns." },
+  { name: "requests retry", operation: "requests.retry", operations: ["requests.retry"], permission: "manage:write", mutation: true, requires_site: true, text_input: "none", text_limit: null, flags: [], exits: WRITE_EXITS, summary: "Send a failed request again. Reports the returned attempt, including null." },
+  { name: "requests wait", operation: "requests.thread", operations: ["requests.thread"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [...WAIT], exits: WAIT_EXITS, summary: "Follow one conversation's latest job to a draft, a question, no change, or a failure." },
+  { name: "suggestions list", operation: "suggestions.list", operations: ["suggestions.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [cursor, limit, { name: "--state", value: "string", required: false, description: "pending, revising, published, dismissed, or failed." }], exits: READ_EXITS, summary: "Suggestions on one tab." },
+  { name: "suggestions get", operation: "suggestions.get", operations: ["suggestions.get"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "One suggestion, its exact revision, and its linked identities." },
+  { name: "suggestions diff", operation: "suggestions.get", operations: ["suggestions.get"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [{ name: "--path", value: "string", required: false, description: "One changed page instead of all of them." }], exits: READ_EXITS, summary: "The supplied page content as a diff, with every gap in it named." },
+  { name: "suggestions conversation", operation: "suggestions.session.read", operations: ["suggestions.session.read"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "The transcript of a suggestion conversation." },
+  { name: "suggestions message", operation: "suggestions.session.post", operations: ["suggestions.session.post"], permission: "manage:write", mutation: true, requires_site: true, text_input: "required", text_limit: SESSION_MESSAGE_LIMIT, flags: [...TEXT, { name: "--question-id", value: "string", required: false, description: "The suggestion question being answered. Not a request thread id." }], exits: WRITE_EXITS, summary: "Ask about a suggestion or answer its question, reporting whether a revision started." },
+  { name: "suggestions request-changes", operation: "suggestions.request-changes", operations: ["suggestions.request-changes"], permission: "manage:write", mutation: true, requires_site: true, text_input: "required", text_limit: REVISION_NOTE_LIMIT, flags: [...TEXT], exits: WRITE_EXITS, summary: "Ask for a revision. A note saved without a queued revision is reported as such." },
+  { name: "suggestions preview", operation: "suggestions.preview.read", operations: ["suggestions.preview.read", "suggestions.preview.create"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [{ name: "--create", value: "boolean", required: false, description: "Build a preview. Requires an explicit --site and manage:write." }], exits: WRITE_EXITS, summary: "Read the current revision's preview; build one only when asked." },
+  { name: "suggestions approve", operation: "suggestions.approve", operations: ["suggestions.approve"], permission: "manage:approve", mutation: true, requires_site: true, text_input: "none", text_limit: null, flags: [{ name: "--base", value: "string", required: true, description: "The reviewed base SHA, sent as expected_base_sha." }, { name: "--head", value: "string", required: true, description: "The reviewed head SHA, sent as expected_head_sha." }], exits: WRITE_EXITS, summary: "Publish exactly the revision that was reviewed. A moved head is refused, never repaired." },
+  { name: "suggestions dismiss", operation: "suggestions.dismiss", operations: ["suggestions.dismiss"], permission: "manage:write", mutation: true, requires_site: true, text_input: "optional", text_limit: REVISION_NOTE_LIMIT, flags: [{ name: "--base", value: "string", required: true, description: "The reviewed base SHA." }, { name: "--head", value: "string", required: true, description: "The reviewed head SHA." }, { name: "--reason", value: "string", required: true, description: "not_needed, wrong_pages, inaccurate, manual, or other." }, ...TEXT], exits: WRITE_EXITS, summary: "Dismiss the reviewed revision. Incomplete pull-request cleanup is reported, not hidden." },
+  { name: "suggestions retry", operation: "suggestions.retry", operations: ["suggestions.retry"], permission: "manage:approve", mutation: true, requires_site: true, text_input: "none", text_limit: null, flags: [], exits: WRITE_EXITS, summary: "Retry the analysis or the publication, whichever failed, and report which happened." },
+  { name: "suggestions wait", operation: "suggestions.get", operations: ["suggestions.get", "releases.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [...WAIT, { name: "--until", value: "string", required: true, description: "reviewable or published." }], exits: WAIT_EXITS, summary: "Wait for a revision to become reviewable, or for its linked release to show activation." },
+  { name: "activity list", operation: "activity.list", operations: ["activity.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [cursor, limit, { name: "--outcome", value: "string", required: false, description: "suggestion, nochange, skipped, failed, or published." }, { name: "--repo", value: "string", required: false, description: "Full repository name." }, { name: "--from", value: "string", required: false, description: "Inclusive UTC date." }, { name: "--to", value: "string", required: false, description: "Inclusive UTC date." }], exits: READ_EXITS, summary: "Operational activity, newest first." },
+  { name: "activity get", operation: "activity.list", operations: ["activity.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "One job by id, through the list operation's job_id filter. No page-one scan." },
+  { name: "releases list", operation: "releases.list", operations: ["releases.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [cursor, limit], exits: READ_EXITS, summary: "Releases, newest first, with activation and current-active status." },
+  { name: "releases get", operation: "releases.list", operations: ["releases.list"], permission: "manage:read", mutation: false, requires_site: false, text_input: "none", text_limit: null, flags: [], exits: READ_EXITS, summary: "One release by id, including one older than the first page." }
+];
+var P0_COMMAND_NAMES = Object.freeze(P0_COMMANDS.map((command) => command.name));
+function commandSpec(name) {
+  return P0_COMMANDS.find((command) => command.name === name);
+}
+var ManagementError = class extends Error {
+  detail;
+  constructor(detail, options) {
+    super(detail.message, options);
+    this.name = "ManagementError";
+    this.detail = detail;
+  }
+};
+function clientError(code, message, overrides = {}) {
+  const category = CLIENT_ERROR_CATEGORIES[code];
+  return {
+    code,
+    message,
+    retryable: overrides.retryable ?? category.retryable,
+    mutation: overrides.mutation ?? category.mutation,
+    exit: category.exit,
+    server: overrides.server ?? null
+  };
+}
+function managementError(code, message, overrides = {}) {
+  return new ManagementError(clientError(code, message, overrides));
+}
+function invalidInput(message) {
+  return managementError("invalid_input", message);
+}
+function refusalError(refusal, details = {}) {
+  const code = classifyRefusal(refusal, { exactReview: details.exactReview });
+  const fault = serverFault(refusal, details.retryAfter ?? null, details.correlationId ?? null);
+  const message = code === "unauthorized" ? OPAQUE_UNAUTHORIZED_MESSAGE : fault.message ?? `The management API answered ${refusal.status}${fault.code === null ? "" : ` ${fault.code}`}.`;
+  return new ManagementError(clientError(code, message, { mutation: details.mutation, server: fault }));
+}
+function transportFailure(message, mutation = "not_submitted") {
+  return managementError("transport_failure", message, { mutation });
+}
+function interrupted(mutation = "not_submitted") {
+  return managementError("interrupted", "The command was interrupted before it finished. Nothing remote was cancelled.", { mutation });
+}
+function unknownOutcome(message) {
+  return managementError("unknown_outcome", message);
+}
+function isManagementError(value) {
+  return value instanceof ManagementError;
+}
+function toClientError(cause, mutation = "not_submitted") {
+  if (isManagementError(cause)) return cause.detail;
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return clientError("transport_failure", message === "" ? "The request failed without a reason." : message, { mutation });
+}
+var REDACTION = "[redacted]";
+function redactSecrets(text, secrets) {
+  let out = text.replace(/[Bb]earer\s+[\w.~+/=-]+/gu, `Bearer ${REDACTION}`);
+  for (const secret of secrets) {
+    if (secret === void 0 || secret === "") continue;
+    out = out.split(secret).join(REDACTION);
+  }
+  return out;
+}
+var COMMIT_SHA = /^[0-9a-f]{40}$/u;
+var SETTINGS_REVISION = /^[0-9a-f]{64}$/u;
+function parseReviewedRevision(base, head) {
+  const base_sha = requireCommitSha(base, "--base");
+  const head_sha = requireCommitSha(head, "--head");
+  return { base_sha, head_sha };
+}
+function requireCommitSha(value, flag) {
+  if (typeof value !== "string" || !COMMIT_SHA.test(value)) {
+    throw invalidInput(`${flag} must be the full 40-character commit SHA exactly as the suggestion read returned it, in lower case.`);
+  }
+  return value;
+}
+function requireSettingsRevision(value) {
+  if (typeof value !== "string" || !SETTINGS_REVISION.test(value)) {
+    throw invalidInput("--revision must be the 64-character revision returned by the settings read or the proposal review, in lower case.");
+  }
+  return value;
+}
+function ifMatchHeader(revision) {
+  return `"${requireSettingsRevision(revision)}"`;
+}
+var DEFAULT_ORIGIN = "https://app.saturndocs.com";
+var DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
+var DEFAULT_DEADLINE_MS = 3e4;
+var MAX_READ_ATTEMPTS = 4;
+var BASE_BACKOFF_MS = 250;
+var MAX_BACKOFF_MS = 5e3;
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET"]);
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 503]);
+function parseOrigin(value = DEFAULT_ORIGIN) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw invalidInput("The management API address must be a full HTTPS origin, such as https://app.saturndocs.com.");
+  }
+  if (url.protocol !== "https:") throw invalidInput("The management API address must use HTTPS; a token must never travel in clear text.");
+  if (url.username !== "" || url.password !== "") throw invalidInput("The management API address must not carry credentials.");
+  if (url.pathname !== "/" || url.search !== "" || url.hash !== "") throw invalidInput("The management API address must be a bare origin with no path, query, or fragment.");
+  return url;
+}
+function resourcePath(siteId, segments = []) {
+  const rest = segments.map((segment) => {
+    if (segment === "") throw invalidInput("A resource id in the request path is empty.");
+    return encodeURIComponent(segment);
+  });
+  const prefix = siteId === null ? ["v1"] : ["v1", "sites", encodeURIComponent(siteId)];
+  return `/${[...prefix, ...rest].join("/")}`;
+}
+function confinedUrl(origin, path) {
+  if (!path.startsWith("/v1")) throw invalidInput("A management request path must start with /v1.");
+  if (path.includes("\\") || path.includes("#") || path.startsWith("//")) throw invalidInput("A management request path must not carry a host, a fragment, or a backslash.");
+  for (const part of path.split("/")) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(part);
+    } catch {
+      throw invalidInput("A management request path contains an invalid escape.");
+    }
+    if (decoded === "." || decoded === "..") throw invalidInput("A management request path must not contain relative segments.");
+  }
+  const url = new URL(path, origin);
+  if (url.origin !== origin.origin) throw invalidInput("A management request must stay on the configured API origin.");
+  if (url.pathname !== "/v1" && !url.pathname.startsWith("/v1/")) throw invalidInput("A management request must stay under /v1.");
+  return url;
+}
+function parseRetryAfter(header, now) {
+  if (header === null) return null;
+  const trimmed = header.trim();
+  if (/^\d+$/u.test(trimmed)) return Number(trimmed);
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return null;
+  return Math.max(0, Math.ceil((at - now) / 1e3));
+}
+async function readBounded(response, maxBytes) {
+  const declared = response.headers.get("content-length");
+  if (declared !== null && /^\d+$/u.test(declared) && Number(declared) > maxBytes) {
+    throw new Error(`The response is ${declared} bytes, over the ${maxBytes}-byte read limit.`);
+  }
+  const body = response.body;
+  if (body === null || body === void 0 || typeof body.getReader !== "function") {
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength > maxBytes) throw new Error(`The response is over the ${maxBytes}-byte read limit.`);
+    return new TextDecoder().decode(buffer);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value === void 0) continue;
+      total += value.byteLength;
+      if (total > maxBytes) throw new Error(`The response is over the ${maxBytes}-byte read limit.`);
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+  const joined = new Uint8Array(total);
+  let at = 0;
+  for (const chunk of chunks) {
+    joined.set(chunk, at);
+    at += chunk.byteLength;
+  }
+  return new TextDecoder().decode(joined);
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function createClient(config = {}) {
+  const origin = parseOrigin(config.origin);
+  const token = config.token;
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const callerSignal = config.signal;
+  const defaultDeadline = config.deadlineMs ?? DEFAULT_DEADLINE_MS;
+  const maxBytes = config.maxBytes ?? DEFAULT_MAX_BYTES;
+  const sleep = config.sleep ?? defaultSleep;
+  const now = config.now ?? (() => Date.now());
+  const secrets = [token];
+  const clean = (text) => redactSecrets(text, secrets);
+  const cancelled = (signal) => (callerSignal?.aborted ?? false) || (signal?.aborted ?? false);
+  async function request(input) {
+    const url = confinedUrl(origin, input.path);
+    for (const [name, value] of Object.entries(input.query ?? {})) {
+      if (value !== void 0) url.searchParams.set(name, String(value));
+    }
+    if (input.method === "GET" && (input.body !== void 0 || input.rawBody !== void 0)) throw invalidInput("A GET request does not carry a body.");
+    if (input.body !== void 0 && input.rawBody !== void 0) throw invalidInput("A request carries either a JSON body or an encoded one, never both.");
+    const anonymous = input.anonymous === true;
+    if (!anonymous && (token === void 0 || token === "")) throw invalidInput("Set SATURNDOCS_MANAGEMENT_TOKEN to a management credential for this site.");
+    const mutation = input.mutation === true || !IDEMPOTENT.has(input.method);
+    const headers = new Headers({ accept: "application/json" });
+    if (!anonymous) headers.set("authorization", `Bearer ${token}`);
+    if (input.revision !== void 0) headers.set("if-match", ifMatchHeader(input.revision));
+    const body = input.rawBody ?? (input.body === void 0 ? void 0 : JSON.stringify(input.body));
+    if (input.body !== void 0) headers.set("content-type", "application/json");
+    const deadlineMs = input.deadlineMs ?? defaultDeadline;
+    if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) throw invalidInput("The timeout must be a positive number of seconds.");
+    const startedAt = now();
+    const remaining = () => deadlineMs - (now() - startedAt);
+    let attempts = 0;
+    for (; ; ) {
+      if (cancelled(input.signal)) throw interrupted();
+      const left = remaining();
+      if (left <= 0) throw transportFailure(`The management API did not answer within ${Math.round(deadlineMs / 1e3)}s.`, mutation ? "unknown" : "not_submitted");
+      const timeout = AbortSignal.timeout(left);
+      const signals = [timeout, callerSignal, input.signal].filter((value) => value !== void 0);
+      const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+      attempts += 1;
+      let response;
+      try {
+        response = await fetchImpl(url, { method: input.method, headers, body, redirect: "manual", signal });
+      } catch (cause) {
+        if (cancelled(input.signal)) throw interrupted(mutation ? "unknown" : "not_submitted");
+        const message = clean(cause instanceof Error ? cause.message : String(cause));
+        if (!mutation && !timeout.aborted && attempts < MAX_READ_ATTEMPTS && remaining() > BASE_BACKOFF_MS) {
+          await backoff(attempts, null, remaining(), input.signal);
+          continue;
+        }
+        throw transportFailure(
+          timeout.aborted ? `The management API did not answer within ${Math.round(deadlineMs / 1e3)}s.` : `The management request did not complete: ${message}`,
+          mutation ? "unknown" : "not_submitted"
+        );
+      }
+      if (response.status >= 300 && response.status < 400) {
+        throw invalidInput("The management API redirected the request, so it was refused without forwarding the credential. Check the API address.");
+      }
+      const retryAfter = parseRetryAfter(response.headers.get("retry-after"), now());
+      const correlationId = response.headers.get("x-correlation-id") ?? response.headers.get("cf-ray");
+      let text;
+      try {
+        text = await readBounded(response, maxBytes);
+      } catch (cause) {
+        const message = clean(cause instanceof Error ? cause.message : String(cause));
+        if (mutation && response.ok) throw unknownOutcome(`The write was accepted but its answer could not be read: ${message} Read the site's state before sending anything again.`);
+        throw transportFailure(`The management answer could not be read: ${message}`, mutation ? "unknown" : "not_submitted");
+      }
+      let data = null;
+      if (text.trim() !== "") {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          if (mutation && response.ok) throw unknownOutcome("The write was accepted but its answer was not JSON. Read the site's state before sending anything again.");
+          if (response.ok) throw transportFailure("The management API answered with something other than JSON.");
+          data = null;
+        }
+      }
+      if (response.ok) return { status: response.status, headers: response.headers, data, attempts };
+      const refusal = refusalError({ status: response.status, body: data }, {
+        exactReview: input.exactReview,
+        retryAfter,
+        correlationId,
+        mutation: "not_submitted"
+      });
+      const retryable = !mutation && RETRYABLE_STATUS.has(response.status) && attempts < MAX_READ_ATTEMPTS;
+      if (!retryable) throw refusal;
+      const waitMs = retryAfter === null ? null : retryAfter * 1e3;
+      const left2 = remaining();
+      if (waitMs !== null && waitMs >= left2) throw refusal;
+      if (waitMs === null && left2 <= BASE_BACKOFF_MS) throw refusal;
+      try {
+        await backoff(attempts, waitMs, left2, input.signal);
+      } catch (cause) {
+        if (cause instanceof ManagementError) throw cause;
+        throw refusal;
+      }
+    }
+  }
+  async function backoff(attempt, waitMs, left, requestSignal) {
+    const planned = waitMs ?? Math.min(MAX_BACKOFF_MS, BASE_BACKOFF_MS * 2 ** (attempt - 1));
+    const signals = [callerSignal, requestSignal].filter((value) => value !== void 0);
+    const signal = signals.length === 0 ? new AbortController().signal : AbortSignal.any(signals);
+    try {
+      await sleep(Math.min(planned, Math.max(0, left - 1)), signal);
+    } catch (cause) {
+      if (cancelled(requestSignal)) throw interrupted();
+      throw cause;
+    }
+  }
+  return {
+    origin: origin.origin,
+    request,
+    get(path, options = {}) {
+      return request({ ...options, method: "GET", path });
+    }
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_POLL_INTERVAL_MS = 15e3;
+function defaultSleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason instanceof Error ? signal.reason : new Error("aborted"));
+    };
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function poll(attempt, options) {
+  const { deadlineMs } = options;
+  if (!Number.isFinite(deadlineMs) || deadlineMs <= 0) {
+    throw invalidInput("A wait needs a positive, finite --timeout in seconds. Nothing was sent.");
+  }
+  const now = options.now ?? (() => Date.now());
+  const sleep = options.sleep ?? defaultSleep2;
+  const base = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const ceiling = options.maxIntervalMs ?? DEFAULT_MAX_POLL_INTERVAL_MS;
+  const signal = options.signal ?? new AbortController().signal;
+  const startedAt = now();
+  const elapsed = () => now() - startedAt;
+  const remaining = () => deadlineMs - elapsed();
+  let attempts = 0;
+  let last = null;
+  for (; ; ) {
+    if (signal.aborted) throw interrupted();
+    const left = remaining();
+    if (left <= 0) return { timed_out: true, last, attempts, elapsed_ms: elapsed() };
+    attempts += 1;
+    let step;
+    try {
+      step = await attempt({ signal, deadlineMs: left, attempt: attempts });
+    } catch (cause) {
+      if (signal.aborted) throw interrupted();
+      if (remaining() > 0 || isManagementError(cause) && cause.detail.code === "interrupted") throw cause;
+      return { timed_out: true, last, attempts, elapsed_ms: elapsed() };
+    }
+    last = step.value;
+    if (step.done) return { timed_out: false, last, attempts, elapsed_ms: elapsed() };
+    const before = remaining();
+    if (before <= 0) return { timed_out: true, last, attempts, elapsed_ms: elapsed() };
+    const wait = Math.min(base * 2 ** (attempts - 1), ceiling, before);
+    try {
+      await sleep(wait, signal);
+    } catch (cause) {
+      if (signal.aborted) throw interrupted();
+      throw cause;
+    }
+  }
+}
+async function resolveTarget(client, request = {}) {
+  if (request.site !== void 0 && request.site.trim() === "") throw invalidInput("--site needs a site id.");
+  if (request.mutation === true && request.site === void 0) {
+    throw invalidInput("This command writes, so it needs an explicit --site naming the site to act on.");
+  }
+  const response = await client.get("/v1/sites", { signal: request.signal, deadlineMs: request.deadlineMs });
+  const parsed = SitesResponse2.safeParse(response.data);
+  if (!parsed.success) {
+    throw managementError(
+      "transport_failure",
+      "The site listing did not come back in the shape this client understands, so the target could not be verified.",
+      { mutation: "not_submitted" }
+    );
+  }
+  const sites = parsed.data.sites.map((site) => site.site_id);
+  const current = parsed.data.current;
+  if (request.site === void 0) return { site_id: current, current, sites, explicit: false };
+  if (request.site !== current && !sites.includes(request.site)) {
+    throw invalidInput(`This credential acts on ${current}, not ${request.site}. Nothing was sent. Use --site ${current}, or a credential for ${request.site}.`);
+  }
+  if (request.mutation === true && request.site !== current) {
+    throw invalidInput(`This credential's own site is ${current}, so it may not write to ${request.site}. Nothing was sent.`);
+  }
+  return { site_id: request.site, current, sites, explicit: true };
+}
+var COMMAND_SCHEMA_VERSION = "saturndocs.cli.schema/v1";
+function selectorFor(name) {
+  return name.replace(/ /gu, ".");
+}
+var TEXT_SOURCES = ["--text", "--file", "--data", "stdin"];
+var SITE_RULES = ["required", "inferred", "none"];
+var IDEMPOTENCY_KINDS = ["none", "submission_id", "expected_review"];
+var FlagSpecSchema = z4.object({
+  name: z4.string().regex(/^--[a-z][a-z0-9-]*$/u),
+  value: z4.enum(["string", "integer", "boolean"]),
+  required: z4.boolean(),
+  description: z4.string().min(1)
+});
+var ExitCodeSchema = z4.union(EXIT_CODES.map((code) => z4.literal(code)));
+var CommandMetadataSchema = z4.object({
+  name: z4.string().min(1),
+  selector: z4.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/u),
+  group: z4.string().min(1),
+  summary: z4.string().min(1),
+  description: z4.string().min(1),
+  text: z4.object({
+    requirement: z4.enum(["none", "required", "optional"]),
+    limit: z4.number().int().positive().nullable(),
+    sources: z4.array(z4.enum(TEXT_SOURCES))
+  }),
+  target: z4.object({
+    site: z4.enum(SITE_RULES),
+    arguments: z4.array(z4.object({ name: z4.string().min(1), required: z4.boolean(), description: z4.string().min(1) }))
+  }),
+  permissions: z4.object({
+    server: z4.enum(MANAGEMENT_SCOPES2).nullable(),
+    preflight: z4.enum(MANAGEMENT_SCOPES2).nullable()
+  }),
+  side_effects: z4.object({
+    mutation: z4.boolean(),
+    effect: z4.string().min(1),
+    idempotency: z4.enum(IDEMPOTENCY_KINDS)
+  }),
+  flags: z4.array(FlagSpecSchema),
+  output: z4.object({
+    fields: z4.array(z4.string().min(1)),
+    ids: z4.array(z4.string().min(1)),
+    limitations: z4.array(z4.enum(LIMITATION_CODES))
+  }),
+  errors: z4.array(z4.enum(CLIENT_ERROR_CODES)).min(1),
+  exits: z4.array(ExitCodeSchema).min(1),
+  examples: z4.array(z4.object({ command: z4.string().min(1), description: z4.string().min(1) })).min(1)
+}).superRefine((value, ctx) => {
+  if (selectorFor(value.name) !== value.selector) {
+    ctx.addIssue({ code: "custom", message: `${value.name} is spoken as ${selectorFor(value.name)}, not ${value.selector}` });
+  }
+  if (!value.name.startsWith(value.group)) {
+    ctx.addIssue({ code: "custom", message: `${value.name} is not a command of the ${value.group} group` });
+  }
+  if (value.text.requirement === "none" !== (value.text.sources.length === 0)) {
+    ctx.addIssue({ code: "custom", message: `${value.name} declares text sources that disagree with its text requirement` });
+  }
+  if (value.side_effects.mutation && value.target.site !== "required") {
+    ctx.addIssue({ code: "custom", message: `${value.name} mutates and would accept whatever site the credential named` });
+  }
+  for (const example of value.examples) {
+    if (!example.command.startsWith(`saturndocs ${value.name}`)) {
+      ctx.addIssue({ code: "custom", message: `an example of ${value.name} runs ${example.command}` });
+    }
+  }
+});
+var TEXT_FLAGS = /* @__PURE__ */ new Set(["--text", "--file"]);
+function textSpec(requirement, limit2, flags) {
+  if (requirement === "none") return { requirement, limit: null, sources: [] };
+  const sources = [];
+  for (const flag of flags) {
+    if (flag.name === "--text") sources.push("--text");
+    if (flag.name === "--file") sources.push("--file", "stdin");
+  }
+  return { requirement, limit: limit2, sources: Object.freeze(sources) };
+}
+function commandMetadata(name, details) {
+  const spec = commandSpec(name);
+  if (spec === void 0) {
+    throw new Error(`${name} has no entry in the frozen P0 command surface; add it there before giving it metadata.`);
+  }
+  const flags = Object.freeze([...spec.flags, ...GLOBAL_FLAGS.filter((flag) => !spec.flags.some((own) => own.name === flag.name))]);
+  const textFlags = spec.flags.filter((flag) => TEXT_FLAGS.has(flag.name));
+  return Object.freeze({
+    name: spec.name,
+    selector: selectorFor(spec.name),
+    group: spec.name.split(" ")[0],
+    summary: spec.summary,
+    description: details.description,
+    text: details.text_sources === void 0 ? textSpec(spec.text_input, spec.text_limit, textFlags) : Object.freeze({ requirement: spec.text_input, limit: spec.text_input === "none" ? null : spec.text_limit, sources: Object.freeze([...details.text_sources]) }),
+    target: Object.freeze({
+      site: spec.requires_site ? "required" : spec.permission === null ? "none" : "inferred",
+      arguments: Object.freeze([...details.target.arguments])
+    }),
+    permissions: Object.freeze({
+      server: spec.permission,
+      preflight: spec.mutation ? "manage:read" : null
+    }),
+    side_effects: Object.freeze({
+      mutation: spec.mutation,
+      effect: details.effect,
+      idempotency: details.idempotency ?? "none"
+    }),
+    flags,
+    output: Object.freeze({
+      fields: Object.freeze([...details.output.fields]),
+      ids: Object.freeze([...details.output.ids]),
+      limitations: Object.freeze([...details.output.limitations])
+    }),
+    errors: Object.freeze([...details.errors]),
+    exits: Object.freeze([...spec.exits]),
+    examples: Object.freeze([...details.examples])
+  });
+}
+function parseResponse(schema, data, what) {
+  const parsed = schema.safeParse(data);
+  if (!parsed.success) {
+    throw managementError("transport_failure", `${what} did not come back in the shape this client understands, so nothing was reported from it.`, {
+      mutation: "not_submitted"
+    });
+  }
+  return parsed.data;
+}
+async function listSites(client, options = {}) {
+  const response = await client.get(operationPath("sites.list", ""), options);
+  return parseResponse(SitesResponse2, response.data, "The site listing");
+}
+async function getSite(client, siteId, options = {}) {
+  const response = await client.get(operationPath("site.get", siteId), options);
+  return parseResponse(PortalSite2, response.data, `The site read for ${siteId}`);
+}
+async function getDocsRepo(client, siteId, options = {}) {
+  const response = await client.get(operationPath("docs-repo.get", siteId), options);
+  return parseResponse(DocsRepoSettings2, response.data, `The documentation repository read for ${siteId}`);
+}
+async function listProductConnections(client, siteId, options = {}) {
+  const response = await client.get(operationPath("product-connections.list", siteId), options);
+  return parseResponse(ProductConnectionsResponse2, response.data, `The watched repositories read for ${siteId}`);
+}
+async function readSiteDetail(client, siteId, options = {}) {
+  const { connections = false, ...read } = options;
+  if (!connections) return { site_id: siteId, site: await getSite(client, siteId, read), connections: null };
+  const [site, docsRepo, productConnections] = await Promise.all([
+    getSite(client, siteId, read),
+    getDocsRepo(client, siteId, read),
+    listProductConnections(client, siteId, read)
+  ]);
+  return { site_id: siteId, site, connections: { docs_repo: docsRepo, product_connections: productConnections } };
+}
+var PAGE_TRAFFIC_WINDOWS = [7, 30, 90];
+function pagesUnavailable(result) {
+  return "unavailable" in result;
+}
+async function listPages(client, siteId, options = {}) {
+  const { days, ...read } = options;
+  if (days !== void 0 && !PAGE_TRAFFIC_WINDOWS.includes(days)) {
+    throw invalidInput(`--days takes ${PAGE_TRAFFIC_WINDOWS.join(", ")}. The server keeps no other traffic window.`);
+  }
+  const response = await client.get(operationPath("pages.list", siteId), {
+    ...read,
+    ...days === void 0 ? {} : { query: { days } }
+  });
+  return parseResponse(PagesResponse2, response.data, `The published page listing for ${siteId}`);
+}
+var ActivityPageRead = ActivityPage2.extend({ events: z5.array(ActivityEvent.loose()) });
+var ACTIVITY_OUTCOMES = ACTIVITY_OUTCOME_FILTERS;
+var BOUNDS = operationOf("activity.list").query;
+function boundOf(name) {
+  const bound2 = BOUNDS.find((entry) => entry.name === name);
+  if (bound2 === void 0) throw new Error(`The frozen activity.list operation declares no ${name} bound.`);
+  return bound2;
+}
+var ACTIVITY_LIMIT_CEILING = boundOf("limit").max ?? 100;
+var ACTIVITY_REPO_MAX_CHARS = boundOf("repo").max ?? 200;
+var ACTIVITY_JOB_ID_MAX_CHARS = boundOf("job_id").max ?? 200;
+var UTC_DATE = z5.iso.date();
+function dateFilter(name, value) {
+  if (!UTC_DATE.safeParse(value).success) {
+    throw invalidInput(`--${name} takes an inclusive UTC date as YYYY-MM-DD; ${value} is not one.`);
+  }
+  return value;
+}
+function activityQuery(filters) {
+  const query = {};
+  if (filters.cursor !== void 0) {
+    if (filters.cursor === "") throw invalidInput("--cursor takes the next_cursor of the preceding page.");
+    query.cursor = filters.cursor;
+  }
+  if (filters.limit !== void 0) {
+    if (!Number.isInteger(filters.limit) || filters.limit < 1) throw invalidInput("--limit takes a whole number of events, at least 1.");
+    query.limit = filters.limit;
+  }
+  if (filters.outcome !== void 0) {
+    if (!ACTIVITY_OUTCOMES.includes(filters.outcome)) {
+      throw invalidInput(`--outcome takes ${ACTIVITY_OUTCOMES.join(", ")}. The server filters on no others.`);
+    }
+    query.outcome = filters.outcome;
+  }
+  if (filters.repo !== void 0) {
+    if (filters.repo === "" || filters.repo.length > ACTIVITY_REPO_MAX_CHARS) {
+      throw invalidInput(`--repo takes a full repository name of 1 to ${ACTIVITY_REPO_MAX_CHARS} characters, such as example/docs.`);
+    }
+    query.repo = filters.repo;
+  }
+  if (filters.from !== void 0) query.from = dateFilter("from", filters.from);
+  if (filters.to !== void 0) query.to = dateFilter("to", filters.to);
+  if (query.from !== void 0 && query.to !== void 0 && String(query.from) > String(query.to)) {
+    throw invalidInput(`--from ${String(query.from)} is later than --to ${String(query.to)}, which can only ever match nothing. Nothing was read.`);
+  }
+  return query;
+}
+async function listActivity(client, siteId, options = {}) {
+  const { cursor: cursor2, limit: limit2, outcome, repo, from, to, ...read } = options;
+  const query = activityQuery({ cursor: cursor2, limit: limit2, outcome, repo, from, to });
+  const response = await client.get(operationPath("activity.list", siteId), {
+    ...read,
+    ...Object.keys(query).length === 0 ? {} : { query }
+  });
+  return parseResponse(ActivityPageRead, response.data, `The activity listing for ${siteId}`);
+}
+function activityJobFound(read) {
+  return read.event !== null;
+}
+async function readActivityJob(client, siteId, jobId, options = {}) {
+  if (jobId === "" || jobId.length > ACTIVITY_JOB_ID_MAX_CHARS) {
+    throw invalidInput(`A job id is 1 to ${ACTIVITY_JOB_ID_MAX_CHARS} characters; the server mints no others.`);
+  }
+  const response = await client.get(operationPath("activity.list", siteId), { ...options, query: { job_id: jobId } });
+  const page = parseResponse(ActivityPageRead, response.data, `The activity read of ${jobId}`);
+  return { site_id: page.site_id, job_id: jobId, event: page.events[0] ?? null };
+}
+var MAX_LIMIT = 50;
+function isTab(value) {
+  return SUGGESTION_TABS.includes(value);
+}
+function parseTab(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (!isTab(trimmed)) {
+    throw invalidInput(`--state takes one of ${SUGGESTION_TABS.join(", ")}; ${value} is not a suggestion tab.`);
+  }
+  return trimmed;
+}
+function parseCursor(value) {
+  if (value === void 0) return void 0;
+  if (value.trim() === "") throw invalidInput("--cursor needs the next_cursor of the preceding page.");
+  return value;
+}
+function parseLimit(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) {
+    throw invalidInput(`--limit takes a whole number from 1 to ${MAX_LIMIT}.`);
+  }
+  return value;
+}
+function unreadable(what) {
+  throw managementError("transport_failure", `The ${what} did not come back in the shape this client understands, so nothing is reported rather than a partial reading of it.`);
+}
+async function listSuggestions(client, input) {
+  const state = parseTab(input.state);
+  const response = await client.get(resourcePath(input.site, ["suggestions"]), {
+    query: { state, cursor: parseCursor(input.cursor), limit: parseLimit(input.limit) },
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = SuggestionsPage2.safeParse(response.data);
+  if (!parsed.success) unreadable("suggestion listing");
+  return parsed.data;
+}
+async function getSuggestion(client, input) {
+  if (input.suggestionId.trim() === "") throw invalidInput("Name the suggestion to read, as saturndocs suggestions get <suggestion-id>.");
+  const response = await client.get(resourcePath(input.site, ["suggestions", input.suggestionId]), {
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = SuggestionDetailResponse2.safeParse(response.data);
+  if (!parsed.success) unreadable("suggestion detail");
+  return parsed.data;
+}
+function suggestionIds(suggestion) {
+  const ids = { suggestion_id: suggestion.suggestion_id, base_sha: suggestion.base_sha, pr_number: suggestion.pr_number };
+  if (typeof suggestion.head_sha === "string") ids.head_sha = suggestion.head_sha;
+  if (typeof suggestion.request_thread_id === "string") ids.thread_id = suggestion.request_thread_id;
+  const jobId = suggestion.publication?.job_id ?? suggestion.job_id;
+  if (typeof jobId === "string") ids.job_id = jobId;
+  const releaseId = suggestion.publication?.release_id;
+  if (typeof releaseId === "string") ids.release_id = releaseId;
+  return ids;
+}
+function pageContentAvailable(suggestion) {
+  const pages = suggestion.pages ?? [];
+  if (pages.length === 0) return false;
+  return pages.some((page) => (page.diff?.length ?? 0) > 0 || typeof page.before === "string" || typeof page.after === "string");
+}
+function suggestionLimitations(suggestion) {
+  const limitations = [];
+  if (typeof suggestion.head_edited_by === "string" && suggestion.head_edited_by !== "") {
+    limitations.push({
+      code: "hand_edited",
+      message: `The head of this suggestion was edited on GitHub by ${suggestion.head_edited_by}, so what publishes is not only what the agent drafted. Read ${suggestion.files_changed_url ?? "the pull request"} before approving.`,
+      at: "suggestion.head_sha"
+    });
+  }
+  if (suggestion.snapshots_available === false || suggestion.pages !== void 0 && !pageContentAvailable(suggestion)) {
+    limitations.push({
+      code: "content_unavailable",
+      message: "The server did not supply page content for this revision, so the changed pages are listed without their text. This is not a suggestion that changes nothing.",
+      at: "suggestion.pages"
+    });
+  }
+  if (typeof suggestion.files_changed_url !== "string" || suggestion.files_changed_url === "") {
+    limitations.push({
+      code: "section_unavailable",
+      message: "No pull-request URL was recorded for this suggestion, so there is no GitHub diff to compare this reading against.",
+      at: "suggestion.files_changed_url"
+    });
+  }
+  return Object.freeze(limitations);
+}
+var DEFAULT_DIFF_MAX_BYTES = 64 * 1024;
+var CONTEXT_LINES = 3;
+var MAX_CELLS = 4e5;
+var MAX_INPUT_LINES = 3e3;
+function splitLines(text) {
+  if (text === "") return [];
+  const normalized = text.replace(/\r\n?/gu, "\n");
+  return (normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized).split("\n");
+}
+function lcsChanges(before, after) {
+  const cols = after.length + 1;
+  const table = new Int32Array((before.length + 1) * cols);
+  for (let i2 = before.length - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = after.length - 1; j2 >= 0; j2 -= 1) {
+      table[i2 * cols + j2] = before[i2] === after[j2] ? table[(i2 + 1) * cols + j2 + 1] + 1 : Math.max(table[(i2 + 1) * cols + j2], table[i2 * cols + j2 + 1]);
+    }
+  }
+  const changes = [];
+  let i = 0;
+  let j = 0;
+  while (i < before.length && j < after.length) {
+    if (before[i] === after[j]) {
+      changes.push({ op: "context", text: before[i] });
+      i += 1;
+      j += 1;
+    } else if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) {
+      changes.push({ op: "del", text: before[i] });
+      i += 1;
+    } else {
+      changes.push({ op: "add", text: after[j] });
+      j += 1;
+    }
+  }
+  for (; i < before.length; i += 1) changes.push({ op: "del", text: before[i] });
+  for (; j < after.length; j += 1) changes.push({ op: "add", text: after[j] });
+  return changes;
+}
+function collapseContext(rows) {
+  const keep = new Array(rows.length).fill(false);
+  for (let index = 0; index < rows.length; index += 1) {
+    if (rows[index].op === "context") continue;
+    for (let near = Math.max(0, index - CONTEXT_LINES); near <= Math.min(rows.length - 1, index + CONTEXT_LINES); near += 1) keep[near] = true;
+  }
+  const out = [];
+  let skipped = 0;
+  for (let index = 0; index < rows.length; index += 1) {
+    if (keep[index] === true) {
+      if (skipped > 0) {
+        out.push({ op: "skip", before_line: null, after_line: null, text: null, count: skipped });
+        skipped = 0;
+      }
+      out.push(rows[index]);
+      continue;
+    }
+    skipped += 1;
+  }
+  if (skipped > 0) out.push({ op: "skip", before_line: null, after_line: null, text: null, count: skipped });
+  return out;
+}
+function compareContent(before, after) {
+  const beforeAll = splitLines(before);
+  const afterAll = splitLines(after);
+  const overLength = beforeAll.length > MAX_INPUT_LINES || afterAll.length > MAX_INPUT_LINES;
+  const beforeLines = beforeAll.slice(0, MAX_INPUT_LINES);
+  const afterLines = afterAll.slice(0, MAX_INPUT_LINES);
+  let head = 0;
+  while (head < beforeLines.length && head < afterLines.length && beforeLines[head] === afterLines[head]) head += 1;
+  let tail = 0;
+  while (tail < beforeLines.length - head && tail < afterLines.length - head && beforeLines[beforeLines.length - 1 - tail] === afterLines[afterLines.length - 1 - tail]) tail += 1;
+  const midBefore = beforeLines.slice(head, beforeLines.length - tail);
+  const midAfter = afterLines.slice(head, afterLines.length - tail);
+  const changes = beforeLines.slice(0, head).map((text) => ({ op: "context", text }));
+  let truncated = overLength;
+  if ((midBefore.length + 1) * (midAfter.length + 1) > MAX_CELLS) {
+    truncated = true;
+    for (const text of midBefore) changes.push({ op: "del", text });
+    for (const text of midAfter) changes.push({ op: "add", text });
+  } else {
+    changes.push(...lcsChanges(midBefore, midAfter));
+  }
+  for (const text of beforeLines.slice(beforeLines.length - tail)) changes.push({ op: "context", text });
+  const numbered = [];
+  let beforeNumber = 0;
+  let afterNumber = 0;
+  let added = 0;
+  let removed = 0;
+  for (const change of changes) {
+    if (change.op === "context") {
+      beforeNumber += 1;
+      afterNumber += 1;
+      numbered.push({ op: "context", before_line: beforeNumber, after_line: afterNumber, text: change.text, count: null });
+    } else if (change.op === "del") {
+      beforeNumber += 1;
+      removed += 1;
+      numbered.push({ op: "del", before_line: beforeNumber, after_line: null, text: change.text, count: null });
+    } else {
+      afterNumber += 1;
+      added += 1;
+      numbered.push({ op: "add", before_line: null, after_line: afterNumber, text: change.text, count: null });
+    }
+  }
+  return { rows: collapseContext(numbered), added, removed, truncated };
+}
+function serverRows(page) {
+  return (page.diff ?? []).map((line) => ({
+    op: line.op,
+    before_line: line.before_line ?? null,
+    after_line: line.after_line ?? null,
+    text: line.text ?? null,
+    count: line.count ?? null
+  }));
+}
+var has = (value) => typeof value === "string";
+function pageDiff(page) {
+  const base = {
+    path: page.path,
+    op: page.op,
+    reason: page.reason ?? null,
+    url: page.url ?? null,
+    truncated: page.truncated === true,
+    omitted_rows: 0,
+    has_before: has(page.before),
+    has_after: has(page.after)
+  };
+  const supplied = serverRows(page);
+  if (supplied.length > 0) {
+    return { ...base, availability: "server_diff", source: "server", added_lines: page.added_lines ?? null, removed_lines: page.removed_lines ?? null, rows: supplied };
+  }
+  if (has(page.before) && has(page.after)) {
+    const local = compareContent(page.before, page.after);
+    return { ...base, availability: "computed", source: "local", added_lines: local.added, removed_lines: local.removed, truncated: base.truncated || local.truncated, rows: local.rows };
+  }
+  if (page.op === "delete" && has(page.before)) {
+    const local = compareContent(page.before, "");
+    return { ...base, availability: "deletion", source: "local", added_lines: local.added, removed_lines: local.removed, truncated: base.truncated || local.truncated, rows: local.rows };
+  }
+  if (page.op === "create" && has(page.after)) {
+    const local = compareContent("", page.after);
+    return { ...base, availability: "creation", source: "local", added_lines: local.added, removed_lines: local.removed, truncated: base.truncated || local.truncated, rows: local.rows };
+  }
+  if (has(page.before) || has(page.after)) {
+    return { ...base, availability: "partial", source: "none", added_lines: null, removed_lines: null, rows: [] };
+  }
+  return { ...base, availability: "unavailable", source: "none", added_lines: null, removed_lines: null, rows: [] };
+}
+function rowBytes(row) {
+  return new TextEncoder().encode(row.text ?? "").length + 8;
+}
+function bound(pages, maxBytes) {
+  const out = [];
+  let used = 0;
+  let omitted = 0;
+  for (const page of pages) {
+    used += new TextEncoder().encode(page.path).length + 16;
+    const kept = [];
+    let dropped = 0;
+    for (const row of page.rows) {
+      if (dropped > 0 || used + rowBytes(row) > maxBytes) {
+        dropped += 1;
+        continue;
+      }
+      used += rowBytes(row);
+      kept.push(row);
+    }
+    if (dropped > 0) kept.push({ op: "omitted", before_line: null, after_line: null, text: null, count: dropped });
+    omitted += dropped;
+    out.push({ ...page, rows: kept, omitted_rows: dropped });
+  }
+  return { pages: out, used, omitted };
+}
+var HANDOFF = "This is the content the server supplied, formatted here. Nothing in it was checked against the product, so it is a starting point for an owner's review, not a completed one.";
+function limitationsFor(suggestion, pages, omitted, limit2) {
+  const limitations = [
+    { code: "review_incomplete", message: HANDOFF, at: null }
+  ];
+  pages.forEach((page, index) => {
+    const at = `pages[${index}]`;
+    if (page.availability === "unavailable") {
+      limitations.push({ code: "content_unavailable", message: `Neither side of ${page.path} was supplied, so this page has no diff at all. An empty diff here would read as a page that does not change.`, at });
+    }
+    if (page.availability === "partial") {
+      const missing = page.has_before ? "after" : "before";
+      limitations.push({ code: "content_unavailable", message: `The ${missing} side of ${page.path} was not supplied, so this ${page.op} cannot be compared. Nothing is shown for it rather than half of it read as the whole change.`, at });
+    }
+    if (page.truncated) {
+      limitations.push({ code: "page_bounded", message: `The comparison of ${page.path} hit a size bound, so this diff is part of the change and not all of it.`, at });
+    }
+  });
+  if (omitted > 0) {
+    limitations.push({ code: "output_truncated", message: `${omitted} diff lines were left out to stay inside the ${limit2}-byte output bound. Read one page at a time with --path, or read the pull request.`, at: null });
+  }
+  if (typeof suggestion.head_edited_by === "string" && suggestion.head_edited_by !== "") {
+    limitations.push({ code: "hand_edited", message: `The head was edited on GitHub by ${suggestion.head_edited_by} after the draft, so this diff of the supplied content may not be what would publish.`, at: "head_sha" });
+  }
+  if (typeof suggestion.files_changed_url !== "string" || suggestion.files_changed_url === "") {
+    limitations.push({ code: "section_unavailable", message: "No pull-request URL was recorded, so this reading cannot be checked against GitHub's own diff.", at: "files_changed_url" });
+  }
+  return limitations;
+}
+function suggestionDiff(suggestion, options = {}) {
+  const limit2 = options.maxBytes ?? DEFAULT_DIFF_MAX_BYTES;
+  const all = suggestion.pages ?? [];
+  const selected = options.path === void 0 ? all : all.filter((page) => page.path === options.path);
+  if (options.path !== void 0 && selected.length === 0) {
+    const known = all.map((page) => page.path);
+    throw invalidInput(
+      known.length === 0 ? `This suggestion lists no changed pages, so --path ${options.path} names nothing to diff.` : `--path ${options.path} is not a page this suggestion changes. It changes: ${known.join(", ")}.`
+    );
+  }
+  const computed = selected.map((page) => pageDiff(page));
+  const bounded = bound(computed, limit2);
+  return {
+    suggestion_id: suggestion.suggestion_id,
+    base_sha: suggestion.base_sha,
+    head_sha: suggestion.head_sha ?? null,
+    revision: suggestion.revision ?? null,
+    files_changed_url: suggestion.files_changed_url ?? null,
+    pages: Object.freeze(bounded.pages),
+    bytes: { limit: limit2, used: bounded.used, omitted: bounded.omitted },
+    review: { complete: false, handoff: HANDOFF },
+    limitations: Object.freeze(limitationsFor(suggestion, bounded.pages, bounded.omitted, limit2))
+  };
+}
+function rowText(row) {
+  if (row.op === "skip") return `@@ ${row.count ?? 0} unchanged lines @@`;
+  if (row.op === "omitted") return `... ${row.count ?? 0} lines omitted by the output bound ...`;
+  const marker = row.op === "add" ? "+" : row.op === "del" ? "-" : " ";
+  return `${marker}${row.text ?? ""}`;
+}
+var AVAILABILITY_TEXT = Object.freeze({
+  server_diff: "diff supplied by the server",
+  computed: "compared here from the supplied before and after",
+  creation: "new page; there is no before",
+  deletion: "page removed; there is no after",
+  partial: "only one side was supplied; not comparable",
+  unavailable: "neither side was supplied; nothing to compare"
+});
+function renderDiffText(result) {
+  const out = [
+    `suggestion ${result.suggestion_id} revision ${result.revision ?? "unknown"}`,
+    `base ${result.base_sha}`,
+    `head ${result.head_sha ?? "unknown"}`,
+    `files changed: ${result.files_changed_url ?? "no pull-request URL was recorded"}`,
+    ""
+  ];
+  if (result.pages.length === 0) out.push("This suggestion lists no changed pages.", "");
+  for (const page of result.pages) {
+    out.push(`--- a/${page.path}`, `+++ b/${page.path}`, `# ${page.op}: ${AVAILABILITY_TEXT[page.availability]}`);
+    if (page.reason !== null) out.push(`# reason: ${page.reason}`);
+    for (const row of page.rows) out.push(rowText(row));
+    out.push("");
+  }
+  for (const limitation of result.limitations) out.push(`note (${limitation.code}): ${limitation.message}`);
+  return out.join("\n");
+}
+var DISMISS_REASONS = Object.freeze([...DismissInput.shape.reason.options]);
+function requireSuggestionId(value, usage) {
+  if (value.trim() === "") throw invalidInput(`Name the suggestion to act on, as ${usage}.`);
+  return value;
+}
+function parseDismissReason(value) {
+  if (typeof value !== "string" || !DISMISS_REASONS.includes(value)) {
+    throw invalidInput(`--reason takes one of ${DISMISS_REASONS.join(", ")}; the server stores no other reason.`);
+  }
+  return value;
+}
+function staleReview(error, reviewed, verb) {
+  const message = `Nothing was ${verb}: the server did not find this suggestion at the revision that was reviewed (base ${reviewed.base_sha}, head ${reviewed.head_sha}). A head that moved after the review is answered the same way as an id this site does not have, so read the suggestion again and review what it holds now. Sending this again with the current hashes would act on a revision nobody has read.`;
+  return new ManagementError(clientError("stale_review", message, { server: error.detail.server }), { cause: error });
+}
+function withStaleReview(promise, reviewed, verb) {
+  return promise.catch((error) => {
+    if (isManagementError(error) && error.detail.code === "stale_review") throw staleReview(error, reviewed, verb);
+    throw error;
+  });
+}
+function unreadable2(what) {
+  throw managementError(
+    "unknown_outcome",
+    `The ${what} was accepted and its answer was not in the shape this client understands, so what happened is not reported here. Read the suggestion before sending anything again.`
+  );
+}
+function optionalNumber(value) {
+  return typeof value === "number" ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+async function approveSuggestion(client, input) {
+  const suggestionId = requireSuggestionId(input.suggestionId, "saturndocs suggestions approve <suggestion-id>");
+  const reviewed = parseReviewedRevision(input.base, input.head);
+  const response = await withStaleReview(
+    client.request({
+      method: "POST",
+      path: resourcePath(input.site, ["suggestions", suggestionId, "approve"]),
+      body: { expected_base_sha: reviewed.base_sha, expected_head_sha: reviewed.head_sha },
+      exactReview: true,
+      signal: input.signal,
+      deadlineMs: input.deadlineMs
+    }),
+    reviewed,
+    "approved"
+  );
+  const parsed = ApproveOutcome2.safeParse(response.data);
+  if (!parsed.success) unreadable2("approval");
+  const outcome = parsed.data;
+  const state = outcome.state;
+  if (state === void 0) unreadable2("approval");
+  const limitations = [];
+  if (state === "revising") {
+    limitations.push({
+      code: "review_incomplete",
+      message: "The approval did not publish: it produced another revision, which nobody has reviewed. Read the new revision and review it before approving again.",
+      at: "state"
+    });
+  }
+  if (state === "publishing") {
+    limitations.push({
+      code: "activation_unknown",
+      message: "The merge was accepted and the build has started. Nothing here says a release went live; follow the suggestion or its release to find out whether readers see the change.",
+      at: "state"
+    });
+  }
+  return {
+    suggestion_id: suggestionId,
+    base_sha: reviewed.base_sha,
+    head_sha: reviewed.head_sha,
+    state,
+    published: false,
+    publication_started: state === "publishing",
+    review_required: state === "revising",
+    pr_number: optionalNumber(outcome.pr_number),
+    merge_commit_sha: optionalString(outcome.merge_commit_sha),
+    failure: state === "failed" ? { code: optionalString(outcome.failure) ?? optionalString(outcome.error), reason: optionalString(outcome.failure_reason) ?? optionalString(outcome.message) ?? optionalString(outcome.reason) } : null,
+    outcome,
+    limitations: Object.freeze(limitations)
+  };
+}
+async function dismissSuggestion(client, input) {
+  const suggestionId = requireSuggestionId(input.suggestionId, "saturndocs suggestions dismiss <suggestion-id>");
+  const reviewed = parseReviewedRevision(input.base, input.head);
+  const reason = parseDismissReason(input.reason);
+  const note = input.note === void 0 || input.note === null || input.note === "" ? void 0 : input.note;
+  const body = DismissInput.safeParse({
+    expected_base_sha: reviewed.base_sha,
+    expected_head_sha: reviewed.head_sha,
+    reason,
+    ...note === void 0 ? {} : { note }
+  });
+  if (!body.success) {
+    throw invalidInput(`The dismissal note is longer than the server accepts, so nothing was sent.`);
+  }
+  const response = await withStaleReview(
+    client.request({
+      method: "POST",
+      path: resourcePath(input.site, ["suggestions", suggestionId, "dismiss"]),
+      body: body.data,
+      exactReview: true,
+      signal: input.signal,
+      deadlineMs: input.deadlineMs
+    }),
+    reviewed,
+    "dismissed"
+  );
+  const parsed = DismissOutcome2.safeParse(response.data);
+  if (!parsed.success) unreadable2("dismissal");
+  const outcome = parsed.data;
+  if (outcome.state !== "dismissed") unreadable2("dismissal");
+  const prNumber = optionalNumber(outcome.pr_number);
+  const closed = typeof outcome.pull_request_closed === "boolean" ? outcome.pull_request_closed : null;
+  const limitations = [];
+  if (closed === false) {
+    limitations.push({
+      code: "cleanup_incomplete",
+      message: `The suggestion is dismissed and its pull request${prNumber === null ? "" : ` #${prNumber}`} is still open. Close it on GitHub; nothing here will close it.`,
+      at: "pull_request_closed"
+    });
+  } else if (closed === null && prNumber !== null) {
+    limitations.push({
+      code: "cleanup_incomplete",
+      message: `The suggestion is dismissed and the server did not say whether pull request #${prNumber} was closed. Check it on GitHub rather than reading silence as a closed one.`,
+      at: "pull_request_closed"
+    });
+  }
+  return {
+    suggestion_id: suggestionId,
+    base_sha: reviewed.base_sha,
+    head_sha: reviewed.head_sha,
+    state: "dismissed",
+    reason,
+    pr_number: prNumber,
+    pull_request_closed: closed,
+    cleanup_complete: limitations.length === 0,
+    outcome,
+    limitations: Object.freeze(limitations)
+  };
+}
+function reviewDecisionIds(result) {
+  return {
+    suggestion_id: result.suggestion_id,
+    base_sha: result.base_sha,
+    head_sha: result.head_sha,
+    pr_number: result.pr_number
+  };
+}
+function optionalNumber2(value) {
+  return typeof value === "number" ? value : null;
+}
+function optionalString2(value) {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function unreadable3() {
+  throw managementError(
+    "unknown_outcome",
+    "The retry was accepted and its answer was not in a shape this client understands, so what it started is not reported here. Read the suggestion and its job before sending anything again."
+  );
+}
+function notRetryable(reason, server) {
+  const message = reason === null ? "Nothing was retried: the server refused this suggestion as not retryable and gave no reason. Read the suggestion before acting on it again." : `Nothing was retried: ${reason}`;
+  return new ManagementError(clientError("conflict", message, { server }));
+}
+function analysisResult(suggestionId, outcome) {
+  return {
+    kind: "analysis",
+    suggestion_id: suggestionId,
+    job_id: outcome.job_id,
+    attempt: outcome.attempt,
+    budget_tokens: outcome.budget_tokens ?? null,
+    completed: false,
+    outcome,
+    limitations: Object.freeze([])
+  };
+}
+function publicationResult(suggestionId, outcome, state) {
+  const limitations = [];
+  if (state === "revising") {
+    limitations.push({
+      code: "review_incomplete",
+      message: "The retry did not publish: it produced another revision, which nobody has reviewed. This is not an approval of that revision; read it and review it before approving anything.",
+      at: "state"
+    });
+  }
+  if (state === "publishing") {
+    limitations.push({
+      code: "activation_unknown",
+      message: "The merge was accepted and the build has started. Nothing here says a release went live; follow the suggestion or its release to find out whether readers see the change.",
+      at: "state"
+    });
+  }
+  return {
+    kind: "publication",
+    suggestion_id: suggestionId,
+    state,
+    published: false,
+    publication_started: state === "publishing",
+    review_required: state === "revising",
+    pr_number: optionalNumber2(outcome.pr_number),
+    merge_commit_sha: optionalString2(outcome.merge_commit_sha),
+    failure: state === "failed" ? {
+      code: optionalString2(outcome.failure) ?? optionalString2(outcome.error),
+      reason: optionalString2(outcome.failure_reason) ?? optionalString2(outcome.message) ?? optionalString2(outcome.reason)
+    } : null,
+    outcome,
+    limitations: Object.freeze(limitations)
+  };
+}
+async function retrySuggestion(client, input) {
+  const suggestionId = input.suggestionId.trim();
+  if (suggestionId === "") throw invalidInput("Name the suggestion to retry, as saturndocs suggestions retry <suggestion-id>.");
+  let response;
+  try {
+    response = await client.request({
+      method: "POST",
+      path: resourcePath(input.site, ["suggestions", suggestionId, "retry"]),
+      body: {},
+      signal: input.signal,
+      deadlineMs: input.deadlineMs
+    });
+  } catch (error) {
+    if (isManagementError(error) && error.detail.server?.code === "not_retryable") {
+      throw notRetryable(error.detail.server.message, error.detail.server);
+    }
+    throw error;
+  }
+  const analysis = AnalysisRetryAccepted.safeParse(response.data);
+  if (analysis.success) return analysisResult(suggestionId, analysis.data);
+  const refused = NotRetryable.safeParse(response.data);
+  if (refused.success) {
+    throw notRetryable(refused.data.reason ?? refused.data.message ?? null, serverFault({ status: response.status, body: response.data }));
+  }
+  const publication = PublicationRetryOutcome.safeParse(response.data);
+  if (!publication.success) unreadable3();
+  const state = publication.data.state;
+  if (state === void 0) unreadable3();
+  return publicationResult(suggestionId, publication.data, state);
+}
+function retryIds(result) {
+  return result.kind === "analysis" ? { suggestion_id: result.suggestion_id, job_id: result.job_id, attempt: result.attempt } : { suggestion_id: result.suggestion_id, pr_number: result.pr_number };
+}
+function boundOf2(name) {
+  const bound2 = operationOf("releases.list").query.find((entry) => entry.name === name);
+  if (bound2?.max === void 0) throw new Error(`releases.list declares no ceiling for ${name}`);
+  return bound2.max;
+}
+var RELEASE_PAGE_MAX = boundOf2("limit");
+var RELEASE_ID_MAX_CHARS = boundOf2("release_id");
+function activeStatusOf(page) {
+  return page.active_release_status === "known" ? "known" : "unknown";
+}
+var STATE_OF = Object.freeze({
+  published_active: "live",
+  published_historical: "historical",
+  published_activation_unknown: "unknown"
+});
+function summaryOf(release, state, active) {
+  if (state === "live") return `${release.release_id} is the release readers are seeing, activated ${release.activated_at ?? "at an unrecorded time"}.`;
+  if (state === "built") return `${release.release_id} was built and has no activation record, so it was never published.`;
+  if (state === "historical") {
+    const generation = release.generation === null ? "unrecorded" : String(release.generation);
+    return `${release.release_id} went live at ${String(release.activated_at)} (generation ${generation}) and is not what readers are seeing now${active === null ? "" : `; that is ${active}`}.`;
+  }
+  return `${release.release_id} went live at ${String(release.activated_at)}. The activation record could not be read, so whether it is live now is unknown.`;
+}
+function classifyReleaseActivation(release, page) {
+  const status = activeStatusOf(page);
+  const active = page.active_release_id;
+  const rule = classifyActivation({
+    release_id: release.release_id,
+    activated_at: release.activated_at,
+    active_release_id: active,
+    active_release_status: status
+  });
+  const state = STATE_OF[rule.outcome] ?? "built";
+  return {
+    state,
+    activated_at: release.activated_at,
+    generation: release.generation,
+    active_release_id: active,
+    active_release_status: status,
+    rule,
+    summary: summaryOf(release, state, active)
+  };
+}
+function checkBounds(options) {
+  if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > RELEASE_PAGE_MAX)) {
+    throw invalidInput(`--limit takes a whole number from 1 to ${RELEASE_PAGE_MAX}. The release route refuses anything else rather than trimming it.`);
+  }
+  if (options.cursor !== void 0 && options.cursor.trim() === "") throw invalidInput("--cursor needs the next_cursor of the preceding page.");
+}
+async function listReleases(client, siteId, options = {}) {
+  const { cursor: cursor2, limit: limit2, ...read } = options;
+  checkBounds(options);
+  const response = await client.get(operationPath("releases.list", siteId), {
+    ...read,
+    query: { ...cursor2 === void 0 ? {} : { cursor: cursor2 }, ...limit2 === void 0 ? {} : { limit: limit2 } }
+  });
+  return parseResponse(ReleasesPage2, response.data, `The release listing for ${siteId}`);
+}
+async function getRelease(client, siteId, releaseId, options = {}) {
+  const id = releaseId.trim();
+  if (id === "") throw invalidInput("Name the release to read.");
+  if (id.length > RELEASE_ID_MAX_CHARS) throw invalidInput(`A release id is at most ${RELEASE_ID_MAX_CHARS} characters; the route refuses a longer one as invalid_release_id.`);
+  const response = await client.get(operationPath("releases.list", siteId), { ...options, query: { release_id: id } });
+  const page = parseResponse(ReleasesPage2, response.data, `The release read for ${id} on ${siteId}`);
+  const release = page.releases[0];
+  if (release === void 0) {
+    throw managementError(
+      "not_found",
+      `${siteId} holds no release ${id}, or it is being deleted. This answer reports no release of that id and says nothing about which release the site is serving.`
+    );
+  }
+  return { site_id: page.site_id, release, activation: classifyReleaseActivation(release, page), page };
+}
+var DEFAULT_SUGGESTION_WAIT_MS = 10 * 6e4;
+var TIMEOUT_NOTE = "The deadline passed with the suggestion still moving. Nothing remote was cancelled or approved; it can be waited on again.";
+var HANDOFF_NOTE = "The server supplied no page content for this revision, so what would publish cannot be read here. Read the pull request before approving.";
+var UNREADABLE_RELEASE_NOTE = "The suggestion names a release the release history does not answer for yet, so nothing is claimed about activation.";
+var WAIT_ERROR_CODES = Object.freeze({
+  no_longer_reviewable: "conflict",
+  review_required: "conflict",
+  dismissed: "conflict",
+  superseded: "conflict",
+  failed: "remote_failure",
+  timed_out: "wait_timeout"
+});
+function suggestionWaitErrorCode(outcome) {
+  return WAIT_ERROR_CODES[outcome] ?? null;
+}
+function parseSuggestionWaitTarget(value) {
+  const word = typeof value === "string" ? value.trim() : "";
+  if (!SUGGESTION_WAIT_TARGETS.includes(word)) {
+    throw invalidInput(`--until takes one of ${SUGGESTION_WAIT_TARGETS.join(", ")}; ${String(value)} is not one of them.`);
+  }
+  return word;
+}
+function activationLimitation(release) {
+  if (release === null || release.active_release_status === "known") return [];
+  return [{
+    code: "activation_unknown",
+    message: `${release.release_id} went live, and the activation record could not be read, so whether it is the release readers see now is unknown rather than no.`,
+    at: "release.active_release_id"
+  }];
+}
+function releaseNotFound(error) {
+  return isManagementError(error) && error.detail.code === "not_found";
+}
+async function activationOf(client, input) {
+  try {
+    const read = await getRelease(client, input.site, input.releaseId, { signal: input.signal, deadlineMs: input.deadlineMs });
+    const { activation } = read;
+    return {
+      activation: {
+        release_id: read.release.release_id,
+        activated_at: activation.activated_at,
+        active_release_id: activation.active_release_id,
+        active_release_status: activation.active_release_status
+      },
+      release: {
+        release_id: read.release.release_id,
+        state: activation.state,
+        activated_at: activation.activated_at,
+        generation: activation.generation,
+        active_release_id: activation.active_release_id,
+        active_release_status: activation.active_release_status,
+        summary: activation.summary
+      },
+      unreadable: false
+    };
+  } catch (error) {
+    if (!releaseNotFound(error)) throw error;
+    return {
+      activation: { release_id: input.releaseId, activated_at: null, active_release_id: null, active_release_status: "unknown" },
+      release: null,
+      unreadable: true
+    };
+  }
+}
+async function waitForSuggestion(client, input) {
+  const target = parseSuggestionWaitTarget(input.until);
+  const deadlineMs = input.deadlineMs ?? DEFAULT_SUGGESTION_WAIT_MS;
+  const outcome = await poll(async (context) => {
+    const detail = await getSuggestion(client, {
+      site: input.site,
+      suggestionId: input.suggestionId,
+      signal: context.signal,
+      deadlineMs: context.deadlineMs
+    });
+    const suggestion2 = detail.suggestion;
+    const reached = classifySuggestionWait(target, suggestion2);
+    if (target !== "published" || reached.decision === "stop") {
+      return {
+        done: reached.decision === "stop",
+        value: { suggestion: suggestion2, outcome: reached.outcome, exit: reached.exit, note: reached.rule.note, release: null, release_unreadable: false }
+      };
+    }
+    const releaseId = suggestion2.publication?.release_id ?? null;
+    const read = releaseId === null ? { activation: { release_id: null, activated_at: null, active_release_id: null, active_release_status: "known" }, release: null, unreadable: false } : await activationOf(client, { site: input.site, releaseId, signal: context.signal, deadlineMs: context.deadlineMs });
+    const verified = classifySuggestionWait(target, suggestion2, read.activation);
+    const note = read.unreadable ? UNREADABLE_RELEASE_NOTE : read.release?.summary ?? verified.activation?.note ?? verified.rule.note;
+    return {
+      done: verified.decision === "stop",
+      value: { suggestion: suggestion2, outcome: verified.outcome, exit: verified.exit, note, release: read.release, release_unreadable: read.unreadable }
+    };
+  }, {
+    deadlineMs,
+    signal: input.signal,
+    intervalMs: input.intervalMs,
+    maxIntervalMs: input.maxIntervalMs,
+    now: input.now,
+    sleep: input.sleep
+  });
+  const last = outcome.last;
+  const suggestion = last?.suggestion ?? null;
+  const release = last?.release ?? null;
+  const reviewLimitations = suggestion === null ? [] : suggestionLimitations(suggestion);
+  const missingContent = reviewLimitations.some((limitation) => limitation.code === "content_unavailable");
+  const reviewable = !outcome.timed_out && last?.outcome === "reviewable";
+  const limitations = Object.freeze([
+    ...target === "reviewable" ? reviewLimitations : [],
+    ...activationLimitation(release)
+  ]);
+  const base = {
+    target,
+    timed_out: outcome.timed_out,
+    suggestion,
+    state: suggestion?.state ?? null,
+    revision: suggestion?.revision ?? null,
+    base_sha: suggestion?.base_sha ?? null,
+    head_sha: suggestion?.head_sha ?? null,
+    pr_number: suggestion?.pr_number ?? null,
+    publication_job_id: suggestion?.publication?.job_id ?? null,
+    release,
+    owner_handoff: reviewable && missingContent,
+    limitations,
+    polls: outcome.attempts,
+    elapsed_ms: outcome.elapsed_ms
+  };
+  if (outcome.timed_out || last === void 0 || last === null) {
+    return { ...base, outcome: "timed_out", exit: EXIT.wait_timeout, note: TIMEOUT_NOTE, timed_out: true };
+  }
+  return {
+    ...base,
+    outcome: last.outcome,
+    exit: last.exit,
+    note: base.owner_handoff ? `${last.note} ${HANDOFF_NOTE}` : last.note
+  };
+}
+var REQUEST_THREAD_LIMIT_MAX = MAX_REQUEST_THREADS;
+function checkedLimit(limit2) {
+  if (limit2 === null || limit2 === void 0) return void 0;
+  if (!Number.isInteger(limit2) || limit2 < 1 || limit2 > REQUEST_THREAD_LIMIT_MAX) {
+    throw invalidInput(`--limit takes a whole number from 1 to ${REQUEST_THREAD_LIMIT_MAX}. Nothing was sent.`);
+  }
+  return limit2;
+}
+function checkedCursor(cursor2) {
+  if (cursor2 === null || cursor2 === void 0) return void 0;
+  if (cursor2.trim() === "") throw invalidInput("--cursor needs the next_cursor of the preceding page.");
+  return cursor2;
+}
+async function listRequestThreads(client, input) {
+  const query = {
+    view: "threads",
+    cursor: checkedCursor(input.cursor),
+    limit: checkedLimit(input.limit),
+    attention: input.attention === true ? "1" : void 0
+  };
+  const response = await client.get(operationPath("requests.list", input.siteId), {
+    query,
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  return parseResponse(RequestsPage2, response.data, "The request thread listing");
+}
+async function readRequestThread(client, input) {
+  if (input.jobId.trim() === "") throw invalidInput("Name the job whose conversation to read.");
+  const response = await client.get(operationPath("requests.thread", input.siteId, { job: input.jobId }), {
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  return parseResponse(RequestThread2, response.data, "The request thread");
+}
+var REQUEST_PAGE_LIMIT = 400;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+function checkedSubmissionId(value) {
+  if (!UUID.test(value.trim())) {
+    throw invalidInput("--submission-id takes a UUID you mint and keep, so a lost answer can be replayed under the same identity. Nothing was sent.");
+  }
+  return value.trim();
+}
+function checkedRequestText(text) {
+  if (text.trim() === "") throw invalidInput("The request is empty, and an empty request buys a model run with nothing to go on. Nothing was sent.");
+  if (text.length > REQUEST_TEXT_LIMIT) {
+    throw invalidInput(`A request may be at most ${REQUEST_TEXT_LIMIT} characters as the server counts them, and this one is ${text.length}. Nothing was sent.`);
+  }
+  return text;
+}
+function checkedPage(page) {
+  if (page === null || page === void 0) return void 0;
+  if (page.trim() === "") throw invalidInput("--page needs a page path, such as pages/export.mdx.");
+  if (page.length > REQUEST_PAGE_LIMIT) throw invalidInput(`--page may be at most ${REQUEST_PAGE_LIMIT} characters. Nothing was sent.`);
+  return page;
+}
+async function createRequest(client, input) {
+  const page = checkedPage(input.page);
+  const body = {
+    submission_id: checkedSubmissionId(input.submissionId),
+    request: checkedRequestText(input.request),
+    ...page === void 0 ? {} : { page }
+  };
+  const accepted = UpdateRequestBody.safeParse(body);
+  if (!accepted.success) {
+    throw invalidInput(`The request was not in the shape the server accepts: ${accepted.error.issues.map((issue) => issue.path.join(".") || "body").join(", ")}. Nothing was sent.`);
+  }
+  const response = await client.request({
+    method: "POST",
+    path: operationPath("requests.create", input.siteId),
+    body,
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = UpdateRequestResponse2.safeParse(response.data);
+  if (!parsed.success) {
+    throw unknownOutcome(`The request was accepted and its answer did not name the queued job. Replay submission_id ${body.submission_id} with the same words to recover it; do not send different words under that id.`);
+  }
+  return parsed.data;
+}
+var NEW_REQUEST_GUIDANCE = "Ask for the next change with `saturndocs requests create` under a new --submission-id; a closed conversation is never reopened.";
+function withNewRequestGuidance(error) {
+  if (!isManagementError(error) || error.detail.server?.code !== "thread_closed") return error;
+  return new ManagementError(
+    clientError("conflict", `${error.detail.message} ${NEW_REQUEST_GUIDANCE}`, {
+      mutation: error.detail.mutation,
+      server: error.detail.server
+    }),
+    { cause: error }
+  );
+}
+async function replyToRequest(client, input) {
+  const submissionId = checkedSubmissionId(input.submissionId);
+  const request = checkedRequestText(input.request);
+  const thread = await readRequestThread(client, {
+    siteId: input.siteId,
+    jobId: input.jobId,
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const root = thread.root.job_id;
+  const body = { submission_id: submissionId, request, thread: root };
+  const accepted = UpdateRequestBody.safeParse(body);
+  if (!accepted.success) {
+    throw new ManagementError(clientError("invalid_input", `The reply was not in the shape the server accepts: ${accepted.error.issues.map((issue) => issue.path.join(".") || "body").join(", ")}. Nothing was sent.`));
+  }
+  let response;
+  try {
+    response = await client.request({
+      method: "POST",
+      path: operationPath("requests.create", input.siteId),
+      body,
+      signal: input.signal,
+      deadlineMs: input.deadlineMs
+    });
+  } catch (error) {
+    throw withNewRequestGuidance(error);
+  }
+  const parsed = UpdateRequestResponse2.safeParse(response.data);
+  if (!parsed.success) {
+    throw unknownOutcome(`The reply was accepted and its answer did not name the queued job. Read the conversation ${root}, or replay submission_id ${submissionId} with the same words; do not send different words under that id.`);
+  }
+  return { queued: parsed.data, threadId: thread.thread_id };
+}
+async function retryRequest(client, input) {
+  if (input.jobId.trim() === "") throw invalidInput("Name the failed job to send again.");
+  const response = await client.request({
+    method: "POST",
+    path: operationPath("requests.retry", input.siteId, { job: input.jobId }),
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = RequestRetryResponse2.safeParse(response.data);
+  if (!parsed.success) {
+    throw unknownOutcome(`The retry of ${input.jobId} was accepted and its answer could not be read. Read the conversation before sending it again.`);
+  }
+  return parsed.data;
+}
+var STATUS_SECTIONS = ["site", "requests", "suggestions", "activity"];
+var STATUS_PAGE_LIMIT = 10;
+function available(section2, data, empty, recovery) {
+  return { section: section2, state: empty ? "empty" : "available", data, error: null, recovery };
+}
+function unavailable(section2, cause, recovery) {
+  return { section: section2, state: "unavailable", data: null, error: toClientError(cause), recovery };
+}
+function readCommand(section2, siteId) {
+  if (section2 === "site") return `saturndocs sites get ${siteId} --json`;
+  if (section2 === "requests") return `saturndocs requests list --site ${siteId} --json`;
+  if (section2 === "suggestions") return `saturndocs suggestions list --site ${siteId} --state pending --json`;
+  return `saturndocs activity list ${siteId} --json`;
+}
+function retryRecovery(section2, siteId) {
+  return {
+    command: readCommand(section2, siteId),
+    replay: null,
+    message: `The ${section2} section of this briefing was not read. Run its own command to see whether the service answers, and read nothing into its absence here.`
+  };
+}
+async function section(name, siteId, read, isEmpty, recovery) {
+  try {
+    const data = await read();
+    return available(name, data, isEmpty(data), recovery(data));
+  } catch (cause) {
+    return unavailable(name, cause, retryRecovery(name, siteId));
+  }
+}
+function awaitingReply(page, siteId) {
+  const waiting = [];
+  for (const thread of page.threads) {
+    if (!thread.open) continue;
+    const ids = { thread_id: thread.thread_id, job_id: thread.latest.job_id, attempt: thread.latest.attempt };
+    waiting.push({
+      kind: "request_awaiting_reply",
+      ids,
+      summary: `Request ${thread.thread_id} is waiting on an answer; its latest job is ${thread.latest.job_id}.`,
+      recovery: {
+        command: `saturndocs requests reply --site ${siteId} --thread ${thread.thread_id} --submission-id <uuid> --file -`,
+        replay: null,
+        message: "Answer the question to let the drafting run carry on. The answer's words go in on stdin, never in argv."
+      }
+    });
+  }
+  return Object.freeze(waiting);
+}
+function requestsRecovery(page, siteId) {
+  const open = page.threads.filter((thread) => thread.open);
+  const first = open[0];
+  if (first === void 0) return null;
+  return {
+    command: `saturndocs requests reply --site ${siteId} --thread ${first.thread_id} --submission-id <uuid> --file -`,
+    replay: null,
+    message: `${open.length} conversation(s) on this page are waiting on an answer. ${first.thread_id} is the newest of them.`
+  };
+}
+function countsOf(requests, suggestions) {
+  return {
+    requests_failed: requests.data?.failed ?? null,
+    requests_waiting: requests.data?.waiting ?? null,
+    suggestions: suggestions.data?.counts ?? null
+  };
+}
+async function readSiteStatus(client, siteId, options = {}) {
+  const { limit: limit2 = STATUS_PAGE_LIMIT, ...read } = options;
+  const [site, requests, suggestions, activity] = await Promise.all([
+    section("site", siteId, () => getSite(client, siteId, read), () => false, () => null),
+    section(
+      "requests",
+      siteId,
+      () => listRequestThreads(client, { siteId, limit: limit2, attention: true, ...read }),
+      (page) => page.threads.length === 0,
+      (page) => requestsRecovery(page, siteId)
+    ),
+    section(
+      "suggestions",
+      siteId,
+      () => listSuggestions(client, { site: siteId, state: "pending", limit: limit2, ...read }),
+      (page) => page.suggestions.length === 0,
+      () => null
+    ),
+    section(
+      "activity",
+      siteId,
+      () => listActivity(client, siteId, { limit: limit2, ...read }),
+      (page) => page.events.length === 0,
+      () => null
+    )
+  ]);
+  return {
+    site_id: siteId,
+    site,
+    requests,
+    suggestions,
+    activity,
+    counts: countsOf(requests, suggestions),
+    attention: requests.data === null ? Object.freeze([]) : awaitingReply(requests.data, siteId)
+  };
+}
+function statusSections(status) {
+  return [status.site, status.requests, status.suggestions, status.activity];
+}
+function statusLimitations(status) {
+  const limitations = [];
+  for (const part of statusSections(status)) {
+    if (part.state !== "unavailable") continue;
+    limitations.push({
+      code: "section_unavailable",
+      message: `The ${part.section} section could not be read: ${part.error?.message ?? "the read failed and said nothing."} Nothing here says this site has no ${part.section}.`,
+      at: part.section
+    });
+  }
+  if (status.requests.data?.next_cursor != null) {
+    limitations.push({ code: "page_bounded", message: "This is one page of conversations. Read the rest with saturndocs requests list --cursor.", at: "requests.data.threads" });
+  }
+  if (status.suggestions.data?.next_cursor != null) {
+    limitations.push({ code: "page_bounded", message: "This is one page of the pending tab. Read the rest with saturndocs suggestions list --cursor.", at: "suggestions.data.suggestions" });
+  }
+  if (status.activity.data?.next_cursor != null) {
+    limitations.push({ code: "page_bounded", message: "This is one page of activity. Read the rest with saturndocs activity list --cursor.", at: "activity.data.events" });
+  }
+  return Object.freeze(limitations);
+}
+function statusBlocker(status) {
+  const failures = statusSections(status).filter((part) => part.state === "unavailable");
+  const refused = failures.find((part) => part.error?.code === "unauthorized" || part.error?.code === "forbidden");
+  if (refused?.error != null) return refused.error;
+  if (failures.length === STATUS_SECTIONS.length) return failures[0]?.error ?? null;
+  return null;
+}
+function statusIds(status) {
+  return status.attention[0]?.ids ?? {};
+}
+function statusRecovery(status) {
+  return status.attention[0]?.recovery ?? status.requests.recovery ?? null;
+}
+var DEFAULT_REQUEST_WAIT_MS = 10 * 6e4;
+var TIMEOUT_NOTE2 = "The deadline passed with the work still running. Nothing remote was cancelled; the job carries on and can be waited on again.";
+var WAIT_ERROR_CODES2 = Object.freeze({
+  failed: "remote_failure",
+  cancelled: "remote_failure",
+  outcome_unknown: "service_unavailable",
+  timed_out: "wait_timeout"
+});
+function requestWaitErrorCode(outcome) {
+  return WAIT_ERROR_CODES2[outcome] ?? null;
+}
+function summaryOf2(state, thread) {
+  const entry = thread.entries.filter((row) => row.job_id === state.job_id && (state.attempt === null || row.attempt === state.attempt)).at(-1);
+  const words = entry === void 0 ? null : entry.body.trim();
+  return words === null || words === "" ? state.rule.note : words;
+}
+async function waitForRequest(client, input) {
+  const deadlineMs = input.deadlineMs ?? DEFAULT_REQUEST_WAIT_MS;
+  const outcome = await poll(async (context) => {
+    const thread2 = await readRequestThread(client, {
+      siteId: input.siteId,
+      jobId: input.jobId,
+      signal: context.signal,
+      deadlineMs: context.deadlineMs
+    });
+    const state2 = classifyRequestWait(thread2);
+    return { done: state2.rule.decision === "stop", value: { thread: thread2, state: state2 } };
+  }, {
+    deadlineMs,
+    signal: input.signal,
+    intervalMs: input.intervalMs,
+    maxIntervalMs: input.maxIntervalMs,
+    now: input.now,
+    sleep: input.sleep
+  });
+  const thread = outcome.last?.thread ?? null;
+  const state = outcome.last?.state ?? null;
+  const base = {
+    timed_out: outcome.timed_out,
+    thread,
+    job_id: state?.job_id ?? null,
+    attempt: state?.attempt ?? null,
+    state: thread?.latest_job.state ?? null,
+    suggestion_id: state?.suggestion_id ?? null,
+    polls: outcome.attempts,
+    elapsed_ms: outcome.elapsed_ms
+  };
+  if (outcome.timed_out || state === null) {
+    return { ...base, outcome: "timed_out", exit: EXIT.wait_timeout, note: TIMEOUT_NOTE2, timed_out: true };
+  }
+  return {
+    ...base,
+    outcome: state.rule.outcome,
+    exit: state.rule.exit,
+    note: thread === null ? state.rule.note : summaryOf2(state, thread)
+  };
+}
+function requireSuggestionId2(value) {
+  if (value.trim() === "") throw invalidInput("Name the suggestion to preview, as saturndocs suggestions preview <suggestion-id>.");
+  return value;
+}
+function unreadable4() {
+  throw managementError(
+    "transport_failure",
+    "The preview did not come back in the shape this client understands, so nothing is reported rather than a reading that might call a stale or absent preview a current one."
+  );
+}
+function limitationsFor2(body) {
+  const limitations = [];
+  if (body.state === "building") {
+    limitations.push({
+      code: "activation_unknown",
+      message: "A preview build is running. This command does not follow it and nothing here says one will open; read the preview again to find out how the build ended.",
+      at: "state"
+    });
+  }
+  if (body.state === "ready" && !body.current) {
+    limitations.push({
+      code: "review_incomplete",
+      message: `This preview was built for revision ${body.revision === null ? "unknown" : String(body.revision)}, which is not the suggestion's current revision. Reviewing it reviews work that has since changed.`,
+      at: "current"
+    });
+  }
+  if (body.state === "ready" && body.url === null) {
+    limitations.push({
+      code: "content_unavailable",
+      message: "The server reported a built preview and gave no address for it, so there is nothing to open. This is not a preview waiting to be opened; ask for it again.",
+      at: "url"
+    });
+  }
+  return Object.freeze(limitations);
+}
+function toResult(suggestionId, body, requestedBuild) {
+  return {
+    suggestion_id: suggestionId,
+    state: body.state,
+    revision: body.revision,
+    current: body.current,
+    url: body.url,
+    leave_url: body.leave_url,
+    error: body.error,
+    current_preview_available: body.state === "ready" && body.current && body.url !== null,
+    requested_build: requestedBuild,
+    response: body,
+    limitations: limitationsFor2(body)
+  };
+}
+async function readPreview(client, input, method) {
+  const suggestionId = requireSuggestionId2(input.suggestionId);
+  const path = resourcePath(input.site, ["suggestions", suggestionId, "preview"]);
+  const response = method === "GET" ? await client.get(path, { signal: input.signal, deadlineMs: input.deadlineMs }) : await client.request({ method: "POST", path, signal: input.signal, deadlineMs: input.deadlineMs });
+  const parsed = SuggestionPreviewResponse2.safeParse(response.data);
+  if (!parsed.success) unreadable4();
+  return toResult(suggestionId, parsed.data, method === "POST");
+}
+async function getSuggestionPreview(client, input) {
+  return readPreview(client, input, "GET");
+}
+async function createSuggestionPreview(client, input) {
+  return readPreview(client, input, "POST");
+}
+function previewIds(result) {
+  return { suggestion_id: result.suggestion_id };
+}
+var SESSION_MESSAGE_LIMIT2 = MAX_SESSION_MESSAGE_CHARS;
+function requireSuggestionId3(value, usage) {
+  if (value.trim() === "") throw invalidInput(`Name the suggestion to act on, as ${usage}.`);
+  return value;
+}
+function unreadableRead() {
+  throw managementError(
+    "transport_failure",
+    "The conversation did not come back in the shape this client understands, so nothing is reported rather than a partial reading of it."
+  );
+}
+function unreadableTurn(suggestionId) {
+  throw unknownOutcome(
+    `The message was accepted and its answer was not in the shape this client understands, so whether it queued a revision is not reported here. Read the transcript with saturndocs suggestions conversation ${suggestionId} before sending anything again; sending this message again would ask the suggestion twice.`
+  );
+}
+async function readConversation(client, input) {
+  const suggestionId = requireSuggestionId3(input.suggestionId, "saturndocs suggestions conversation <suggestion-id>");
+  const response = await client.get(resourcePath(input.site, ["suggestions", suggestionId, "session"]), {
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = SuggestionThread2.safeParse(response.data);
+  if (!parsed.success) unreadableRead();
+  const entries = parsed.data.entries;
+  return {
+    suggestion_id: suggestionId,
+    entries,
+    latest_revision: entries.length === 0 ? null : entries.reduce((highest, entry) => Math.max(highest, entry.revision), entries[0].revision)
+  };
+}
+async function sendSessionMessage(client, input) {
+  const suggestionId = requireSuggestionId3(input.suggestionId, "saturndocs suggestions message <suggestion-id>");
+  const questionId = input.questionId === void 0 || input.questionId === null || input.questionId === "" ? void 0 : input.questionId;
+  const body = SessionMessageBody.safeParse({ message: input.message, ...questionId === void 0 ? {} : { question_id: questionId } });
+  if (!body.success) {
+    const onQuestion = body.error.issues.some((issue) => issue.path[0] === "question_id");
+    throw invalidInput(
+      onQuestion ? `--question-id takes a question id this suggestion carries, and this one is not a length the server mints. Read the suggestion's questions first; a request thread id is not a suggestion question.` : `saturndocs suggestions message accepts at most ${SESSION_MESSAGE_LIMIT2} characters and no empty message. Nothing was sent.`
+    );
+  }
+  const response = await client.request({
+    method: "POST",
+    path: resourcePath(input.site, ["suggestions", suggestionId, "session"]),
+    body: body.data,
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = SessionResponse2.safeParse(response.data);
+  if (!parsed.success) unreadableTurn(suggestionId);
+  const outcome = parsed.data;
+  const limitations = [];
+  if (outcome.startedRevision) {
+    limitations.push({
+      code: "review_incomplete",
+      message: "The answer queued a revision. The draft it produces has nobody's review, so read the suggestion again before approving anything.",
+      at: "started_revision"
+    });
+  }
+  return {
+    suggestion_id: suggestionId,
+    question_id: questionId ?? null,
+    answer: outcome.answer,
+    evidence: outcome.evidence,
+    started_revision: outcome.startedRevision,
+    saved_answer: !outcome.startedRevision,
+    outcome,
+    limitations: Object.freeze(limitations)
+  };
+}
+function conversationIds(result) {
+  return { suggestion_id: result.suggestion_id };
+}
+var REVISION_NOTE_LIMIT2 = MAX_REQUEST_CHANGES_NOTE_CHARS;
+function unreadableRequest(suggestionId) {
+  throw unknownOutcome(
+    `The change request was accepted and its answer was not in the shape this client understands, so whether a revision was queued is not reported here. Read the transcript with saturndocs suggestions conversation ${suggestionId} before sending anything again; sending this note again would ask for the same changes twice.`
+  );
+}
+async function requestSuggestionChanges(client, input) {
+  const suggestionId = input.suggestionId;
+  if (suggestionId.trim() === "") throw invalidInput("Name the suggestion to act on, as saturndocs suggestions request-changes <suggestion-id>.");
+  const body = RequestChangesBody.safeParse({ note: input.note });
+  if (!body.success) {
+    throw invalidInput(`saturndocs suggestions request-changes accepts at most ${REVISION_NOTE_LIMIT2} characters and no empty note. Nothing was sent.`);
+  }
+  const response = await client.request({
+    method: "POST",
+    path: resourcePath(input.site, ["suggestions", suggestionId, "request-changes"]),
+    body: body.data,
+    signal: input.signal,
+    deadlineMs: input.deadlineMs
+  });
+  const parsed = RequestChangesOutcome2.safeParse(response.data);
+  if (!parsed.success) unreadableRequest(suggestionId);
+  const outcome = parsed.data;
+  if (outcome.state !== "revising") unreadableRequest(suggestionId);
+  const alreadyRequested = outcome.already_requested === true;
+  const revision = typeof outcome.revision === "number" ? outcome.revision : null;
+  const limitations = [
+    alreadyRequested ? {
+      code: "review_incomplete",
+      message: `This note queued nothing: a revision asked for earlier${revision === null ? "" : ` (revision ${revision})`} is still running, and it is what the suggestion is revising to. Read the conversation to see what was asked for; asking again does not add this note to it.`,
+      at: "already_requested"
+    } : {
+      code: "review_incomplete",
+      message: `A revision${revision === null ? "" : ` (revision ${revision})`} is queued. The draft it produces has nobody's review, so read the suggestion again before approving anything.`,
+      at: "revision_queued"
+    }
+  ];
+  return {
+    suggestion_id: suggestionId,
+    state: "revising",
+    revision,
+    pr_number: typeof outcome.pr_number === "number" ? outcome.pr_number : null,
+    revision_queued: !alreadyRequested,
+    already_requested: alreadyRequested,
+    outcome,
+    limitations: Object.freeze(limitations)
+  };
+}
+function requestChangesIds(result) {
+  return { suggestion_id: result.suggestion_id, pr_number: result.pr_number };
+}
+
+// src/adapter/globals.ts
+import { InvalidArgumentError } from "commander";
+var GLOBAL_OPTION_KEYS = ["json", "site", "api", "input", "timeout"];
+var GLOBAL_DEFAULTS = { json: false, site: null, api: null, input: true, timeout: null };
+function positiveSeconds(value) {
+  const seconds = Number(value);
+  if (!Number.isInteger(seconds) || seconds <= 0) {
+    throw new InvalidArgumentError("Give a positive whole number of seconds.");
+  }
+  return seconds;
+}
+var GLOBAL_FLAGS2 = [
+  ["--json", "One result object and a newline on stdout. Diagnostics stay on stderr."],
+  ["--site <site-id>", "The site to act on. Required for every remote mutation."],
+  ["--api <origin>", "Management API origin."],
+  ["--no-input", "Never read from a terminal."],
+  ["--timeout <seconds>", "Seconds a wait or a request may take.", positiveSeconds]
+];
+function longOf(flags) {
+  return flags.split(/[ ,|]/)[0] ?? flags;
+}
+function applyGlobalFlags(command) {
+  const declared = new Set(command.options.map((option) => option.long));
+  for (const [flags, description, parser] of GLOBAL_FLAGS2) {
+    const long = longOf(flags);
+    if (declared.has(long) || long === "--no-input" && declared.has("--input")) continue;
+    if (parser === void 0) command.option(flags, description);
+    else command.option(flags, description, parser);
+  }
+  return command;
+}
+function applyGlobalFlagsDeep(command) {
+  applyGlobalFlags(command);
+  for (const child of command.commands) applyGlobalFlagsDeep(child);
+}
+function resolveGlobalOptions(command) {
+  const chain = [];
+  for (let node = command; node !== null; node = node.parent) chain.unshift(node);
+  const resolved = { ...GLOBAL_DEFAULTS };
+  for (const node of chain) {
+    for (const key of GLOBAL_OPTION_KEYS) {
+      const source = node.getOptionValueSource(key);
+      if (source === void 0 || source === "default") continue;
+      const value = node.getOptionValue(key);
+      if (value === void 0) continue;
+      resolved[key] = value;
+    }
+  }
+  return {
+    json: resolved.json === true,
+    site: typeof resolved.site === "string" ? resolved.site : null,
+    api: typeof resolved.api === "string" ? resolved.api : null,
+    input: resolved.input !== false,
+    timeout: typeof resolved.timeout === "number" ? resolved.timeout : null
+  };
+}
+
+// src/adapter/errors.ts
+var CliError = class extends Error {
+  code;
+  server;
+  retryable;
+  mutation;
+  exit;
+  limitations;
+  recovery;
+  data;
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "CliError";
+    this.code = code;
+    this.server = options.server ?? null;
+    this.retryable = options.retryable ?? CLIENT_ERROR_CATEGORIES[code].retryable;
+    this.mutation = options.mutation ?? CLIENT_ERROR_CATEGORIES[code].mutation;
+    this.exit = options.exit ?? CLIENT_ERROR_CATEGORIES[code].exit;
+    this.limitations = options.limitations ?? [];
+    this.recovery = options.recovery ?? null;
+    this.data = options.data;
+  }
+};
+function invalidInput2(message, options = {}) {
+  return new CliError("invalid_input", message, options);
+}
+function interrupted2(message = CLIENT_ERROR_CATEGORIES.interrupted.meaning, options = {}) {
+  return new CliError("interrupted", message, options);
+}
+function clientError2(code, message, server = null) {
+  const category = CLIENT_ERROR_CATEGORIES[code];
+  return { code, message, retryable: category.retryable, mutation: category.mutation, exit: category.exit, server };
+}
+function envelope2(context) {
+  return {
+    schema_version: CLIENT_SCHEMA_VERSION,
+    command: context.command,
+    site_id: context.siteId ?? null,
+    ids: context.ids ?? {},
+    limitations: [...context.limitations ?? []],
+    recovery: context.recovery ?? null
+  };
+}
+function successResult(context, data) {
+  return { ...envelope2(context), ok: true, data };
+}
+function messageOf(error) {
+  if (error instanceof Error && error.message !== "") return error.message;
+  const text = String(error);
+  return text === "" ? "The command failed and said nothing." : text;
+}
+var UNCLASSIFIED = "service_unavailable";
+function failureResult(error, context) {
+  const classified = error instanceof CliError;
+  const code = classified ? error.code : UNCLASSIFIED;
+  const base = envelope2({
+    ...context,
+    limitations: [...context.limitations ?? [], ...classified ? error.limitations : []],
+    recovery: (classified ? error.recovery : null) ?? context.recovery ?? null
+  });
+  const failure = {
+    ...base,
+    ok: false,
+    error: classified ? {
+      code,
+      message: messageOf(error),
+      retryable: error.retryable,
+      mutation: error.mutation,
+      exit: error.exit,
+      server: error.server
+    } : clientError2(code, messageOf(error))
+  };
+  if (classified && error.data !== void 0) failure.data = error.data;
+  return failure;
+}
+
+// src/adapter/output.ts
+function createResultWriter(options) {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  let written = false;
+  let exit = 0;
+  return {
+    json: options.json,
+    get written() {
+      return written;
+    },
+    write(result, writeOptions = {}) {
+      if (written) return exit;
+      written = true;
+      exit = exitForResult(result);
+      if (options.json) {
+        stdout.write(`${JSON.stringify(result)}
+`);
+        return exit;
+      }
+      if (result.ok) {
+        if (writeOptions.text !== void 0) stdout.write(`${writeOptions.text}
+`);
+      } else {
+        stderr.write(`error: ${result.error.message}
+`);
+      }
+      for (const limitation of result.limitations) {
+        stderr.write(`note: ${limitation.message}
+`);
+      }
+      return exit;
+    }
+  };
+}
+function wantsJson(argv) {
+  return argv.includes("--json");
+}
+
+export {
+  SUGGESTION_TABS,
+  EXIT,
+  EXIT_MEANINGS,
+  CLIENT_ERROR_CODES,
+  CLIENT_ERROR_CATEGORIES,
+  CLIENT_SCHEMA_VERSION,
+  GLOBAL_FLAGS,
+  REQUEST_TEXT_LIMIT,
+  isManagementError,
+  requireCommitSha,
+  createClient,
+  resolveTarget,
+  COMMAND_SCHEMA_VERSION,
+  selectorFor,
+  commandMetadata,
+  listSites,
+  readSiteDetail,
+  PAGE_TRAFFIC_WINDOWS,
+  pagesUnavailable,
+  listPages,
+  ACTIVITY_OUTCOMES,
+  ACTIVITY_LIMIT_CEILING,
+  listActivity,
+  activityJobFound,
+  readActivityJob,
+  listSuggestions,
+  getSuggestion,
+  suggestionIds,
+  suggestionLimitations,
+  suggestionDiff,
+  renderDiffText,
+  DISMISS_REASONS,
+  approveSuggestion,
+  dismissSuggestion,
+  reviewDecisionIds,
+  retrySuggestion,
+  retryIds,
+  RELEASE_PAGE_MAX,
+  activeStatusOf,
+  classifyReleaseActivation,
+  listReleases,
+  getRelease,
+  DEFAULT_SUGGESTION_WAIT_MS,
+  suggestionWaitErrorCode,
+  parseSuggestionWaitTarget,
+  waitForSuggestion,
+  listRequestThreads,
+  readRequestThread,
+  checkedSubmissionId,
+  checkedRequestText,
+  createRequest,
+  replyToRequest,
+  retryRequest,
+  readSiteStatus,
+  statusSections,
+  statusLimitations,
+  statusBlocker,
+  statusIds,
+  statusRecovery,
+  DEFAULT_REQUEST_WAIT_MS,
+  requestWaitErrorCode,
+  waitForRequest,
+  getSuggestionPreview,
+  createSuggestionPreview,
+  previewIds,
+  readConversation,
+  sendSessionMessage,
+  conversationIds,
+  requestSuggestionChanges,
+  requestChangesIds,
+  applyGlobalFlags,
+  applyGlobalFlagsDeep,
+  resolveGlobalOptions,
+  CliError,
+  invalidInput2 as invalidInput,
+  interrupted2 as interrupted,
+  clientError2 as clientError,
+  successResult,
+  failureResult,
+  createResultWriter,
+  wantsJson
+};