@pome-sh/cli 0.19.0 → 0.21.0

package/dist/chunk-2Q7AYEUA.js

@@ -0,0 +1,1207 @@
+import { twinIdSchema } from './chunk-VBATFCWR.js';
+import { z } from 'zod';
+
+var SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SLUG_MAX_LENGTH = 64;
+function deriveAgentSlug(input) {
+  return input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-/, "").replace(/-$/, "");
+}
+var agentSlugSchema = z.string().max(SLUG_MAX_LENGTH).regex(SLUG_RE, "Agent slug must be kebab-case: lowercase letters, digits, single dashes");
+var manifestAgentSchema = z.object({
+  slug: agentSlugSchema,
+  name: z.string().min(1).optional(),
+  // display name (server display_name)
+  description: z.string().optional(),
+  // shown on dashboard
+  version: z.string().optional(),
+  // user-declared label; never auto-bumped
+  // Open enum by design: unknown frameworks get a did-you-mean warning at the
+  // consuming edge, never a validation error.
+  framework: z.string().min(1).optional()
+  // langgraph | claude-agent-sdk | openai-agents | …
+});
+var manifestSchema = z.object({
+  // pome.json carries the editor pointer; pome.yaml uses a comment instead.
+  $schema: z.string().optional(),
+  agent: manifestAgentSchema,
+  command: z.string().min(1).optional(),
+  // how the CLI launches the agent
+  twins: z.array(z.string().min(1)).min(1).optional(),
+  // default twin set for runs
+  tasks: z.string().min(1).optional(),
+  // task files directory (legacy name: scenarios)
+  artifacts_dir: z.string().min(1).default("runs"),
+  pass_threshold: z.number().int().min(0).max(100).default(100)
+});
+
+// src/contract/task-vocab.ts
+var LEGACY_TASK_VOCAB_KEY_MAP = {
+  scenario_name: "task_name",
+  scenario_hash: "task_hash",
+  scenario_source: "task_source",
+  scenario_id: "task_id",
+  promoted_scenario_id: "promoted_task_id"
+};
+function normalizeTaskVocabKeys(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const record = value;
+  let out = null;
+  for (const [legacyKey, canonicalKey] of Object.entries(LEGACY_TASK_VOCAB_KEY_MAP)) {
+    if (legacyKey in record) {
+      out ??= { ...record };
+      if (!(canonicalKey in record)) {
+        out[canonicalKey] = record[legacyKey];
+      }
+      delete out[legacyKey];
+    }
+  }
+  return out ?? value;
+}
+var LEGACY_CRITERION_KIND_MAP = {
+  D: "code",
+  P: "model"
+};
+
+// src/contract/run.ts
+var judgeModelSchema = z.string().min(1);
+var correlatorKindSchema = z.enum([
+  "heuristic",
+  "adapter_rich",
+  "span_context"
+]);
+var CRITERION_KINDS = ["code", "model"];
+z.enum(CRITERION_KINDS);
+var criterionKindInputSchema = z.enum(["D", "P", "code", "model"]).transform(
+  (kind) => kind === "D" || kind === "P" ? LEGACY_CRITERION_KIND_MAP[kind] : kind
+);
+var criterionSchema = z.object({
+  // Accepts D | P | code | model; parsed output is always code | model.
+  type: criterionKindInputSchema,
+  text: z.string().min(1),
+  // Multi-twin (M3): the twin this criterion attributes to. Rides through the
+  // D/P→code/model transform above untouched. Absent = the run's primary twin
+  // (the session's twins[0]). Additive — single-twin runs omit it.
+  twin: z.string().min(1).optional()
+});
+var baseCriterionResultSchema = z.object({
+  criterion: criterionSchema,
+  // full {type, text} object
+  passed: z.boolean(),
+  skipped: z.boolean(),
+  // true if [code] fell back to [model] but the judge was unreachable, etc.
+  reason: z.string()
+  // human-readable evidence
+});
+var deterministicCriterionResultSchema = baseCriterionResultSchema.extend({
+  // [code] adds nothing further; criterion.type === "code" identifies it.
+});
+var probabilisticCriterionResultSchema = baseCriterionResultSchema.extend({
+  confidence: z.number().min(0).max(1),
+  judge_model: judgeModelSchema
+});
+var criterionResultSchema = z.union([
+  probabilisticCriterionResultSchema,
+  deterministicCriterionResultSchema
+]);
+var stepSchema = z.object({
+  id: z.string(),
+  // matches RecorderEvent.step_id
+  started_at: z.string().datetime(),
+  ended_at: z.string().datetime(),
+  label: z.string().nullable(),
+  lane_ids: z.array(z.string())
+  // child lanes, render order
+});
+var laneSchema = z.object({
+  id: z.string(),
+  step_id: z.string(),
+  // parent Step.id
+  twin: twinIdSchema,
+  // matches RecorderEvent.twin
+  label: z.string().nullable(),
+  // e.g. "POST /v1/refunds (3 calls)"
+  request_ids: z.array(z.string())
+  // RecorderEvent.request_id, time-ordered
+});
+var runObjectSchema = z.object({
+  id: z.string(),
+  // run_<nanoid>
+  session_id: z.string(),
+  team_id: z.string(),
+  task_name: z.string(),
+  // 0.3.0 alias: scenario_name
+  task_hash: z.string(),
+  // sha256 of source markdown; 0.3.0 alias: scenario_hash
+  satisfaction_score: z.number().int().min(0).max(100),
+  // CLI-computed (BYOK Flavor #1)
+  criteria_results: z.array(criterionResultSchema),
+  trace_s3_key: z.string().nullable(),
+  // s3 key for events.jsonl (hosted only; F-689 deleted tool_calls.jsonl)
+  state_s3_key: z.string().nullable(),
+  // s3 key for state_final.json
+  meta_s3_key: z.string().nullable(),
+  duration_ms: z.number().int(),
+  agent_model: z.string(),
+  // which model the agent used (informational)
+  judge_model: judgeModelSchema,
+  // which model judged [model] criteria (free-form)
+  judge_tokens_in: z.number().int().min(0).nullable(),
+  judge_tokens_out: z.number().int().min(0).nullable(),
+  // ── FDRS-613: reconciled from pome-cloud /v1 wire truth (all additive with
+  // defaults so pre-existing Run constructors stay valid) ────────────────────
+  // Sim deep-telemetry — per-run agent telemetry rollup, computed at finalize
+  // from the agent's independently-correlated `gen_ai` span tree. Null = no
+  // instrumentation / legacy / twin-only sim (dashboard renders `·`, never `0`).
+  agent_tokens_in: z.number().int().min(0).nullable().default(null),
+  agent_tokens_out: z.number().int().min(0).nullable().default(null),
+  agent_latency_p50_ms: z.number().int().min(0).nullable().default(null),
+  agent_latency_p95_ms: z.number().int().min(0).nullable().default(null),
+  agent_latency_max_ms: z.number().int().min(0).nullable().default(null),
+  agent_error_count: z.number().int().min(0).nullable().default(null),
+  agent_telemetry_span_count: z.number().int().min(0).nullable().default(null),
+  // Which server-side correlator produced lanes/steps.
+  correlator_kind: correlatorKindSchema.default("heuristic"),
+  // M0.2 (FDRS-509) — which surface this run belongs to. 'simulation' =
+  // CLI/staging scenario run (default for every legacy row); 'production' = an
+  // ingested OTLP production trace (M2).
+  environment: z.enum(["production", "simulation"]).default("simulation"),
+  // M0.5 (FDRS-512) — replay loop linkage (prod-run → task → replay-run).
+  // W3 vocab: canonical key; 0.3.0 alias: promoted_scenario_id.
+  promoted_task_id: z.string().nullable().default(null),
+  replay_run_id: z.string().nullable().default(null),
+  // Storage key for the tar-and-upload state archive the replay engine seeds a
+  // sandbox from. Null when no archive was captured.
+  state_archive_s3_key: z.string().nullable().default(null),
+  // Correlator output. Empty arrays for legacy runs (pre-M3i / pre-M4-1).
+  lanes: z.array(laneSchema).default([]),
+  steps: z.array(stepSchema).default([]),
+  // Server-generated by the managed judge (ADR-013). 1-2 sentence concise
+  // narrative of the run. Null for pre-ADR-013 rows / legacy /result runs.
+  summary: z.string().nullable().default(null),
+  // Originally CLI-generated (BYOK Flavor #1). Null on --no-fix-prompt opt-out,
+  // LLM endpoint failure, or legacy pre-M4-1 runs.
+  fix_prompt: z.string().nullable().default(null),
+  // Storage KEY (path) of the raw events.jsonl blob — NOT a URL (dashboard mints
+  // a signed GET URL on read). FDRS-613: relaxed from `.url()` to match the
+  // pome-cloud shape, since persisted storage keys are not URLs. Null in
+  // self-host mode, on upload failure, --no-upload opt-out, or legacy runs.
+  events_jsonl_url: z.string().nullable().default(null),
+  created_at: z.string().datetime(),
+  finished_at: z.string().datetime().nullable()
+});
+z.preprocess(normalizeTaskVocabKeys, runObjectSchema);
+var userSchema = z.object({
+  id: z.string(),
+  // usr_<nanoid> (text, not uuid; per /plan-eng-review L7)
+  clerk_user_id: z.string(),
+  // Clerk user ID (`user_*`)
+  email: z.string().email(),
+  display_name: z.string().nullable(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime()
+});
+var planTierSchema = z.enum([
+  "free",
+  "hobby",
+  "pro",
+  "team",
+  "self_host_annual",
+  "enterprise"
+]);
+var teamSchema = z.object({
+  id: z.string(),
+  // tm_<nanoid>
+  slug: z.string(),
+  // /dashboard/[teamSlug]/...
+  name: z.string(),
+  plan_tier: planTierSchema,
+  stripe_customer_id: z.string().nullable(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime()
+});
+var teamRoleSchema = z.enum(["owner", "admin", "member"]);
+z.object({
+  team_id: z.string(),
+  user_id: z.string(),
+  role: teamRoleSchema,
+  invited_at: z.string().datetime(),
+  accepted_at: z.string().datetime().nullable()
+});
+var teamInviteSchema = z.object({
+  id: z.string(),
+  // inv_<nanoid>
+  team_id: z.string(),
+  email: z.string().email(),
+  role: teamRoleSchema,
+  invited_by: z.string(),
+  // user_id
+  expires_at: z.string().datetime(),
+  accepted_at: z.string().datetime().nullable(),
+  created_at: z.string().datetime()
+});
+var apiKeySchema = z.object({
+  id: z.string(),
+  // pme_<short> public prefix; hashed_key NEVER appears in API responses (kept server-side only)
+  team_id: z.string(),
+  name: z.string(),
+  created_by: z.string(),
+  // user_id
+  last_used_at: z.string().datetime().nullable(),
+  created_at: z.string().datetime(),
+  revoked_at: z.string().datetime().nullable()
+});
+apiKeySchema.extend({
+  full_key: z.string()
+  // pme_<full> — show once, then redact
+});
+var MOUNTED_TWINS = ["github", "stripe", "slack", "gmail", "linear"];
+var sessionStateSchema = z.enum([
+  "provisioning",
+  "ready",
+  "running",
+  "done",
+  "expired",
+  "failed"
+]);
+var sessionSchema = z.object({
+  id: z.string(),
+  // ses_<nanoid>
+  team_id: z.string(),
+  api_key_id: z.string().nullable(),
+  // null if dashboard-launched
+  twin_type: z.string(),
+  // legacy: equals twins[0] in M3+; kept for one CLI release
+  twins: z.array(z.string()).min(1),
+  // M3: authoritative list of mounted twins for this session
+  state: sessionStateSchema,
+  twin_url: z.string().url().nullable(),
+  // populated when state='ready'
+  pod_id: z.string().nullable(),
+  // INTERNAL: which pool pod served — never on public API responses
+  created_at: z.string().datetime(),
+  ready_at: z.string().datetime().nullable(),
+  expires_at: z.string().datetime(),
+  // TTL, default created_at + 30min
+  closed_at: z.string().datetime().nullable()
+});
+var sessionPublicSchema = sessionSchema.omit({
+  pod_id: true,
+  api_key_id: true
+});
+var githubSeedStateSchema = z.object({
+  users: z.array(
+    z.object({
+      login: z.string().min(1),
+      type: z.enum(["User", "Organization"]).default("User"),
+      name: z.string().default("")
+    })
+  ).optional(),
+  repositories: z.array(
+    z.object({
+      owner: z.string().min(1),
+      name: z.string().min(1),
+      description: z.string().optional(),
+      default_branch: z.string().min(1).optional(),
+      labels: z.array(
+        z.object({
+          name: z.string().min(1),
+          color: z.string().default("ededed"),
+          description: z.string().default("")
+        })
+      ).default([]),
+      collaborators: z.array(z.string().min(1)).default([]),
+      files: z.array(
+        z.object({
+          path: z.string().min(1),
+          content: z.string(),
+          branch: z.string().optional()
+        })
+      ).optional(),
+      issues: z.array(
+        z.object({
+          number: z.number().int().positive(),
+          title: z.string().min(1),
+          body: z.string().default(""),
+          state: z.enum(["open", "closed"]).default("open"),
+          labels: z.array(z.string().min(1)).default([]),
+          assignee: z.string().nullable().default(null)
+        })
+      ).default([]),
+      pull_requests: z.array(
+        z.object({
+          number: z.number().int().positive().optional(),
+          title: z.string().min(1),
+          body: z.string().default(""),
+          head: z.string().min(1),
+          base: z.string().min(1).default("main"),
+          state: z.enum(["open", "closed"]).default("open"),
+          author: z.string().min(1).optional(),
+          // Reviews seeded on this PR. State mirrors GitHub's review state
+          // enum; author must exist in users or collaborators.
+          reviews: z.array(
+            z.object({
+              author: z.string().min(1),
+              state: z.enum(["APPROVED", "CHANGES_REQUESTED", "COMMENTED"]).default("APPROVED"),
+              body: z.string().default("")
+            })
+          ).default([]),
+          // Commit statuses on the PR head SHA, wired into commit_statuses
+          // so get_pull_request_status and merge_pull_request see them.
+          statuses: z.array(
+            z.object({
+              context: z.string().min(1).default("ci/build"),
+              state: z.enum(["error", "failure", "pending", "success"]).default("success"),
+              description: z.string().default("")
+            })
+          ).default([])
+        })
+      ).optional()
+    })
+  ).min(1)
+});
+var stripeSeedStateSchema = z.object({
+  api_keys: z.array(
+    z.object({
+      key: z.string().min(1).default("sk_test_pome_default"),
+      sid: z.string().min(1).default("default"),
+      account_id: z.string().min(1).optional()
+    })
+  ).default([]),
+  customers: z.array(z.record(z.string(), z.unknown())).default([]),
+  products: z.array(z.record(z.string(), z.unknown())).default([]),
+  prices: z.array(z.record(z.string(), z.unknown())).default([]),
+  payment_intents: z.array(z.record(z.string(), z.unknown())).default([]),
+  charges: z.array(z.record(z.string(), z.unknown())).default([]),
+  events: z.array(z.record(z.string(), z.unknown())).default([]),
+  balances: z.array(z.record(z.string(), z.unknown())).default([])
+});
+var slackSeedStateSchema = z.object({
+  team: z.object({
+    id: z.string().regex(/^T[A-Z0-9_]+$/).optional(),
+    name: z.string().default("Pome Twin Workspace"),
+    domain: z.string().default("pome-twin")
+  }).prefault({}),
+  users: z.array(
+    z.object({
+      id: z.string().regex(/^[UB][A-Z0-9_]+$/).optional(),
+      name: z.string().min(1),
+      real_name: z.string().default(""),
+      email: z.string().email().optional(),
+      is_bot: z.boolean().default(false),
+      is_admin: z.boolean().default(false),
+      tz: z.string().default("America/Los_Angeles"),
+      profile: z.record(z.string(), z.unknown()).default({})
+    })
+  ).default([]),
+  channels: z.array(
+    z.object({
+      id: z.string().regex(/^[CGDM][A-Z0-9_]+$/).optional(),
+      name: z.string().regex(/^[a-z0-9_-]{1,80}$/),
+      is_private: z.boolean().default(false),
+      topic: z.string().default(""),
+      purpose: z.string().default(""),
+      creator: z.string().optional(),
+      members: z.array(z.string()).default([]),
+      messages: z.array(
+        z.object({
+          ts: z.string().optional(),
+          user: z.string(),
+          text: z.string(),
+          thread_ts: z.string().optional(),
+          reactions: z.array(z.object({ name: z.string(), user: z.string() })).default([])
+        })
+      ).default([])
+    })
+  ).default([]),
+  emoji: z.array(
+    z.object({
+      name: z.string().regex(/^[a-z0-9_+-]{1,100}$/),
+      url: z.string().url().optional(),
+      alias: z.string().regex(/^[a-z0-9_+-]{1,100}$/).optional()
+    })
+  ).default([])
+});
+var gmailEmailSchema = z.string().trim().email().transform((value) => value.toLowerCase());
+var gmailIdSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+var gmailAttachmentSeedSchema = z.object({
+  filename: z.string().max(512),
+  mimeType: z.string().min(1).max(255).default("application/octet-stream"),
+  disposition: z.enum(["attachment", "inline"]).default("attachment"),
+  contentId: z.string().max(998).optional(),
+  data: z.string().max(5e7)
+});
+var gmailMessageSeedFields = {
+  id: gmailIdSchema.optional(),
+  threadId: gmailIdSchema.optional(),
+  raw: z.string().max(5e7).optional(),
+  from: gmailEmailSchema.optional(),
+  to: z.array(gmailEmailSchema).max(500).default([]),
+  cc: z.array(gmailEmailSchema).max(500).default([]),
+  bcc: z.array(gmailEmailSchema).max(500).default([]),
+  subject: z.string().max(998).default(""),
+  text: z.string().max(25e6).default(""),
+  html: z.string().max(25e6).default(""),
+  date: z.string().datetime({ offset: true }).optional(),
+  messageId: z.string().min(3).max(998).optional(),
+  inReplyTo: z.string().max(998).optional(),
+  references: z.array(z.string().max(998)).max(100).default([]),
+  attachments: z.array(gmailAttachmentSeedSchema).max(100).default([])
+};
+var gmailFilterSeedSchema = z.object({
+  id: gmailIdSchema.optional(),
+  criteria: z.object({
+    from: z.string().max(998).optional(),
+    to: z.string().max(998).optional(),
+    subject: z.string().max(998).optional(),
+    query: z.string().max(4096).optional(),
+    negatedQuery: z.string().max(4096).optional(),
+    hasAttachment: z.boolean().optional(),
+    excludeChats: z.boolean().optional(),
+    size: z.number().int().nonnegative().optional(),
+    sizeComparison: z.enum(["larger", "smaller"]).optional()
+  }).default({}),
+  action: z.object({
+    addLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    removeLabelIds: z.array(z.string().min(1)).max(100).default([]),
+    /** Twin rejects filter forwarding (no delivery); keep field for drift detection. */
+    forward: gmailEmailSchema.optional()
+  }).default({ addLabelIds: [], removeLabelIds: [] })
+}).superRefine((filter, ctx) => {
+  if (filter.action.forward) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Filter forwarding is unsupported",
+      path: ["action", "forward"]
+    });
+  }
+});
+var gmailMailboxSeedSchema = z.object({
+  email: gmailEmailSchema,
+  displayName: z.string().max(256).default(""),
+  labels: z.array(
+    z.object({
+      id: gmailIdSchema.optional(),
+      name: z.string().trim().min(1).max(225),
+      color: z.object({
+        textColor: z.string().max(32).optional(),
+        backgroundColor: z.string().max(32).optional()
+      }).optional()
+    })
+  ).max(5e3).default([]),
+  messages: z.array(
+    z.object({
+      ...gmailMessageSeedFields,
+      labels: z.array(z.string().min(1).max(255)).max(100).default([])
+    })
+  ).max(1e4).default([]),
+  drafts: z.array(z.object(gmailMessageSeedFields)).max(5e3).default([]),
+  filters: z.array(gmailFilterSeedSchema).max(1e3).default([]),
+  forwardingAddresses: z.array(z.record(z.string(), z.unknown())).max(1e3).default([]),
+  sendAs: z.array(z.record(z.string(), z.unknown())).max(1e3).default([])
+});
+var gmailFaultSchema = z.object({
+  name: z.enum(["rate-limited"]),
+  target: z.string().min(1).max(128).default("messages.send"),
+  succeedFirst: z.number().int().nonnegative().max(1e3).default(2),
+  throttleFor: z.number().int().positive().max(1e3).default(3),
+  retryAfterSeconds: z.number().int().positive().max(3600).default(1)
+}).strict();
+var gmailSeedStateSchema = z.object({
+  primaryMailbox: gmailMailboxSeedSchema,
+  mailboxes: z.array(gmailMailboxSeedSchema).max(100).default([]),
+  deliveryMode: z.enum(["sender-only", "seeded-mailboxes"]).default("sender-only"),
+  clock: z.string().datetime({ offset: true }).default("2025-01-01T00:00:00.000Z"),
+  faults: z.array(gmailFaultSchema).max(50).default([])
+});
+var linearEmailSchema = z.string().trim().email().transform((value) => value.toLowerCase());
+var linearIdSchema = z.string().min(1).max(128);
+var linearDatetimeSchema = z.string().datetime({ offset: true });
+var linearScopesSchema = z.union([z.array(z.string().min(1).max(64)).max(50), z.string().max(500)]).optional();
+var linearStateTypeSchema = z.enum(["backlog", "unstarted", "started", "completed", "canceled"]);
+var linearSeedStateSchema = z.object({
+  clock: linearDatetimeSchema.default("2026-07-21T00:00:00.000Z"),
+  defaultSid: z.string().min(1).max(128).default("standalone"),
+  baseUrl: z.string().url().default("http://127.0.0.1:3337"),
+  strictScopes: z.boolean().default(false),
+  organization: z.object({
+    id: linearIdSchema.optional(),
+    name: z.string().min(1).max(200).optional(),
+    urlKey: z.string().min(1).max(100).optional()
+  }).optional(),
+  users: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      email: linearEmailSchema,
+      name: z.string().min(1).max(200).optional(),
+      displayName: z.string().min(1).max(200).optional(),
+      avatarUrl: z.string().url().nullable().optional(),
+      active: z.boolean().default(true),
+      admin: z.boolean().default(false),
+      app: z.boolean().default(false)
+    })
+  ).max(500).default([]),
+  teams: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      key: z.string().min(1).max(20),
+      name: z.string().min(1).max(200),
+      description: z.string().max(2e3).nullable().optional(),
+      private: z.boolean().default(false),
+      states: z.array(
+        z.object({
+          id: linearIdSchema.optional(),
+          name: z.string().min(1).max(100),
+          type: linearStateTypeSchema.optional(),
+          position: z.number().int().nonnegative().optional()
+        })
+      ).max(50).optional()
+    })
+  ).max(50).default([]),
+  labels: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      name: z.string().min(1).max(100),
+      color: z.string().max(32).optional(),
+      description: z.string().max(2e3).nullable().optional(),
+      team: z.string().min(1).max(128).optional()
+    })
+  ).max(500).default([]),
+  projects: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      name: z.string().min(1).max(200),
+      description: z.string().max(1e4).nullable().optional(),
+      state: z.enum(["planned", "started", "completed", "canceled"]).default("planned"),
+      team: z.string().min(1).max(128).optional()
+    })
+  ).max(200).default([]),
+  cycles: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      team: z.string().min(1).max(128),
+      name: z.string().min(1).max(200),
+      number: z.number().int().positive().optional(),
+      startsAt: linearDatetimeSchema.nullable().optional(),
+      endsAt: linearDatetimeSchema.nullable().optional()
+    })
+  ).max(200).default([]),
+  issues: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      team: z.string().min(1).max(128),
+      title: z.string().min(1).max(512),
+      description: z.string().max(65536).nullable().optional(),
+      priority: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).default(0),
+      state: z.string().min(1).max(128).optional(),
+      assignee: z.string().min(1).max(200).optional(),
+      creator: z.string().min(1).max(200).optional(),
+      delegate: z.string().min(1).max(200).optional(),
+      project: z.string().min(1).max(200).optional(),
+      cycle: z.string().min(1).max(200).optional(),
+      parent: z.string().min(1).max(200).optional(),
+      estimate: z.number().int().nonnegative().nullable().optional(),
+      labels: z.array(z.string().min(1).max(100)).max(50).default([]),
+      dueDate: z.string().max(32).nullable().optional(),
+      createdAt: linearDatetimeSchema.optional(),
+      updatedAt: linearDatetimeSchema.optional()
+    })
+  ).max(5e3).default([]),
+  comments: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      issue: z.string().min(1).max(128),
+      body: z.string().min(1).max(65536),
+      parent: z.string().min(1).max(128).optional(),
+      user: z.string().min(1).max(200).optional(),
+      createdAt: linearDatetimeSchema.optional()
+    })
+  ).max(2e4).default([]),
+  documents: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      title: z.string().min(1).max(512),
+      content: z.string().max(65536).nullable().optional(),
+      slug: z.string().min(1).max(200).optional(),
+      project: z.string().min(1).max(200).optional(),
+      team: z.string().min(1).max(128).optional(),
+      issue: z.string().min(1).max(200).optional(),
+      cycle: z.string().min(1).max(200).optional(),
+      icon: z.string().max(64).nullable().optional(),
+      color: z.string().max(32).nullable().optional(),
+      creator: z.string().min(1).max(200).optional(),
+      createdAt: linearDatetimeSchema.optional(),
+      updatedAt: linearDatetimeSchema.optional()
+    })
+  ).max(500).default([]),
+  oauthApps: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      clientId: z.string().min(1).max(200),
+      clientSecret: z.string().min(1).max(500),
+      name: z.string().min(1).max(200),
+      redirectUris: z.array(z.string().url()).min(1).max(20),
+      scopes: linearScopesSchema,
+      actor: z.enum(["user", "app"]).default("user"),
+      assignable: z.boolean().default(false),
+      mentionable: z.boolean().default(false),
+      appUserId: z.string().min(1).max(128).nullable().optional()
+    })
+  ).max(20).default([]),
+  tokens: z.array(
+    z.object({
+      token: z.string().min(1).max(500),
+      type: z.enum(["personal", "oauth_access", "client_credentials"]).default("personal"),
+      user: z.string().min(1).max(200).optional(),
+      app: z.string().min(1).max(200).optional(),
+      scopes: linearScopesSchema,
+      actor: z.enum(["user", "app"]).optional(),
+      sid: z.string().min(1).max(128).optional(),
+      expiresAt: linearDatetimeSchema.nullable().optional()
+    })
+  ).max(50).default([]),
+  webhooks: z.array(
+    z.object({
+      id: linearIdSchema.optional(),
+      label: z.string().min(1).max(200).optional(),
+      url: z.string().url(),
+      resourceTypes: linearScopesSchema,
+      team: z.string().min(1).max(128).optional(),
+      allPublicTeams: z.boolean().optional(),
+      secret: z.string().max(500).nullable().optional(),
+      enabled: z.boolean().default(true)
+    })
+  ).max(50).default([])
+});
+var providerScopedSeedStateSchema = z.object({
+  github: z.object({ seed: githubSeedStateSchema }).optional(),
+  stripe: z.object({ seed: stripeSeedStateSchema }).optional(),
+  slack: z.object({ seed: slackSeedStateSchema }).optional(),
+  gmail: z.object({ seed: gmailSeedStateSchema }).optional(),
+  linear: z.object({ seed: linearSeedStateSchema }).optional()
+}).refine(
+  (value) => Boolean(value.github || value.stripe || value.slack || value.gmail || value.linear),
+  {
+    message: "seedState must include github.seed, stripe.seed, slack.seed, gmail.seed, linear.seed, or the legacy GitHub seed shape"
+  }
+);
+var seedStateSchema = z.union([githubSeedStateSchema, providerScopedSeedStateSchema]);
+z.record(
+  z.string(),
+  z.record(z.string(), z.unknown())
+);
+var taskConfigSchema = z.object({
+  twins: z.array(z.string()).default(["github"]),
+  timeout: z.number().int().positive().default(60),
+  // seconds
+  runs: z.number().int().positive().default(1),
+  passThreshold: z.number().min(0).max(100).default(100),
+  judge: judgeModelSchema.default("claude-haiku-4-5")
+  // CLI's BYOK config decides which endpoint serves this
+});
+z.object({
+  slug: z.string().min(1),
+  title: z.string().min(1),
+  setup: z.string().default(""),
+  // human-readable prose; ignored at runtime
+  prompt: z.string().min(1),
+  expectedBehavior: z.string().default(""),
+  // evaluator-only, NEVER sent to agent
+  criteria: z.array(criterionSchema).min(1),
+  config: taskConfigSchema,
+  seedState: seedStateSchema
+});
+z.object({
+  id: z.string(),
+  // scn_<nanoid>
+  team_id: z.string(),
+  name: z.string(),
+  source: z.string(),
+  // raw markdown
+  source_hash: z.string(),
+  // sha256(source)
+  uploaded_by: z.string(),
+  // user_id
+  created_at: z.string().datetime(),
+  archived_at: z.string().datetime().nullable()
+});
+z.object({
+  user: userSchema.pick({ id: true, email: true }),
+  team: teamSchema.pick({ id: true, slug: true, plan_tier: true }),
+  api_key: apiKeySchema.pick({ id: true, name: true })
+});
+var createSessionRequestObjectSchema = z.object({
+  // Multi-twin (M3): multi-twin arrays are now honored — the cloud provisions
+  // one isolated sandbox per twin. Max 3 twins per session; the cap is
+  // enforced cloud-side, so we deliberately do NOT add a `.max()` here (the
+  // boundary stays permissive and the cloud owns the quota rule). `twins[0]`
+  // is the session's primary twin — the default attribution for criteria and
+  // state that omit an explicit twin.
+  //
+  // Back-compat (the whole M3 contract): a single-twin `twins` array plus none
+  // of the new optional fields below is byte-identical to pre-M3 behavior, so
+  // (old CLI × new cloud) is unchanged. (new CLI × old cloud) with >1 twin is
+  // rejected by the cloud with 422 `multi_twin_unsupported`; a single-twin
+  // request degrades gracefully because every new field is optional and
+  // non-strict readers strip unknown keys rather than erroring.
+  twins: z.array(z.string()).min(1).default(["github"]),
+  task_source: z.string().optional(),
+  // base64-encoded UTF-8 markdown; 0.3.0 alias: scenario_source
+  task_id: z.string().optional(),
+  // alternative: stored task; 0.3.0 alias: scenario_id
+  // FDRS-580 / ADR-015 (adopted from pome-cloud, FDRS-613): the seed override
+  // is a PERMISSIVE, shape-blind boundary. The twin pod's own `parseSeed` is
+  // the sole authority on the seed's domain shape; the cloud forwards it
+  // verbatim. `z.record` keeps the one invariant that is the boundary's
+  // business — "the seed is a JSON object" — while forwarding every domain
+  // field, known or not, untouched. Do NOT re-narrow to `seedStateSchema`
+  // here: a narrow `.object()` strips unknown keys, which is how PR-based
+  // scenarios lost their `users` / `pull_requests` / `files`.
+  seed: z.record(z.string(), z.unknown()).optional(),
+  // optional override
+  // M3: client-supplied UUID v4 used for 30s server-side dedupe of
+  // POST /v1/sessions. The dashboard generates one per Start-button click;
+  // legacy clients work without it.
+  idempotency_key: z.string().uuid().optional(),
+  // M3 / FDRS-636: client-minted trial-group identity — `pome run -n k`
+  // (and `pome demo`) stamp one id per invocation, shared by all k trial
+  // sessions. The cloud copies it onto sessions.group_id at mint and onto
+  // runs.group_id at finalize; the demo/eval mints already accept the same
+  // field. Format mirrors the cloud's GROUP_ID_RE. Legacy clients omit it.
+  group_id: z.string().regex(/^[A-Za-z0-9_-]{6,64}$/).optional(),
+  // F-818 (spec F-804): per-run override of the manifest's agent.version —
+  // an opaque user-declared label stamped onto the session/run rows (F-820).
+  // Absent = the agent's registered version. Additive; older clients omit it
+  // and an older cloud strips it.
+  agent_version: z.string().optional()
+}).refine(
+  (v) => Boolean(v.task_source) !== Boolean(v.task_id),
+  { message: "Provide exactly one of task_source or task_id (scenario_source / scenario_id are accepted 0.3.0 aliases)" }
+);
+z.preprocess(
+  normalizeTaskVocabKeys,
+  createSessionRequestObjectSchema
+);
+function normalizeCreateSessionResponse(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const record = value;
+  if (typeof record.session_id !== "string" || typeof record.twin_url !== "string" || typeof record.openapi_url !== "string") {
+    return value;
+  }
+  let twin = "github";
+  try {
+    const [, parsedTwin] = new URL(record.twin_url).pathname.split("/");
+    if (parsedTwin !== void 0 && parsedTwin.length > 0) twin = parsedTwin;
+  } catch {
+  }
+  const apiUrl = record.twin_url;
+  const mcpUrl = typeof apiUrl === "string" && apiUrl.startsWith("https://api.pome.sh/") ? apiUrl.replace("https://api.pome.sh/", "https://mcp.pome.sh/") : apiUrl;
+  return {
+    ...record,
+    session_token: record.session_token ?? record.session_id,
+    per_twin: record.per_twin ?? {
+      [twin]: {
+        api_url: apiUrl,
+        mcp_url: mcpUrl,
+        openapi_url: record.openapi_url
+      }
+    }
+  };
+}
+var createSessionResponseSchema = z.preprocess(normalizeCreateSessionResponse, z.object({
+  session_id: z.string(),
+  session_token: z.string(),
+  // = session_id in V1; public URL token
+  twin_url: z.string().url(),
+  // legacy: = per_twin[twins[0]].api_url
+  expires_at: z.string().datetime(),
+  agent_token: z.string(),
+  // edt_<jwt>; SENSITIVE — never log; CLI memory only; bearer scoped to session TTL
+  provider_credentials: z.object({
+    github: z.object({
+      token: z.string(),
+      header: z.literal("Authorization"),
+      scheme: z.literal("Bearer")
+    }).optional(),
+    stripe: z.object({
+      api_key: z.string(),
+      header: z.literal("Authorization"),
+      scheme: z.literal("Bearer")
+    }).optional(),
+    slack: z.object({
+      token: z.string(),
+      header: z.literal("Authorization"),
+      scheme: z.literal("Bearer")
+    }).optional()
+  }).default({}),
+  openapi_url: z.string().url(),
+  // legacy: = per_twin[twins[0]].openapi_url
+  per_twin: z.record(
+    z.string(),
+    z.object({
+      api_url: z.string().url(),
+      // api.pome.sh/<twin>/<session_token>
+      mcp_url: z.string().url(),
+      // mcp.pome.sh/<twin>/<session_token> (501 stub in V1)
+      openapi_url: z.string().url()
+    })
+  )
+}));
+var perTwinStateKeysSchema = z.record(
+  z.string(),
+  z.object({
+    state_initial_key: z.string().min(1).optional(),
+    state_final_key: z.string().min(1).optional()
+  }).refine(
+    (v) => v.state_initial_key !== void 0 || v.state_final_key !== void 0,
+    { message: "Each twin entry must carry at least one of state_initial_key or state_final_key" }
+  )
+);
+var submitResultRequestObjectSchema = z.object({
+  task_name: z.string(),
+  // 0.3.0 alias: scenario_name
+  task_hash: z.string(),
+  // 0.3.0 alias: scenario_hash
+  duration_ms: z.number().int(),
+  agent_model: z.string(),
+  // CLI-computed scoring fields (server-trusted; under BYOK there's nothing
+  // billing-sensitive to spoof — we don't bill on judge cost):
+  satisfaction_score: z.number().int().min(0).max(100),
+  criteria_results: z.array(criterionResultSchema),
+  judge_model: judgeModelSchema,
+  judge_tokens_in: z.number().int().min(0).nullable(),
+  judge_tokens_out: z.number().int().min(0).nullable(),
+  // Correlator output + fix-prompt from CLI (post-M3i). Defaults supplied for
+  // backward compat during the M3i rollout — older CLIs that omit these still
+  // submit successfully and the run lands as a "legacy" row (empty lanes/steps,
+  // null fix_prompt). When all CLIs are M3i+, tighten by removing defaults.
+  lanes: z.array(laneSchema).default([]),
+  steps: z.array(stepSchema).default([]),
+  fix_prompt: z.string().nullable().default(null),
+  // FDRS-357 (adopted from pome-cloud, FDRS-613): storage key (NOT URL) returned
+  // by POST /v1/sessions/:id/result-upload-url. Null on upload failure
+  // (best-effort), --no-upload opt-out, or pre-FDRS-357 CLI.
+  events_jsonl_url: z.string().nullable().default(null),
+  // Trace blobs — safe to upload (HTTP between agent and twin, not LLM prompts):
+  trace_jsonl_b64: z.string(),
+  state_initial_json_b64: z.string(),
+  state_final_json_b64: z.string()
+  // NOTE: agent_stdout is intentionally NOT in this request. Cloud never
+  // receives the agent's prompts or completions. The CLI uses agent_stdout
+  // locally for the [model] judge then discards it.
+});
+z.preprocess(
+  normalizeTaskVocabKeys,
+  submitResultRequestObjectSchema
+);
+var submitResultResponseSchema = z.object({
+  run_id: z.string(),
+  dashboard_url: z.string().url()
+});
+var createEvalSessionResponseSchema = z.object({
+  session_id: z.string(),
+  expires_at: z.string()
+});
+var criterionDefSchema = z.object({
+  id: z.string().min(1),
+  text: z.string().min(1),
+  // Tolerant reader (F-778): released CLIs still send the legacy "D"/"P"
+  // spellings; parsed output is always the canonical "code"/"model". Single
+  // source of truth for the rename is LEGACY_CRITERION_KIND_MAP.
+  kind: z.enum(["D", "P", "code", "model"]).transform(
+    (kind) => kind === "D" || kind === "P" ? LEGACY_CRITERION_KIND_MAP[kind] : kind
+  ),
+  // Multi-twin (M3): the twin a [code:<twin>]/[model:<twin>] task criterion
+  // attributes to. Absent = the session's primary twin (twins[0]). Additive —
+  // single-twin tasks omit it and score against the sole twin as before.
+  twin: z.string().min(1).optional()
+});
+z.object({
+  name: z.string().min(1),
+  // Manifest identity (F-818, spec F-804): human-ish slug input — the server
+  // derives the canonical kebab slug with the same deriveAgentSlug exported
+  // from `./manifest.js`, then validates it against SLUG_RE. Cap mirrors the
+  // control-plane edge; shape is deliberately NOT enforced here.
+  slug: z.string().min(1).max(64).optional(),
+  description: z.string().optional(),
+  // User-declared version label from the manifest's agent.version — an opaque
+  // string, never auto-bumped, never semver-interpreted.
+  version: z.string().optional(),
+  // Open enum by design (F-804): unknown frameworks get a did-you-mean warning
+  // server-side, never a validation error.
+  framework: z.string().min(1).optional(),
+  // Multi-twin (M3): the twins this agent is allowed to exercise. Absent = the
+  // server's default enablement. The cloud intersects a session's requested
+  // twins with the agent's enabled services. Additive; older clients omit it.
+  twins: z.array(z.string()).min(1).optional()
+});
+var agentResponseSchema = z.object({
+  id: z.string(),
+  // agt_<nanoid>
+  slug: z.string(),
+  display_name: z.string(),
+  judge_model: z.string(),
+  // Manifest identity (F-818): registered agent.framework / agent.description /
+  // agent.version, nullable where the server has nothing stored. Optional for
+  // the pre-F-820 cloud, which omits them.
+  framework: z.string().optional(),
+  description: z.string().nullable().optional(),
+  version: z.string().nullable().optional(),
+  // F-818 resolver semantics: true when POST /v1/agents auto-registered a new
+  // agent for this slug, false when it resolved an existing one. Optional for
+  // the pre-F-820 cloud; absence means "unknown", not "resolved".
+  created: z.boolean().optional(),
+  // F-861 slug-rename hint (cloud-emitted since v0.4.18): how the resolver
+  // matched this slug. Known values today are "slug" (live match), "alias" (an
+  // old slug that was renamed; the returned `slug` is the new canonical), and
+  // "created" (fresh auto-register) — the CLI surfaces a rename notice only on
+  // "alias". Open enum by design (like request-side `framework`): typed as a
+  // string, not a closed z.enum, so a future resolver mode is tolerated as an
+  // additive value rather than rejecting the whole response. `hint` is an
+  // optional human-readable nudge to print verbatim. Both optional for the
+  // pre-v0.4.18 cloud; absence means "unknown".
+  resolved_via: z.string().optional(),
+  hint: z.string().optional(),
+  // Multi-twin (M3): the services (twins) this agent may exercise. Absent on an
+  // older cloud; new CLIs treat absence as "unconstrained / server default".
+  enabled_services: z.array(z.string()).optional()
+});
+var stateUploadUrlEntrySchema = z.object({
+  url: z.string().url(),
+  key: z.string().min(1)
+});
+z.object({
+  state_initial: stateUploadUrlEntrySchema,
+  state_final: stateUploadUrlEntrySchema,
+  // Multi-twin (M3): one initial/final URL+key pair per twin, keyed by twin id,
+  // so each twin's state blobs land under its own storage prefix. Absent on
+  // single-twin sessions and on an older cloud, where the top-level pair is
+  // authoritative (new CLI × old cloud degrades gracefully).
+  per_twin: z.record(
+    z.string(),
+    z.object({
+      state_initial: stateUploadUrlEntrySchema,
+      state_final: stateUploadUrlEntrySchema
+    })
+  ).optional()
+});
+z.object({
+  period_start: z.string().datetime(),
+  period_end: z.string().datetime(),
+  sessions_used: z.number().int().min(0),
+  sessions_quota: z.number().int().min(0),
+  sessions_remaining: z.number().int().min(0),
+  plan_tier: planTierSchema
+});
+z.object({
+  email: z.string().email(),
+  role: teamRoleSchema.default("member")
+});
+z.object({
+  invite: teamInviteSchema,
+  invite_url: z.string().url()
+  // "https://pome.sh/invites/<token>"
+});
+z.object({
+  token: z.string().min(16)
+});
+z.object({
+  team_id: z.string(),
+  role: teamRoleSchema
+});
+z.object({
+  stop_reason: z.string(),
+  // "completed" | "timeout" | "preflight_failed" | …
+  exit_code: z.number().int(),
+  duration_ms: z.number().int(),
+  agent_model: z.string(),
+  agent_sdk: z.string().nullable(),
+  // normalizeAgentSdk() output: trimmed string or null
+  // Criterion DEFINITIONS (not results): cloud judges these against the recorded
+  // trace/state and returns the authoritative score. Carries optional per-criterion
+  // twin attribution (multi-twin M3).
+  criteria: z.array(criterionDefSchema),
+  scenario_name: z.string(),
+  scenario_hash: z.string(),
+  scenario_prompt: z.string(),
+  expected_behavior: z.string(),
+  // Optional storage-key overrides; omitted keys fall back to the conventional
+  // team-<>/session-<>/<filename> paths written by the *-upload-url routes.
+  trace_storage_key: z.string().optional(),
+  state_initial_storage_key: z.string().optional(),
+  state_final_storage_key: z.string().optional(),
+  signals_storage_key: z.string().optional(),
+  // Multi-twin (M3): additive per-twin state storage keys, keyed by twin id.
+  // Absent on single-twin sessions, which use the flat state_*_storage_key fields
+  // above. Unknown to an older cloud, which strips it and scores the primary twin
+  // unchanged (new CLI × old cloud degrades gracefully).
+  per_twin_state_keys: perTwinStateKeysSchema.optional()
+});
+var finalizeResponseSchema = z.object({
+  run_id: z.string(),
+  score: z.number().int().min(0).max(100),
+  judge_model: z.string().nullable().optional(),
+  dashboard_url: z.string().url(),
+  criteria_results: z.array(criterionResultSchema).optional()
+});
+var finalizeStatusUrlSchema = z.string().min(1).refine(
+  (value) => {
+    if (value.startsWith("/") && !value.startsWith("//")) return true;
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  { message: "Invalid status_url" }
+);
+var finalizeAcceptedResponseSchema = z.object({
+  evaluation_id: z.string().min(1),
+  run_id: z.string().min(1),
+  status: z.literal("queued"),
+  status_url: finalizeStatusUrlSchema
+}).strict();
+var finalizeStatusIdentitySchema = {
+  evaluation_id: z.string().min(1),
+  run_id: z.string().min(1)
+};
+var finalizeQueuedStatusResponseSchema = z.object({
+  ...finalizeStatusIdentitySchema,
+  status: z.literal("queued")
+}).strict();
+var finalizeRunningStatusResponseSchema = z.object({
+  ...finalizeStatusIdentitySchema,
+  status: z.literal("running")
+}).strict();
+var finalizeFailureErrorSchema = z.object({
+  type: z.string().min(1),
+  message: z.string().min(1),
+  details: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var finalizeFailedStatusResponseSchema = z.object({
+  ...finalizeStatusIdentitySchema,
+  status: z.literal("failed"),
+  error: finalizeFailureErrorSchema
+}).strict();
+var finalizeCompletedStatusResponseSchema = z.object({
+  ...finalizeStatusIdentitySchema,
+  status: z.literal("completed"),
+  result: finalizeResponseSchema
+}).strict();
+z.discriminatedUnion("status", [
+  finalizeQueuedStatusResponseSchema,
+  finalizeRunningStatusResponseSchema,
+  finalizeFailedStatusResponseSchema,
+  finalizeCompletedStatusResponseSchema
+]);
+z.union([
+  finalizeResponseSchema,
+  finalizeAcceptedResponseSchema
+]);
+var apiErrorTypeSchema = z.enum([
+  "invalid_auth",
+  "revoked_key",
+  "forbidden",
+  // 403 non-auth permission denial
+  "quota_exceeded",
+  "validation_failed",
+  "not_found",
+  "session_expired",
+  // distinct from not_found for CLI UX
+  "conflict",
+  // 409 (uniqueness, etc.)
+  "rate_limited",
+  "internal_error",
+  "endpoint_not_implemented",
+  "downstream_unavailable"
+]);
+z.object({
+  error: z.object({
+    type: apiErrorTypeSchema,
+    message: z.string(),
+    details: z.record(z.string(), z.unknown()).optional(),
+    documentation_url: z.string().url().optional(),
+    request_id: z.string()
+  })
+});
+
+// src/hosted/errors.ts
+var HostedAuthError = class extends Error {
+  constructor(message, requestId) {
+    super(message);
+    this.requestId = requestId;
+    this.name = "HostedAuthError";
+  }
+  requestId;
+};
+var HostedQuotaError = class extends Error {
+  /** `details` mirrors the cloud error envelope's machine-readable details
+   *  (e.g. `{ kind: "daily_judge_cap" }`) so `pome demo` (FDRS-643/662) can
+   *  render honest labeled at-capacity states. Optional: older responses and
+   *  the twin-pod 401 shape carry none. */
+  constructor(message, requestId, details) {
+    super(message);
+    this.requestId = requestId;
+    this.details = details;
+    this.name = "HostedQuotaError";
+  }
+  requestId;
+  details;
+};
+var HostedOrchError = class extends Error {
+  /** `status` is the HTTP status that produced this error, when one exists
+   *  (network/parse failures leave it undefined). `pome eval` uses it to
+   *  scope its reaped-session retry to 404/410 only (FDRS-656 review). */
+  constructor(message, requestId, status, type) {
+    super(message);
+    this.requestId = requestId;
+    this.status = status;
+    this.type = type;
+    this.name = "HostedOrchError";
+  }
+  requestId;
+  status;
+  type;
+};
+var HostedUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HostedUsageError";
+  }
+};
+var HostedTrialError = class extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+    this.name = "HostedTrialError";
+  }
+  errorCode;
+};
+var HostedDiscardRefusedError = class extends Error {
+  constructor(message, sessionId, state, taskName, openSeconds, discardToken) {
+    super(message);
+    this.sessionId = sessionId;
+    this.state = state;
+    this.taskName = taskName;
+    this.openSeconds = openSeconds;
+    this.discardToken = discardToken;
+    this.name = "HostedDiscardRefusedError";
+  }
+  sessionId;
+  state;
+  taskName;
+  openSeconds;
+  discardToken;
+};
+function exitCodeFor(err) {
+  if (err instanceof HostedAuthError) return 3;
+  if (err instanceof HostedQuotaError) return 4;
+  if (err instanceof HostedUsageError) return 5;
+  return 2;
+}
+
+export { HostedAuthError, HostedDiscardRefusedError, HostedOrchError, HostedQuotaError, HostedTrialError, HostedUsageError, MOUNTED_TWINS, SLUG_RE, agentResponseSchema, createEvalSessionResponseSchema, createSessionResponseSchema, criterionSchema, deriveAgentSlug, exitCodeFor, finalizeResponseSchema, manifestSchema, sessionPublicSchema, submitResultResponseSchema };