@withgauge/cli 0.12.1 → 0.13.0

package/dist/index.js

@@ -1934,295 +1934,20 @@ var executionTargetsResponseSchema = z21.object({
   items: z21.array(executionTargetSchema)
 });
 
-// ../packages/api-schemas/src/experiments.ts
-var experiments_exports = {};
-__export(experiments_exports, {
-  EXPERIMENT_MODES: () => EXPERIMENT_MODES,
-  EXPERIMENT_STATUSES: () => EXPERIMENT_STATUSES,
-  SUPPORT_CLASSES: () => SUPPORT_CLASSES,
-  TERMINAL_EXPERIMENT_STATUSES: () => TERMINAL_EXPERIMENT_STATUSES,
-  addVariantBodySchema: () => addVariantBodySchema,
-  cancelResponseSchema: () => cancelResponseSchema,
-  createExperimentBodyFields: () => createExperimentBodyFields,
-  createExperimentBodySchema: () => createExperimentBodySchema,
-  createExperimentResponseSchema: () => createExperimentResponseSchema,
-  eligibleExperimentRunSchema: () => eligibleExperimentRunSchema,
-  experimentBoundarySchema: () => experimentBoundarySchema,
-  experimentContentQuerySchema: () => experimentContentQuerySchema,
-  experimentContentResponseSchema: () => experimentContentResponseSchema,
-  experimentContentTypeSchema: () => experimentContentTypeSchema,
-  experimentDetailSchema: () => experimentDetailSchema,
-  experimentListQuerySchema: () => experimentListQuerySchema,
-  experimentListResponseSchema: () => experimentListResponseSchema,
-  experimentModeSchema: () => experimentModeSchema,
-  experimentStatusResponseSchema: () => experimentStatusResponseSchema,
-  experimentStatusSchema: () => experimentStatusSchema,
-  experimentSummarySchema: () => experimentSummarySchema,
-  experimentVariantSchema: () => experimentVariantSchema,
-  fixerEditSchema: () => fixerEditSchema,
-  launchResultSchema: () => launchResultSchema,
-  patchVariantBodySchema: () => patchVariantBodySchema,
-  recommendationSchema: () => recommendationSchema,
-  shipBodySchema: () => shipBodySchema,
-  supportClassSchema: () => supportClassSchema,
-  variantDeltaSchema: () => variantDeltaSchema,
-  variantRefSchema: () => variantRefSchema,
-  variantRunSchema: () => variantRunSchema,
-  writeRoundResponseSchema: () => writeRoundResponseSchema,
-  writeVariantContentBodySchema: () => writeVariantContentBodySchema,
-  writeVariantContentResponseSchema: () => writeVariantContentResponseSchema
-});
+// ../packages/api-schemas/src/invites.ts
 import { z as z22 } from "zod";
-var EXPERIMENT_STATUSES = [
-  "DRAFT",
-  "GENERATING",
-  "LAUNCHING",
-  "RUNNING",
-  "SYNTHESIZING",
-  "COMPLETE",
-  "PARTIAL",
-  "FAILED",
-  "CANCELED"
-];
-var experimentStatusSchema = z22.enum(EXPERIMENT_STATUSES);
-var TERMINAL_EXPERIMENT_STATUSES = [
-  "COMPLETE",
-  "PARTIAL",
-  "FAILED",
-  "CANCELED"
-];
-var SUPPORT_CLASSES = [
-  "RECOMMENDED",
-  "PROMISING",
-  "NOT_SUPPORTED",
-  "NOT_EVALUABLE"
-];
-var supportClassSchema = z22.enum(SUPPORT_CLASSES);
-var jsonValue = z22.unknown();
-var EXPERIMENT_MODES = ["PROPOSE", "DIRECT", "MANUAL"];
-var experimentModeSchema = z22.enum(EXPERIMENT_MODES);
-var createExperimentBodyFields = z22.object({
-  runId: z22.string().min(1),
-  boundarySeq: z22.string().min(1),
-  problemText: z22.string().trim().min(1).optional(),
-  /** OPTIONAL, and it stays optional: a CLI built before the bifurcation must
-   *  keep working, and omitting it means PROPOSE — the behaviour it already
-   *  expects. */
-  mode: experimentModeSchema.optional(),
-  /** DIRECT only: the one change to make, in the author's own words. Ignored
-   *  in the other modes. Carried as the single rewrite's title, and REQUIRED
-   *  when `mode` is DIRECT — see the cross-field check below. */
-  changeInstruction: z22.string().trim().min(1).max(200).optional()
-});
-var createExperimentBodySchema = createExperimentBodyFields.superRefine((body, ctx) => {
-  if (body.mode === "DIRECT" && !body.changeInstruction) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["changeInstruction"],
-      message: "mode DIRECT requires changeInstruction \u2014 the one change to make, in your own words"
-    });
-  }
-});
-var createExperimentResponseSchema = z22.object({
-  experimentId: z22.string(),
-  /** false = an existing draft for this (run, boundary) was resumed. */
-  created: z22.boolean(),
-  /** What is persisted — a resume keeps the statement it was opened with. */
-  problemText: z22.string(),
-  /** The PERSISTED mode, echoed for the same reason `problemText` is: exactly
-   *  one live draft exists per (run, boundary), so a resume returns the mode
-   *  that draft was opened with — which may not be the one this call asked
-   *  for. Clients report what came back, not what they sent. */
-  mode: experimentModeSchema
-});
-var experimentListQuerySchema = z22.object({
-  status: z22.string().transform(
-    (s) => s.split(",").map((x) => x.trim().toUpperCase()).filter(Boolean)
-  ).pipe(z22.array(experimentStatusSchema)).optional(),
-  limit: z22.coerce.number().int().min(1).max(100).default(25)
-});
-var experimentSummarySchema = z22.object({
+var inviteSchema = z22.object({
   id: z22.string(),
-  status: experimentStatusSchema,
-  problem: z22.string(),
-  boundaryUrl: z22.string().nullable(),
-  sourceRunId: z22.string(),
-  variantCount: z22.number().int(),
-  createdAt: z22.string()
-});
-var experimentListResponseSchema = z22.object({
-  items: z22.array(experimentSummarySchema)
-});
-var eligibleExperimentRunSchema = z22.object({
-  runId: z22.string(),
-  agent: agentSchema,
-  promptText: z22.string(),
-  createdAt: z22.string(),
-  verdict: z22.string().nullable(),
-  boundaryCount: z22.number().int()
-});
-var experimentBoundarySchema = z22.object({
-  boundarySeq: z22.union([z22.string(), z22.number()]),
-  turn: z22.number().int().nullable(),
-  url: z22.string(),
-  domain: z22.string().nullable(),
-  fetchPrompt: z22.string().nullable(),
-  source: z22.string(),
-  boundaryCheckpointId: z22.string().nullable(),
-  boundaryOrdinal: z22.number().int().nullable(),
-  capturedOccurrence: z22.number().int().nullable()
-});
-var variantRunSchema = z22.object({
-  runId: z22.string(),
-  status: z22.string(),
-  failureReason: z22.string().nullable(),
-  integrations: z22.array(jsonValue)
-});
-var experimentVariantSchema = z22.object({
-  variantId: z22.string(),
-  key: z22.string(),
-  title: z22.string(),
-  hypothesis: z22.string(),
-  rewriteChars: z22.number().int(),
-  hasRewrite: z22.boolean(),
-  invalidReason: z22.string().nullable(),
-  planStatus: z22.string().nullable(),
-  planError: z22.string().nullable(),
-  runs: z22.array(variantRunSchema),
-  /** Arm verdict / finding counts / EXPERIMENT_DELTA output — server-owned
-   *  analytic JSON, null until computable. */
-  verdict: jsonValue.nullable(),
-  findings: jsonValue.nullable(),
-  delta: jsonValue.nullable()
-});
-var experimentDetailSchema = z22.object({
-  id: z22.string(),
-  status: experimentStatusSchema,
-  problem: z22.string(),
-  boundaryUrl: z22.string().nullable(),
-  createdAt: z22.string(),
-  editable: z22.boolean(),
-  roundInFlight: z22.boolean(),
-  launching: z22.boolean(),
-  launchError: z22.string().nullable(),
-  planned: z22.boolean(),
-  livePage: jsonValue.nullable(),
-  sourceRun: z22.object({
-    runId: z22.string(),
-    agent: agentSchema,
-    status: z22.string(),
-    task: z22.string(),
-    repoUrl: z22.string().nullable(),
-    verdict: jsonValue.nullable(),
-    integrations: z22.array(jsonValue)
+  email: z22.string(),
+  invitedBy: z22.object({
+    name: z22.string().nullable(),
+    email: z22.string().nullable()
   }),
-  variants: z22.array(experimentVariantSchema),
-  /** The settled comparison (winners vs baseline) — null until launched. */
-  summary: jsonValue.nullable()
-});
-var experimentStatusResponseSchema = z22.object({
-  id: z22.string(),
-  status: experimentStatusSchema,
-  planned: z22.boolean(),
-  writeStartedAt: z22.string().nullable(),
-  launchStartedAt: z22.string().nullable(),
-  launchError: z22.string().nullable(),
-  shippedVariantId: z22.string().nullable(),
-  shippedAt: z22.string().nullable()
-});
-var addVariantBodySchema = z22.object({
-  title: z22.string().optional(),
-  hypothesis: z22.string().optional()
-});
-var patchVariantBodySchema = z22.object({
-  title: z22.string().optional(),
-  hypothesis: z22.string().optional()
-});
-var fixerEditSchema = z22.object({
-  find: z22.string().min(1),
-  replace: z22.string()
-});
-var experimentContentTypeSchema = z22.string().trim().toLowerCase().max(127).regex(
-  /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/,
-  "contentType must be a MIME type such as text/markdown"
-);
-var writeVariantContentBodySchema = z22.object({
-  content: z22.string().optional(),
-  edits: z22.array(fixerEditSchema).optional(),
-  contentType: experimentContentTypeSchema.optional()
-});
-var writeVariantContentResponseSchema = z22.object({
-  variantId: z22.string(),
-  chars: z22.number().int(),
-  truncated: z22.boolean(),
-  applied: z22.number().int(),
-  skipped: z22.number().int()
-});
-var experimentContentQuerySchema = z22.object({
-  variantId: z22.string().optional(),
-  offset: z22.coerce.number().int().min(0).default(0),
-  maxChars: z22.coerce.number().int().min(1).max(4e4).default(2e4)
-});
-var experimentContentResponseSchema = z22.object({
-  source: z22.string(),
-  totalChars: z22.number().int(),
-  offset: z22.number().int(),
-  returnedChars: z22.number().int(),
-  nextOffset: z22.number().int().nullable(),
-  content: z22.string()
-});
-var writeRoundResponseSchema = z22.object({
-  queued: z22.number().int(),
-  reason: z22.enum(["round_in_flight", "nothing_pending"]).optional()
-});
-var launchResultSchema = z22.object({
-  experimentId: z22.string(),
-  status: z22.literal("LAUNCHING")
-});
-var shipBodySchema = z22.object({ variantId: z22.string().min(1) });
-var cancelResponseSchema = z22.object({
-  id: z22.string(),
-  status: z22.literal("CANCELED")
-});
-var variantDeltaSchema = z22.object({
-  changed: z22.boolean().nullable(),
-  hypothesisSupported: z22.enum(["supported", "refuted", "inconclusive"]).nullable(),
-  summary: z22.string().nullable()
-});
-var variantRefSchema = z22.object({
-  key: z22.string(),
-  title: z22.string(),
-  effect: z22.number().nullable(),
-  consistency: z22.string().nullable(),
-  note: z22.string().nullable(),
-  delta: variantDeltaSchema.nullable().optional()
-});
-var recommendationSchema = z22.object({
-  evaluatorVersion: z22.string(),
-  summary: z22.string(),
-  groups: z22.object({
-    recommended: z22.array(variantRefSchema),
-    promising: z22.array(variantRefSchema),
-    notSupported: z22.array(variantRefSchema),
-    notEvaluable: z22.array(variantRefSchema)
-  }),
-  tradeoffs: z22.array(z22.string())
-});
-
-// ../packages/api-schemas/src/invites.ts
-import { z as z23 } from "zod";
-var inviteSchema = z23.object({
-  id: z23.string(),
-  email: z23.string(),
-  invitedBy: z23.object({
-    name: z23.string().nullable(),
-    email: z23.string().nullable()
-  }),
-  createdAt: z23.string(),
-  expiresAt: z23.string()
+  createdAt: z22.string(),
+  expiresAt: z22.string()
 });
-var listInvitesResponseSchema = z23.object({
-  items: z23.array(inviteSchema)
+var listInvitesResponseSchema = z22.object({
+  items: z22.array(inviteSchema)
 });
 
 // ../packages/api-schemas/src/keys.ts
@@ -2235,177 +1960,177 @@ __export(keys_exports, {
   setProviderKeyBodySchema: () => setProviderKeyBodySchema,
   setProviderKeyResponseSchema: () => setProviderKeyResponseSchema
 });
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 var PROVIDER_TYPES = ["anthropic", "openai"];
-var providerTypeSchema = z24.enum(PROVIDER_TYPES);
-var setProviderKeyBodySchema = z24.object({
+var providerTypeSchema = z23.enum(PROVIDER_TYPES);
+var setProviderKeyBodySchema = z23.object({
   /** The raw provider API key. Verified + stored server-side (AWS Secrets
    *  Manager); never persisted in the app DB and never echoed back. */
-  key: z24.string().min(1)
+  key: z23.string().min(1)
 });
-var setProviderKeyResponseSchema = z24.object({
+var setProviderKeyResponseSchema = z23.object({
   providerType: providerTypeSchema,
-  last4: z24.string()
+  last4: z23.string()
 });
-var providerKeySchema = z24.object({
+var providerKeySchema = z23.object({
   providerType: providerTypeSchema,
-  last4: z24.string(),
-  createdAt: z24.string(),
+  last4: z23.string(),
+  createdAt: z23.string(),
   /** When the key was last saved/rotated. */
-  updatedAt: z24.string()
+  updatedAt: z23.string()
 });
 var providerKeyListResponseSchema = listResponseSchema(providerKeySchema);
 
 // ../packages/api-schemas/src/mcp.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // ../packages/api-schemas/src/skills.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var sha256Hex = sha256DigestSchema;
-var skillHandleSchema = z25.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid skill handle").refine((name) => name !== "." && name !== "..", "invalid skill handle");
-var skillSetEntrySchema = z25.object({
-  skillId: z25.string().min(1),
+var skillHandleSchema = z24.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid skill handle").refine((name) => name !== "." && name !== "..", "invalid skill handle");
+var skillSetEntrySchema = z24.object({
+  skillId: z24.string().min(1),
   name: skillHandleSchema,
-  label: z25.string().min(1),
+  label: z24.string().min(1),
   contentDigest: sha256Hex,
   blobDigest: sha256Hex,
   /** `cas/v2/<scope>/skills/sha256/<ab>/<blobDigest>.tar.zst`. */
-  blobKey: z25.string().min(1),
+  blobKey: z24.string().min(1),
   /** Raw canonical-tar size. Bounds the decompression allocation when present. */
-  rawBytes: z25.number().int().positive().optional(),
+  rawBytes: z24.number().int().positive().optional(),
   /** Stored compressed size, verified against the object when present. */
-  storedBytes: z25.number().int().positive().optional(),
+  storedBytes: z24.number().int().positive().optional(),
   /**
    * What the MODEL sees, parsed from the frontmatter at push time
    * (`{ name, description, descriptionChars, bodyBytes }`). Carried through to
    * the trace for the record; the staging path never branches on it.
    */
-  exposure: z25.record(z25.string(), z25.unknown()).optional()
+  exposure: z24.record(z24.string(), z24.unknown()).optional()
 });
 var MAX_SKILL_SET_ENTRIES = 32;
-var skillSetSchema = z25.array(skillSetEntrySchema).max(
+var skillSetSchema = z24.array(skillSetEntrySchema).max(
   MAX_SKILL_SET_ENTRIES,
   `a run may stage at most ${MAX_SKILL_SET_ENTRIES} skills`
 );
-var skillSourceWireSchema = z25.object({
-  repoFullName: z25.string(),
-  ref: z25.string(),
-  subpath: z25.string(),
-  autoIngest: z25.boolean(),
-  lastSeenCommit: z25.string().nullable(),
-  lastCheckedAt: z25.string().nullable(),
-  lastError: z25.string().nullable()
-});
-var skillVersionWireSchema = z25.object({
-  id: z25.string(),
-  label: z25.string(),
-  contentDigest: z25.string(),
-  ingestTrigger: z25.string().nullable(),
-  createdAt: z25.string()
-});
-var skillListItemSchema = z25.object({
-  id: z25.string(),
+var skillSourceWireSchema = z24.object({
+  repoFullName: z24.string(),
+  ref: z24.string(),
+  subpath: z24.string(),
+  autoIngest: z24.boolean(),
+  lastSeenCommit: z24.string().nullable(),
+  lastCheckedAt: z24.string().nullable(),
+  lastError: z24.string().nullable()
+});
+var skillVersionWireSchema = z24.object({
+  id: z24.string(),
+  label: z24.string(),
+  contentDigest: z24.string(),
+  ingestTrigger: z24.string().nullable(),
+  createdAt: z24.string()
+});
+var skillListItemSchema = z24.object({
+  id: z24.string(),
   /** OUR storage handle — the {ref} segment. */
   name: skillHandleSchema,
-  note: z25.string().nullable(),
+  note: z24.string().nullable(),
   source: skillSourceWireSchema.nullable(),
   latestVersion: skillVersionWireSchema.nullable(),
-  versionCount: z25.number().int(),
-  createdAt: z25.string(),
-  updatedAt: z25.string()
+  versionCount: z24.number().int(),
+  createdAt: z24.string(),
+  updatedAt: z24.string()
 });
-var listSkillsResponseSchema = z25.object({
-  items: z25.array(skillListItemSchema)
+var listSkillsResponseSchema = z24.object({
+  items: z24.array(skillListItemSchema)
 });
-var skillDetailSchema = skillListItemSchema.omit({ latestVersion: true }).extend({ versions: z25.array(skillVersionWireSchema) });
-var addSkillBodySchema = z25.object({
-  reference: z25.string().min(1),
+var skillDetailSchema = skillListItemSchema.omit({ latestVersion: true }).extend({ versions: z24.array(skillVersionWireSchema) });
+var addSkillBodySchema = z24.object({
+  reference: z24.string().min(1),
   /** OUR handle; defaults to the resolved directory basename. */
   handle: skillHandleSchema.optional(),
   /** Explicit version label — a typed label is intent and always mints;
    *  omitted derives from the resolved anchor and dedups by digest. */
-  label: z25.string().min(1).max(120).optional(),
+  label: z24.string().min(1).max(120).optional(),
   /** Select one skill from a source holding several. */
-  skill: z25.string().min(1).optional(),
-  note: z25.string().max(2e3).optional(),
+  skill: z24.string().min(1).optional(),
+  note: z24.string().max(2e3).optional(),
   /** Track the source branch for auto re-ingest (needs an explicit branch). */
-  trackSource: z25.boolean().optional()
+  trackSource: z24.boolean().optional()
 });
-var addSkillResponseSchema = z25.object({
-  skillId: z25.string().nullable(),
-  handle: z25.string(),
-  label: z25.string(),
+var addSkillResponseSchema = z24.object({
+  skillId: z24.string().nullable(),
+  handle: z24.string(),
+  label: z24.string(),
   /** True = the newest version already carried this content; nothing minted. */
-  unchanged: z25.boolean()
+  unchanged: z24.boolean()
 });
-var updateSkillBodySchema = z25.object({
+var updateSkillBodySchema = z24.object({
   name: skillHandleSchema.optional(),
-  note: z25.string().max(2e3).nullish(),
-  source: z25.object({
-    repoFullName: z25.string().min(1),
+  note: z24.string().max(2e3).nullish(),
+  source: z24.object({
+    repoFullName: z24.string().min(1),
     /** A branch name — never HEAD, never a SHA. */
-    ref: z25.string().min(1),
-    subpath: z25.string().optional(),
-    autoIngest: z25.boolean().optional()
+    ref: z24.string().min(1),
+    subpath: z24.string().optional(),
+    autoIngest: z24.boolean().optional()
   }).nullish()
 });
-var reingestSkillResponseSchema = z25.object({
-  label: z25.string().nullable(),
+var reingestSkillResponseSchema = z24.object({
+  label: z24.string().nullable(),
   /** True = "already current": the source content matches the newest version. */
-  unchanged: z25.boolean()
+  unchanged: z24.boolean()
 });
-var addSkillVersionBodySchema = z25.object({
-  reference: z25.string().min(1),
+var addSkillVersionBodySchema = z24.object({
+  reference: z24.string().min(1),
   /** Omitted defaults to the ref name (branch/tag), else the anchor. */
-  label: z25.string().min(1).max(120).optional()
-});
-var addSkillVersionResponseSchema = z25.object({
-  label: z25.string(),
-  unchanged: z25.boolean()
-});
-var skillRunWireSchema = z25.object({
-  runId: z25.string(),
-  agent: z25.string(),
-  turns: z25.number().int().nullable(),
-  durationMs: z25.number().int().nullable(),
-  costUsd: z25.number().nullable(),
-  finishedAt: z25.string().nullable(),
+  label: z24.string().min(1).max(120).optional()
+});
+var addSkillVersionResponseSchema = z24.object({
+  label: z24.string(),
+  unchanged: z24.boolean()
+});
+var skillRunWireSchema = z24.object({
+  runId: z24.string(),
+  agent: z24.string(),
+  turns: z24.number().int().nullable(),
+  durationMs: z24.number().int().nullable(),
+  costUsd: z24.number().nullable(),
+  finishedAt: z24.string().nullable(),
   /** WHICH version of the skill the session staged. */
-  versionLabel: z25.string().nullable()
+  versionLabel: z24.string().nullable()
 });
-var listSkillRunsResponseSchema = z25.object({
-  items: z25.array(skillRunWireSchema)
+var listSkillRunsResponseSchema = z24.object({
+  items: z24.array(skillRunWireSchema)
 });
 
 // ../packages/api-schemas/src/mcp.ts
 var mcpServerHandleSchema = skillHandleSchema;
 var MCP_SPEC_VERSION = 1;
-var envVarNameSchema = z26.string().min(1).max(128).regex(
+var envVarNameSchema = z25.string().min(1).max(128).regex(
   /^[A-Za-z_][A-Za-z0-9_]*$/,
   "an environment variable name (letters, digits, underscore; not starting with a digit)"
 );
-var headerNameSchema2 = z26.string().min(1).max(128).regex(
+var headerNameSchema2 = z25.string().min(1).max(128).regex(
   /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/,
   "an HTTP header name (a token \u2014 no colon, no spaces)"
 );
-var mcpToolSchema = z26.object({
-  name: z26.string().min(1).max(128),
-  description: z26.string().max(4096).optional()
+var mcpToolSchema = z25.object({
+  name: z25.string().min(1).max(128),
+  description: z25.string().max(4096).optional()
 });
-var mcpSpecSchema = z26.object({
-  specVersion: z26.literal(MCP_SPEC_VERSION),
-  transport: z26.enum(["stdio", "http"]),
+var mcpSpecSchema = z25.object({
+  specVersion: z25.literal(MCP_SPEC_VERSION),
+  transport: z25.enum(["stdio", "http"]),
   // stdio
-  command: z26.string().min(1).max(512).optional(),
-  args: z26.array(z26.string().max(4096)).max(64).optional(),
-  envNames: z26.array(envVarNameSchema).max(32).optional(),
+  command: z25.string().min(1).max(512).optional(),
+  args: z25.array(z25.string().max(4096)).max(64).optional(),
+  envNames: z25.array(envVarNameSchema).max(32).optional(),
   // http
-  url: z26.string().url().max(2048).optional(),
-  headerNames: z26.array(headerNameSchema2).max(32).optional(),
+  url: z25.string().url().max(2048).optional(),
+  headerNames: z25.array(headerNameSchema2).max(32).optional(),
   // display only — outside the digest (D13)
   serverName: mcpServerHandleSchema,
-  description: z26.string().max(4096).optional(),
-  tools: z26.array(mcpToolSchema).max(256).optional()
+  description: z25.string().max(4096).optional(),
+  tools: z25.array(mcpToolSchema).max(256).optional()
 }).strict().superRefine((spec, ctx) => {
   if (spec.transport === "stdio") {
     if (!spec.command) {
@@ -2449,17 +2174,17 @@ var mcpSpecSchema = z26.object({
     }
   }
 });
-var mcpExposureSchema = z26.object({
-  serverName: z26.string().min(1),
-  description: z26.string().optional(),
-  tools: z26.array(mcpToolSchema).default([]),
+var mcpExposureSchema = z25.object({
+  serverName: z25.string().min(1),
+  description: z25.string().optional(),
+  tools: z25.array(mcpToolSchema).default([]),
   /** Declared credential NAMES, mirrored here so the picker and the index row can
    *  render the contract without parsing `spec`. Never values. */
-  envNames: z26.array(z26.string()).default([]),
-  headerNames: z26.array(z26.string()).default([])
+  envNames: z25.array(z25.string()).default([]),
+  headerNames: z25.array(z25.string()).default([])
 });
-var mcpWarningSchema = z26.object({
-  code: z26.enum([
+var mcpWarningSchema = z25.object({
+  code: z25.enum([
     "unpinned_package",
     "credential_required",
     "value_discarded",
@@ -2469,122 +2194,122 @@ var mcpWarningSchema = z26.object({
     // contract was recorded when none was (Bugbot, medium).
     "flag_ignored"
   ]),
-  message: z26.string()
+  message: z25.string()
 });
-var mcpSetEntrySchema = z26.object({
+var mcpSetEntrySchema = z25.object({
   /** `McpServer.id` — the stable handle a UI chip links back to; `label` already
    *  names the version, so this is deliberately not `McpServerVersion.id`. */
-  serverId: z26.string().min(1),
+  serverId: z25.string().min(1),
   /** `McpServer.name` — OUR handle, and the CONFIG KEY the serializer writes. NOT
    *  the agent-visible `spec.serverName`. */
   name: mcpServerHandleSchema,
-  label: z26.string().min(1),
-  specDigest: z26.string().min(1),
+  label: z25.string().min(1),
+  specDigest: z25.string().min(1),
   spec: mcpSpecSchema,
   /** Declared tools/description as at authoring time. The preparation path never
    *  branches on it; it rides along for the trace and the UI. */
-  exposure: z26.record(z26.string(), z26.unknown()).optional(),
+  exposure: z25.record(z25.string(), z25.unknown()).optional(),
   /** Connection selected by this immutable MCP version. The matching non-secret
    * provider metadata lives in Batch.connectionSet. */
-  connectionId: z26.string().min(1).optional()
+  connectionId: z25.string().min(1).optional()
 });
 var MAX_MCP_SET_ENTRIES = 8;
-var mcpSetSchema = z26.array(mcpSetEntrySchema).max(
+var mcpSetSchema = z25.array(mcpSetEntrySchema).max(
   MAX_MCP_SET_ENTRIES,
   `a run may prepare at most ${MAX_MCP_SET_ENTRIES} MCP servers`
 );
-var mcpRefSchema = z26.string().min(3).max(320).regex(
+var mcpRefSchema = z25.string().min(3).max(320).regex(
   /^[A-Za-z0-9][A-Za-z0-9._-]*@[^,]+$/,
   'an MCP server reference must be "name@label" (a bare name is not a reference)'
 );
-var mcpRefsSchema = z26.array(mcpRefSchema).max(MAX_MCP_SET_ENTRIES);
-var mcpVersionWireSchema = z26.object({
-  id: z26.string(),
-  label: z26.string(),
-  specDigest: z26.string(),
+var mcpRefsSchema = z25.array(mcpRefSchema).max(MAX_MCP_SET_ENTRIES);
+var mcpVersionWireSchema = z25.object({
+  id: z25.string(),
+  label: z25.string(),
+  specDigest: z25.string(),
   spec: mcpSpecSchema,
   exposure: mcpExposureSchema,
-  warnings: z26.array(mcpWarningSchema),
-  createdAt: z26.string()
+  warnings: z25.array(mcpWarningSchema),
+  createdAt: z25.string()
 });
-var mcpServerListItemSchema = z26.object({
-  id: z26.string(),
+var mcpServerListItemSchema = z25.object({
+  id: z25.string(),
   /** OUR handle — the {ref} segment and the config key the serializer writes. */
   name: mcpServerHandleSchema,
-  note: z26.string().nullable(),
+  note: z25.string().nullable(),
   latestVersion: mcpVersionWireSchema.nullable(),
-  versionCount: z26.number().int(),
-  createdAt: z26.string(),
-  updatedAt: z26.string()
+  versionCount: z25.number().int(),
+  createdAt: z25.string(),
+  updatedAt: z25.string()
 });
-var listMcpServersResponseSchema = z26.object({
-  items: z26.array(mcpServerListItemSchema)
+var listMcpServersResponseSchema = z25.object({
+  items: z25.array(mcpServerListItemSchema)
 });
-var mcpServerDetailSchema = mcpServerListItemSchema.omit({ latestVersion: true }).extend({ versions: z26.array(mcpVersionWireSchema) });
-var saveMcpServerBodySchema = z26.object({
+var mcpServerDetailSchema = mcpServerListItemSchema.omit({ latestVersion: true }).extend({ versions: z25.array(mcpVersionWireSchema) });
+var saveMcpServerBodySchema = z25.object({
   name: mcpServerHandleSchema,
-  spec: z26.unknown(),
+  spec: z25.unknown(),
   /** A typed label is intent and always mints; omitted defaults to a UTC
    *  timestamp label and dedups by spec digest. */
-  label: z26.string().min(1).max(120).optional(),
-  note: z26.string().max(2e3).optional()
-});
-var saveMcpServerResponseSchema = z26.object({
-  serverId: z26.string().nullable(),
-  handle: z26.string(),
-  label: z26.string(),
-  specDigest: z26.string(),
-  warnings: z26.array(mcpWarningSchema),
+  label: z25.string().min(1).max(120).optional(),
+  note: z25.string().max(2e3).optional()
+});
+var saveMcpServerResponseSchema = z25.object({
+  serverId: z25.string().nullable(),
+  handle: z25.string(),
+  label: z25.string(),
+  specDigest: z25.string(),
+  warnings: z25.array(mcpWarningSchema),
   /** True = the newest version already carries this exact spec. */
-  unchanged: z26.boolean(),
+  unchanged: z25.boolean(),
   /** Display-only rendered invocation or URL. */
-  invocation: z26.string()
+  invocation: z25.string()
 });
-var updateMcpServerBodySchema = z26.object({
+var updateMcpServerBodySchema = z25.object({
   name: mcpServerHandleSchema.optional(),
-  note: z26.string().max(2e3).nullish()
+  note: z25.string().max(2e3).nullish()
 });
 
 // ../packages/api-schemas/src/me.ts
-import { z as z27 } from "zod";
-var meUserSchema = z27.object({
-  id: z27.string(),
-  email: z27.string().nullable(),
-  isSuperuser: z27.boolean()
+import { z as z26 } from "zod";
+var meUserSchema = z26.object({
+  id: z26.string(),
+  email: z26.string().nullable(),
+  isSuperuser: z26.boolean()
 });
-var meOrgSchema = z27.object({
-  slug: z27.string(),
+var meOrgSchema = z26.object({
+  slug: z26.string(),
   // Gauge's immutable Organization.public_id; null for LOCAL orgs.
-  publicId: z27.string().nullable(),
-  name: z27.string()
+  publicId: z26.string().nullable(),
+  name: z26.string()
 });
-var meResponseSchema = z27.object({
+var meResponseSchema = z26.object({
   user: meUserSchema,
   // Membership-scoped for normal users; superusers see every org (mirrors the
   // web tier's userOrgs).
-  orgs: z27.array(meOrgSchema)
+  orgs: z26.array(meOrgSchema)
 });
 
 // ../packages/api-schemas/src/optimizations.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 
 // ../packages/api-schemas/src/cli-interventions.ts
-import { z as z28 } from "zod";
-var digest = z28.string().regex(/^[a-f0-9]{64}$/);
-var token = z28.string().min(1).max(4096);
-var optionFlag = z28.string().regex(/^--?[A-Za-z0-9][A-Za-z0-9-]*$/);
-var envKey = z28.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
-var relativePath = z28.string().min(1).max(1024).refine(
+import { z as z27 } from "zod";
+var digest = z27.string().regex(/^[a-f0-9]{64}$/);
+var token = z27.string().min(1).max(4096);
+var optionFlag = z27.string().regex(/^--?[A-Za-z0-9][A-Za-z0-9-]*$/);
+var envKey = z27.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var relativePath = z27.string().min(1).max(1024).refine(
   (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.includes("\0") && path2.split("/").every(
     (part) => part && part !== "." && part !== ".." && ![".git", "node_modules", ".pnpm", ".yarn", ".venv"].includes(part)
   ),
   "Use a workspace-relative path without traversal"
 );
-var sourcedValue = z28.discriminatedUnion("source", [
-  z28.object({ source: z28.literal("literal"), value: z28.string().max(8192) }).strict(),
-  z28.object({ source: z28.literal("localFact"), key: envKey }).strict()
+var sourcedValue = z27.discriminatedUnion("source", [
+  z27.object({ source: z27.literal("literal"), value: z27.string().max(8192) }).strict(),
+  z27.object({ source: z27.literal("localFact"), key: envKey }).strict()
 ]);
-var cliLaunchFormSchema = z28.enum([
+var cliLaunchFormSchema = z27.enum([
   "native",
   "path",
   "symlink",
@@ -2595,7 +2320,7 @@ var cliLaunchFormSchema = z28.enum([
   "execveat-path",
   "execveat-fd"
 ]);
-var cliObservationReasonSchema = z28.enum([
+var cliObservationReasonSchema = z27.enum([
   "eligible",
   "other-target",
   "other-command",
@@ -2609,14 +2334,14 @@ var cliObservationReasonSchema = z28.enum([
   "operation-profile",
   "descriptor-lifetime"
 ]);
-var cliIoProfileSchema = z28.enum([
+var cliIoProfileSchema = z27.enum([
   "pipes",
   "redirected",
   "shared-descriptor",
   "pty"
 ]);
-var cliObservationSchema = z28.object({
-  invocationId: z28.string().regex(/^[a-f0-9]{32}$/),
+var cliObservationSchema = z27.object({
+  invocationId: z27.string().regex(/^[a-f0-9]{32}$/),
   targetId: token,
   commandId: token.nullable(),
   entrypointSha256: digest,
@@ -2625,18 +2350,18 @@ var cliObservationSchema = z28.object({
   ioProfile: cliIoProfileSchema.nullable(),
   reason: cliObservationReasonSchema
 });
-var cliCoverageSchema = z28.object({
-  attempt: z28.number().int().nonnegative(),
-  observedInvocationCount: z28.number().int().nonnegative().nullable(),
-  invocationCount: z28.number().int().nonnegative(),
-  appliedInvocationCount: z28.number().int().nonnegative(),
-  incompleteCount: z28.number().int().nonnegative(),
-  unsupportedCount: z28.number().int().nonnegative(),
-  instrumentationFailed: z28.boolean(),
-  observations: z28.array(cliObservationSchema),
-  unsupportedDiagnostics: z28.array(z28.string())
-});
-var cliOperationKindSchema = z28.enum([
+var cliCoverageSchema = z27.object({
+  attempt: z27.number().int().nonnegative(),
+  observedInvocationCount: z27.number().int().nonnegative().nullable(),
+  invocationCount: z27.number().int().nonnegative(),
+  appliedInvocationCount: z27.number().int().nonnegative(),
+  incompleteCount: z27.number().int().nonnegative(),
+  unsupportedCount: z27.number().int().nonnegative(),
+  instrumentationFailed: z27.boolean(),
+  observations: z27.array(cliObservationSchema),
+  unsupportedDiagnostics: z27.array(z27.string())
+});
+var cliOperationKindSchema = z27.enum([
   "ensureOption",
   "replaceOption",
   "setEnv",
@@ -2646,17 +2371,17 @@ var cliOperationKindSchema = z28.enum([
   "promptRecipe",
   "generatedFile"
 ]);
-var commandCapabilitiesSchema = z28.object({
-  operations: z28.array(cliOperationKindSchema).max(8),
-  options: z28.array(z28.object({ flag: optionFlag, takesValue: z28.boolean() }).strict()).max(100).default([]),
-  settings: z28.array(envKey).max(100).default([]),
-  localFacts: z28.array(envKey).max(30).default([]),
-  generatedPaths: z28.array(relativePath).max(50).default([]),
-  outputModes: z28.array(z28.enum(["streaming", "completed"])).max(2).default([]),
-  stdinFormats: z28.array(z28.enum(["text", "json", "jsonl"])).max(3).default([]),
-  recipeIds: z28.array(token).max(50).default([])
+var commandCapabilitiesSchema = z27.object({
+  operations: z27.array(cliOperationKindSchema).max(8),
+  options: z27.array(z27.object({ flag: optionFlag, takesValue: z27.boolean() }).strict()).max(100).default([]),
+  settings: z27.array(envKey).max(100).default([]),
+  localFacts: z27.array(envKey).max(30).default([]),
+  generatedPaths: z27.array(relativePath).max(50).default([]),
+  outputModes: z27.array(z27.enum(["streaming", "completed"])).max(2).default([]),
+  stdinFormats: z27.array(z27.enum(["text", "json", "jsonl"])).max(3).default([]),
+  recipeIds: z27.array(token).max(50).default([])
 }).strict();
-var cliTargetSchema = z28.object({
+var cliTargetSchema = z27.object({
   id: token,
   vendor: token,
   package: token,
@@ -2665,22 +2390,22 @@ var cliTargetSchema = z28.object({
   artifactSha256: digest.nullable(),
   entrypointSha256: digest.nullable(),
   /** Trace-derived recognition hints. Actual bytes are captured by record mode. */
-  discovery: z28.object({
+  discovery: z27.object({
     ecosystem: token.nullable(),
     program: token,
-    executables: z28.array(token).max(20)
+    executables: z27.array(token).max(20)
   }).strict().optional(),
-  ownershipEvidence: z28.string().min(1).max(2048),
-  entrypoints: z28.array(z28.string().min(1).max(1024)).max(20),
+  ownershipEvidence: z27.string().min(1).max(2048),
+  entrypoints: z27.array(z27.string().min(1).max(1024)).max(20),
   /** Flags accepted before the subcommand, with explicit value arity. */
-  globalOptions: z28.array(z28.object({ flag: optionFlag, takesValue: z28.boolean() }).strict()).max(100),
-  launchForms: z28.array(cliLaunchFormSchema).min(1),
-  ioProfiles: z28.array(cliIoProfileSchema).min(1),
-  commands: z28.array(
-    z28.object({
+  globalOptions: z27.array(z27.object({ flag: optionFlag, takesValue: z27.boolean() }).strict()).max(100),
+  launchForms: z27.array(cliLaunchFormSchema).min(1),
+  ioProfiles: z27.array(cliIoProfileSchema).min(1),
+  commands: z27.array(
+    z27.object({
       id: token,
       /** Tokens following global options, before a literal `--`. */
-      subcommand: z28.array(token).max(8),
+      subcommand: z27.array(token).max(8),
       capabilities: commandCapabilitiesSchema
     }).strict()
   ).min(1)
@@ -2760,11 +2485,11 @@ var cliTargetSchema = z28.object({
   }
 });
 var CLI_CATALOG_MAX_TARGETS = 100;
-var cliCatalogSchema = z28.object({
-  version: z28.union([z28.literal(1), z28.literal(2)]),
+var cliCatalogSchema = z27.object({
+  version: z27.union([z27.literal(1), z27.literal(2)]),
   engineVersion: token,
   digest,
-  targets: z28.array(cliTargetSchema).max(CLI_CATALOG_MAX_TARGETS)
+  targets: z27.array(cliTargetSchema).max(CLI_CATALOG_MAX_TARGETS)
 }).strict().superRefine((catalog, ctx) => {
   if (catalog.version === 1 && (!catalog.targets.length || catalog.targets.some((target) => target.discovery)))
     ctx.addIssue({
@@ -2780,15 +2505,15 @@ var cliCatalogSchema = z28.object({
       });
   });
 });
-var exitPredicate = z28.discriminatedUnion("kind", [
-  z28.object({ kind: z28.literal("any") }).strict(),
-  z28.object({
-    kind: z28.literal("code"),
-    value: z28.number().int().min(0).max(255)
+var exitPredicate = z27.discriminatedUnion("kind", [
+  z27.object({ kind: z27.literal("any") }).strict(),
+  z27.object({
+    kind: z27.literal("code"),
+    value: z27.number().int().min(0).max(255)
   }).strict()
 ]);
-var outputStream = z28.enum(["stdout", "stderr", "combined"]);
-var literalEdit = z28.object({ find: z28.string().min(1).max(8192), replace: z28.string().max(8192) }).strict();
+var outputStream = z27.enum(["stdout", "stderr", "combined"]);
+var literalEdit = z27.object({ find: z27.string().min(1).max(8192), replace: z27.string().max(8192) }).strict();
 function boundedOutputPattern(pattern) {
   let at = pattern.startsWith("^") ? 1 : 0;
   const end = pattern.endsWith("$") && pattern.length > at ? pattern.length - 1 : pattern.length;
@@ -2811,86 +2536,86 @@ function boundedOutputPattern(pattern) {
   }
   return literalBytes > 0;
 }
-var operationSchema = z28.discriminatedUnion("kind", [
-  z28.object({
-    kind: z28.literal("ensureOption"),
+var operationSchema = z27.discriminatedUnion("kind", [
+  z27.object({
+    kind: z27.literal("ensureOption"),
     option: optionFlag,
     value: sourcedValue.optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("replaceOption"),
+  z27.object({
+    kind: z27.literal("replaceOption"),
     option: optionFlag,
     value: sourcedValue
   }).strict(),
-  z28.object({
-    kind: z28.literal("setEnv"),
+  z27.object({
+    kind: z27.literal("setEnv"),
     key: envKey,
     value: sourcedValue,
-    whenAbsent: z28.boolean()
+    whenAbsent: z27.boolean()
   }).strict(),
-  z28.object({
-    kind: z28.literal("streamOutput"),
+  z27.object({
+    kind: z27.literal("streamOutput"),
     stream: outputStream,
     edit: literalEdit
   }).strict(),
-  z28.object({
-    kind: z28.literal("completeOutput"),
+  z27.object({
+    kind: z27.literal("completeOutput"),
     stream: outputStream,
-    matcher: z28.discriminatedUnion("kind", [
-      z28.object({
-        kind: z28.literal("literal"),
-        text: z28.string().min(1).max(8192)
+    matcher: z27.discriminatedUnion("kind", [
+      z27.object({
+        kind: z27.literal("literal"),
+        text: z27.string().min(1).max(8192)
       }).strict(),
-      z28.object({
-        kind: z28.literal("re2"),
-        pattern: z28.string().min(1).max(2048).refine(
+      z27.object({
+        kind: z27.literal("re2"),
+        pattern: z27.string().min(1).max(2048).refine(
           boundedOutputPattern,
           "Use literals, anchors, and at most one greedy .*; escape literal regex punctuation"
         )
       }).strict()
     ]),
-    replace: z28.string().max(8192),
+    replace: z27.string().max(8192),
     exit: exitPredicate
   }).strict(),
-  z28.object({
-    kind: z28.literal("structuredStdin"),
-    format: z28.enum(["text", "json", "jsonl"]),
+  z27.object({
+    kind: z27.literal("structuredStdin"),
+    format: z27.enum(["text", "json", "jsonl"]),
     payload: sourcedValue,
-    timing: z28.literal("onLaunch"),
-    callerInput: z28.literal("replace"),
-    eof: z28.literal("close")
+    timing: z27.literal("onLaunch"),
+    callerInput: z27.literal("replace"),
+    eof: z27.literal("close")
   }).strict(),
-  z28.object({
-    kind: z28.literal("promptRecipe"),
+  z27.object({
+    kind: z27.literal("promptRecipe"),
     recipeId: token,
-    steps: z28.array(
-      z28.object({
-        prompt: z28.string().min(1).max(4096),
+    steps: z27.array(
+      z27.object({
+        prompt: z27.string().min(1).max(4096),
         response: sourcedValue,
-        timeoutMs: z28.number().int().min(1).max(12e4)
+        timeoutMs: z27.number().int().min(1).max(12e4)
       }).strict()
     ).min(1).max(20),
-    overallTimeoutMs: z28.number().int().min(1).max(6e5),
-    completion: z28.string().min(1).max(4096)
+    overallTimeoutMs: z27.number().int().min(1).max(6e5),
+    completion: z27.string().min(1).max(4096)
   }).strict(),
-  z28.object({
-    kind: z28.literal("generatedFile"),
+  z27.object({
+    kind: z27.literal("generatedFile"),
     path: relativePath,
     beforeSha256: digest.nullable(),
     generatedSha256: digest,
     outcome: exitPredicate,
     edit: literalEdit,
-    required: z28.boolean()
+    required: z27.boolean()
   }).strict()
 ]);
-var cliBaselineRecordFileSchema = z28.object({
-  pathIndex: z28.number().int().nonnegative().max(49),
+var cliBaselineRecordFileSchema = z27.object({
+  pathIndex: z27.number().int().nonnegative().max(49),
   path: relativePath,
-  status: z28.enum(["generated", "not-exercised"]),
+  status: z27.enum(["generated", "not-exercised"]),
   beforeSha256: digest.nullable(),
   generatedSha256: digest.nullable()
 }).strict();
-var baselineInvocationSchema = z28.object({
+var baselineInvocationSchema = z27.object({
   runId: token,
   invocationId: token,
   targetId: token,
@@ -2901,33 +2626,33 @@ var baselineInvocationSchema = z28.object({
   runtimeSha256: digest.optional(),
   launchForm: cliLaunchFormSchema,
   ioProfile: cliIoProfileSchema,
-  recordFiles: z28.array(cliBaselineRecordFileSchema).max(50).default([])
+  recordFiles: z27.array(cliBaselineRecordFileSchema).max(50).default([])
 }).strict();
-var cliInterventionSchema = z28.object({
-  schemaVersion: z28.union([z28.literal(1), z28.literal(2)]),
-  identityPolicy: z28.literal("artifact").optional(),
+var cliInterventionSchema = z27.object({
+  schemaVersion: z27.union([z27.literal(1), z27.literal(2)]),
+  identityPolicy: z27.literal("artifact").optional(),
   engineVersion: token,
   engineSha256: digest.nullable(),
   bundleSha256: digest,
   catalog: cliCatalogSchema,
-  mode: z28.enum(["record", "trial"]),
-  captureProfiles: z28.array(cliIoProfileSchema).min(1),
+  mode: z27.enum(["record", "trial"]),
+  captureProfiles: z27.array(cliIoProfileSchema).min(1),
   activeTargetId: token.nullable(),
   activeCommandId: token.nullable(),
-  selector: z28.object({
-    optionPresent: z28.array(optionFlag).max(20),
-    optionAbsent: z28.array(optionFlag).max(20)
+  selector: z27.object({
+    optionPresent: z27.array(optionFlag).max(20),
+    optionAbsent: z27.array(optionFlag).max(20)
   }).strict().nullable(),
-  baselineInvocations: z28.array(baselineInvocationSchema).max(500),
-  operations: z28.array(operationSchema).max(50),
-  limits: z28.object({
-    completedStreamBytes: z28.number().int().min(1).max(2 * 1024 * 1024),
-    replacementBytes: z28.number().int().min(1).max(8192),
-    generatedFileBytes: z28.number().int().min(1).max(2 * 1024 * 1024),
-    generatedAggregateBytes: z28.number().int().min(1).max(8 * 1024 * 1024),
-    generatedFileCount: z28.number().int().min(1).max(50)
+  baselineInvocations: z27.array(baselineInvocationSchema).max(500),
+  operations: z27.array(operationSchema).max(50),
+  limits: z27.object({
+    completedStreamBytes: z27.number().int().min(1).max(2 * 1024 * 1024),
+    replacementBytes: z27.number().int().min(1).max(8192),
+    generatedFileBytes: z27.number().int().min(1).max(2 * 1024 * 1024),
+    generatedAggregateBytes: z27.number().int().min(1).max(8 * 1024 * 1024),
+    generatedFileCount: z27.number().int().min(1).max(50)
   }).strict(),
-  shippingIntent: z28.enum([
+  shippingIntent: z27.enum([
     "default",
     "message",
     "interaction",
@@ -3128,7 +2853,7 @@ var cliInterventionSchema = z28.object({
       "Generated file count exceeds limit"
     );
 });
-var cliTrialChangeSchema = z28.object({
+var cliTrialChangeSchema = z27.object({
   targetId: token,
   commandId: token,
   selector: cliInterventionSchema.shape.selector.unwrap(),
@@ -3137,7 +2862,7 @@ var cliTrialChangeSchema = z28.object({
 }).strict();
 
 // ../packages/api-schemas/src/climb.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 
 // ../packages/api-schemas/src/climb-kinds.ts
 var LEVER_KINDS = [
@@ -3167,35 +2892,35 @@ var LEVER_INTERVENTIONS = {
 };
 
 // ../packages/api-schemas/src/sandbox-overrides.ts
-import { z as z29 } from "zod";
+import { z as z28 } from "zod";
 var SANDBOX_OVERRIDE_KINDS = ["packages", "clis"];
-var ecosystemSchema = z29.enum(["npm", "pypi", "cargo", "go", "gem"]);
-var overrideFilesSchema = z29.array(
-  z29.object({
-    path: z29.string().min(1).refine(
+var ecosystemSchema = z28.enum(["npm", "pypi", "cargo", "go", "gem"]);
+var overrideFilesSchema = z28.array(
+  z28.object({
+    path: z28.string().min(1).refine(
       (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.split("/").includes(".."),
       "Use a relative path within the target"
     ),
-    body: z29.string()
+    body: z28.string()
   }).strict()
 ).min(1);
 var contentShape = {
-  version: z29.string().trim().min(1).optional(),
+  version: z28.string().trim().min(1).optional(),
   files: overrideFilesSchema.optional()
 };
 var hasContent = (value) => value.version !== void 0 || value.files !== void 0;
-var sandboxOverridesSchema = z29.object({
-  version: z29.literal(1),
-  packages: z29.array(
-    z29.object({
+var sandboxOverridesSchema = z28.object({
+  version: z28.literal(1),
+  packages: z28.array(
+    z28.object({
       ecosystem: ecosystemSchema,
-      name: z29.string().trim().min(1),
+      name: z28.string().trim().min(1),
       ...contentShape
     }).strict().refine(hasContent, "Specify a version or files")
   ).optional(),
-  clis: z29.array(
-    z29.object({
-      name: z29.string().trim().min(1),
+  clis: z28.array(
+    z28.object({
+      name: z28.string().trim().min(1),
       ...contentShape
     }).strict().refine(hasContent, "Specify a version or files")
   ).optional()
@@ -3222,11 +2947,11 @@ var sandboxOverridesSchema = z29.object({
 });
 
 // ../packages/api-schemas/src/climb.ts
-var climbSubjectKindSchema = z30.enum(["EVAL_SET", "VISIBILITY_PROMPT"]);
-var leverKindSchema = z30.enum(LEVER_KINDS);
-var interventionKindSchema = z30.enum(INTERVENTION_KINDS);
-var skill = z30.object({ skillVersionId: z30.string().min(1) }).strict();
-var empty = z30.object({}).strict();
+var climbSubjectKindSchema = z29.enum(["EVAL_SET", "VISIBILITY_PROMPT"]);
+var leverKindSchema = z29.enum(LEVER_KINDS);
+var interventionKindSchema = z29.enum(INTERVENTION_KINDS);
+var skill = z29.object({ skillVersionId: z29.string().min(1) }).strict();
+var empty = z29.object({}).strict();
 function validateFixtureIntervention(value, ctx) {
   const result = webFixtureSchema.safeParse({ version: 1, ...value });
   if (!result.success) {
@@ -3239,75 +2964,75 @@ function validateFixtureIntervention(value, ctx) {
     }
   }
 }
-var interventionSchema = z30.discriminatedUnion("kind", [
-  z30.object({ kind: z30.literal("BASELINE"), after: empty }),
-  z30.object({ kind: z30.literal("ADD_SKILL"), after: skill }),
-  z30.object({ kind: z30.literal("REMOVE_SKILL"), before: skill, after: empty }),
-  z30.object({ kind: z30.literal("EDIT_SKILL"), before: skill, after: skill }),
-  z30.object({
-    kind: z30.literal("REWRITE_DOCS"),
-    before: z30.json().optional(),
-    after: z30.object({ pages: webFixtureSchema.shape.pages.unwrap().min(1) }).strict().superRefine(validateFixtureIntervention)
+var interventionSchema = z29.discriminatedUnion("kind", [
+  z29.object({ kind: z29.literal("BASELINE"), after: empty }),
+  z29.object({ kind: z29.literal("ADD_SKILL"), after: skill }),
+  z29.object({ kind: z29.literal("REMOVE_SKILL"), before: skill, after: empty }),
+  z29.object({ kind: z29.literal("EDIT_SKILL"), before: skill, after: skill }),
+  z29.object({
+    kind: z29.literal("REWRITE_DOCS"),
+    before: z29.json().optional(),
+    after: z29.object({ pages: webFixtureSchema.shape.pages.unwrap().min(1) }).strict().superRefine(validateFixtureIntervention)
   }),
-  z30.object({
-    kind: z30.literal("PACKAGE_VERSION"),
-    after: z30.object({
+  z29.object({
+    kind: z29.literal("PACKAGE_VERSION"),
+    after: z29.object({
       ecosystem: ecosystemSchema,
-      name: z30.string().min(1),
-      version: z30.string().min(1)
+      name: z29.string().min(1),
+      version: z29.string().min(1)
     }).strict()
   }),
-  z30.object({
-    kind: z30.literal("PACKAGE_CONTENT"),
-    after: z30.object({
+  z29.object({
+    kind: z29.literal("PACKAGE_CONTENT"),
+    after: z29.object({
       ecosystem: ecosystemSchema,
-      name: z30.string().min(1),
+      name: z29.string().min(1),
       files: overrideFilesSchema
     }).strict()
   }),
-  z30.object({
-    kind: z30.literal("CLI_VERSION"),
-    after: z30.object({ name: z30.string().min(1), version: z30.string().min(1) }).strict()
+  z29.object({
+    kind: z29.literal("CLI_VERSION"),
+    after: z29.object({ name: z29.string().min(1), version: z29.string().min(1) }).strict()
   }),
-  z30.object({
-    kind: z30.literal("CLI_INTERVENTION"),
+  z29.object({
+    kind: z29.literal("CLI_INTERVENTION"),
     after: cliInterventionSchema.refine((bundle) => bundle.mode === "trial", {
       message: "A CLI trial requires a trial-mode bundle"
     })
   })
 ]);
-var climbSettingsSchema = z30.object({
-  maxRounds: z30.number().int().positive().default(5),
-  sampleCount: z30.number().int().positive().default(1),
-  creditCap: z30.number().int().nonnegative(),
-  targetScore: z30.number().min(0).max(1).default(1),
+var climbSettingsSchema = z29.object({
+  maxRounds: z29.number().int().positive().default(5),
+  sampleCount: z29.number().int().positive().default(1),
+  creditCap: z29.number().int().nonnegative(),
+  targetScore: z29.number().min(0).max(1).default(1),
   // Narrow the subject's whole roster to one slot, for the baseline and every
   // trial alike. A subject rostering ten models otherwise multiplies every
   // trial by ten, and a one-model trial measured against a ten-model baseline
   // is not a comparison. `pinnedModel` empty means the agent's default model.
   pinnedAgent: schedulableAgentSchema.optional(),
-  pinnedModel: z30.string().optional(),
-  maxTrialsPerRound: z30.number().int().min(1).max(10).default(3),
+  pinnedModel: z29.string().optional(),
+  maxTrialsPerRound: z29.number().int().min(1).max(10).default(3),
   // The round a continuation started at; the no-improvement counter
   // restarts here.
-  continuedAtRound: z30.number().int().nonnegative().optional()
+  continuedAtRound: z29.number().int().nonnegative().optional()
 }).strip().refine((value) => value.pinnedAgent !== void 0 || !value.pinnedModel, {
   path: ["pinnedAgent"],
   message: "Pin an agent with the model"
 });
-var climbDirectionSchema = z30.object({
-  focus: z30.string().trim().max(2e3).nullable().default(null),
-  preserve: z30.array(z30.string().trim().min(1).max(500)).max(20).default([]),
-  exclude: z30.array(z30.string().trim().min(1).max(500)).max(20).default([]),
-  notes: z30.string().trim().max(4e3).nullable().default(null)
-});
-var climbDirectionPatchSchema = z30.object({
-  focus: z30.string().trim().max(2e3).nullable().optional(),
-  preserve: z30.array(z30.string().trim().min(1).max(500)).max(20).optional(),
-  exclude: z30.array(z30.string().trim().min(1).max(500)).max(20).optional(),
-  notes: z30.string().trim().max(4e3).nullable().optional(),
+var climbDirectionSchema = z29.object({
+  focus: z29.string().trim().max(2e3).nullable().default(null),
+  preserve: z29.array(z29.string().trim().min(1).max(500)).max(20).default([]),
+  exclude: z29.array(z29.string().trim().min(1).max(500)).max(20).default([]),
+  notes: z29.string().trim().max(4e3).nullable().default(null)
+});
+var climbDirectionPatchSchema = z29.object({
+  focus: z29.string().trim().max(2e3).nullable().optional(),
+  preserve: z29.array(z29.string().trim().min(1).max(500)).max(20).optional(),
+  exclude: z29.array(z29.string().trim().min(1).max(500)).max(20).optional(),
+  notes: z29.string().trim().max(4e3).nullable().optional(),
   /** One line on why this was recorded; becomes the DIRECTION row summary. */
-  rationale: z30.string().trim().max(500).optional()
+  rationale: z29.string().trim().max(500).optional()
 }).strict();
 var CLIMB_ACTIVITY_KINDS = [
   "STARTED",
@@ -3326,74 +3051,74 @@ var CLIMB_ACTIVITY_KINDS = [
   "CONTINUED",
   "CANCELED"
 ];
-var climbActivityKindSchema = z30.enum(CLIMB_ACTIVITY_KINDS);
-var proposerTraceStepSchema = z30.object({
-  tool: z30.string(),
-  args: z30.string(),
-  result: z30.string().nullable(),
-  isError: z30.boolean().optional()
-});
-var proposerTraceSchema = z30.object({
-  steps: z30.array(proposerTraceStepSchema),
-  reasoning: z30.string(),
-  durationMs: z30.number().int().nonnegative(),
-  model: z30.string()
-});
-var climbActivitySchema = z30.object({
-  id: z30.string(),
-  climbId: z30.string(),
-  roundId: z30.string().nullable(),
-  trialId: z30.string().nullable(),
+var climbActivityKindSchema = z29.enum(CLIMB_ACTIVITY_KINDS);
+var proposerTraceStepSchema = z29.object({
+  tool: z29.string(),
+  args: z29.string(),
+  result: z29.string().nullable(),
+  isError: z29.boolean().optional()
+});
+var proposerTraceSchema = z29.object({
+  steps: z29.array(proposerTraceStepSchema),
+  reasoning: z29.string(),
+  durationMs: z29.number().int().nonnegative(),
+  model: z29.string()
+});
+var climbActivitySchema = z29.object({
+  id: z29.string(),
+  climbId: z29.string(),
+  roundId: z29.string().nullable(),
+  trialId: z29.string().nullable(),
   kind: climbActivityKindSchema,
-  actorUserId: z30.string().nullable(),
-  actorName: z30.string().nullable(),
-  summary: z30.string(),
-  detail: z30.unknown().nullable(),
-  createdAt: z30.string()
-});
-var activityQuerySchema = z30.object({
-  after: z30.string().datetime().optional(),
-  limit: z30.coerce.number().int().min(1).max(500).default(500)
-});
-var climbConfigSnapshotSchema = z30.object({
-  promptText: z30.string(),
-  scenario: z30.enum(["GREENFIELD", "MIGRATION"]),
-  repoUrl: z30.string().nullable(),
-  repoRef: z30.string().nullable(),
-  profileId: z30.string().nullable(),
-  profileName: z30.string().nullable(),
-  profileDescription: z30.string().nullable(),
-  profileModel: z30.string().nullable(),
-  limits: z30.json(),
-  agents: z30.array(agentConfigSchema).min(1),
-  skillRefs: z30.array(z30.string()),
-  mcpRefs: z30.array(z30.string()),
-  skillVersionIds: z30.array(z30.string()),
-  mcpServerVersionIds: z30.array(z30.string()),
-  skillSet: z30.json().nullable(),
-  mcpSet: z30.json().nullable(),
-  connectionIds: z30.array(z30.string()),
-  connectionSet: z30.json().nullable(),
-  agentContext: z30.json().nullable(),
-  agentContextDigest: z30.string().nullable(),
+  actorUserId: z29.string().nullable(),
+  actorName: z29.string().nullable(),
+  summary: z29.string(),
+  detail: z29.unknown().nullable(),
+  createdAt: z29.string()
+});
+var activityQuerySchema = z29.object({
+  after: z29.string().datetime().optional(),
+  limit: z29.coerce.number().int().min(1).max(500).default(500)
+});
+var climbConfigSnapshotSchema = z29.object({
+  promptText: z29.string(),
+  scenario: z29.enum(["GREENFIELD", "MIGRATION"]),
+  repoUrl: z29.string().nullable(),
+  repoRef: z29.string().nullable(),
+  profileId: z29.string().nullable(),
+  profileName: z29.string().nullable(),
+  profileDescription: z29.string().nullable(),
+  profileModel: z29.string().nullable(),
+  limits: z29.json(),
+  agents: z29.array(agentConfigSchema).min(1),
+  skillRefs: z29.array(z29.string()),
+  mcpRefs: z29.array(z29.string()),
+  skillVersionIds: z29.array(z29.string()),
+  mcpServerVersionIds: z29.array(z29.string()),
+  skillSet: z29.json().nullable(),
+  mcpSet: z29.json().nullable(),
+  connectionIds: z29.array(z29.string()),
+  connectionSet: z29.json().nullable(),
+  agentContext: z29.json().nullable(),
+  agentContextDigest: z29.string().nullable(),
   webFixture: webFixtureSchema.nullable(),
   cliIntervention: cliInterventionSchema.nullable().default(null),
   sandboxOverrides: sandboxOverridesSchema.nullable(),
-  visibilityScenarioId: z30.string().nullable()
+  visibilityScenarioId: z29.string().nullable()
 }).strict();
-var targetRefSchema = z30.object({
-  kind: z30.string().min(1),
-  id: z30.string().optional(),
-  url: z30.url().optional(),
-  package: z30.string().optional()
+var targetRefSchema = z29.object({
+  kind: z29.string().min(1),
+  id: z29.string().optional(),
+  url: z29.url().optional(),
+  package: z29.string().optional()
 }).strict();
-var trialInputSchema = z30.object({
-  title: z30.string().trim().min(1).max(200),
-  hypothesis: z30.string().max(4e3).optional(),
+var trialInputSchema = z29.object({
+  title: z29.string().trim().min(1).max(200),
+  hypothesis: z29.string().max(4e3).optional(),
   lever: leverKindSchema,
   targetRef: targetRefSchema.optional(),
   intervention: interventionSchema,
-  authorMode: z30.enum(["MANUAL", "DIRECT", "PROPOSE"]).default("MANUAL")
+  authorMode: z29.enum(["MANUAL", "DIRECT", "PROPOSE"]).default("MANUAL")
 }).strict().superRefine((value, ctx) => {
   const allowed = LEVER_INTERVENTIONS[value.lever];
   if (!allowed.includes(value.intervention.kind))
@@ -3412,7 +3137,7 @@ var OPTIMIZATION_STATUSES = [
   "DONE",
   "ARCHIVED"
 ];
-var optimizationStatusSchema = z31.enum(OPTIMIZATION_STATUSES);
+var optimizationStatusSchema = z30.enum(OPTIMIZATION_STATUSES);
 var ROUND_STATUSES = [
   "PROPOSING",
   "PROPOSED",
@@ -3441,61 +3166,61 @@ var OPTIMIZATION_EFFORTS = [
   { value: "HIGH", label: "Thorough", sampleCount: 2, maxRounds: 8 },
   { value: "XHIGH", label: "Exhaustive", sampleCount: 3, maxRounds: 12 }
 ];
-var optimizationEffortSchema = z31.enum(
+var optimizationEffortSchema = z30.enum(
   OPTIMIZATION_EFFORTS.map((preset) => preset.value)
 );
-var listOptimizationsQuerySchema = z31.object({
-  status: z31.string().optional().transform(
+var listOptimizationsQuerySchema = z30.object({
+  status: z30.string().optional().transform(
     (value) => value ? value.split(",").map((part) => part.trim().toUpperCase()).filter(Boolean) : void 0
-  ).pipe(z31.array(optimizationStatusSchema).optional()),
+  ).pipe(z30.array(optimizationStatusSchema).optional()),
   subjectKind: climbSubjectKindSchema.optional(),
-  subjectId: z31.string().min(1).optional(),
-  limit: z31.coerce.number().int().min(1).max(200).default(50),
+  subjectId: z30.string().min(1).optional(),
+  limit: z30.coerce.number().int().min(1).max(200).default(50),
   /** Drafts are workspaces, not runs; older clients never see them. */
-  includeDrafts: z31.union([z31.boolean(), z31.string()]).optional().transform((value) => value === true || value === "true" || value === "1")
+  includeDrafts: z30.union([z30.boolean(), z30.string()]).optional().transform((value) => value === true || value === "true" || value === "1")
 });
-var optimizationSummarySchema = z31.object({
-  id: z31.string(),
-  name: z31.string(),
+var optimizationSummarySchema = z30.object({
+  id: z30.string(),
+  name: z30.string(),
   status: optimizationStatusSchema,
-  mode: z31.enum(["MANUAL", "AUTO"]),
+  mode: z30.enum(["MANUAL", "AUTO"]),
   /** Autonomous launches every proposed round; interactive waits for one. */
-  autonomous: z31.boolean(),
-  stopReason: z31.string().nullable(),
+  autonomous: z30.boolean(),
+  stopReason: z30.string().nullable(),
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string(),
-  subjectName: z31.string(),
+  subjectId: z30.string(),
+  subjectName: z30.string(),
   lever: leverKindSchema.nullable(),
-  round: z31.number().int(),
-  maxRounds: z31.number().int(),
+  round: z30.number().int(),
+  maxRounds: z30.number().int(),
   /** Starting baseline score, 0..1. */
-  before: z31.number().nullable(),
+  before: z30.number().nullable(),
   /** Score of the marked winner, or best BETTER trial, 0..1. */
-  after: z31.number().nullable(),
+  after: z30.number().nullable(),
   /** Percentage-point change from the baseline to the winner or best BETTER trial. */
-  delta: z31.number().nullable(),
+  delta: z30.number().nullable(),
   /** Score after each round, baseline first. */
-  path: z31.array(z31.number()),
-  creditsSpent: z31.number().int(),
-  creditsReserved: z31.number().int(),
-  summary: z31.string().nullable(),
-  href: z31.string(),
-  createdAt: z31.string(),
-  updatedAt: z31.string()
-});
-var listOptimizationsResponseSchema = z31.object({
-  items: z31.array(optimizationSummarySchema)
-});
-var targetSchema = z31.object({
+  path: z30.array(z30.number()),
+  creditsSpent: z30.number().int(),
+  creditsReserved: z30.number().int(),
+  summary: z30.string().nullable(),
+  href: z30.string(),
+  createdAt: z30.string(),
+  updatedAt: z30.string()
+});
+var listOptimizationsResponseSchema = z30.object({
+  items: z30.array(optimizationSummarySchema)
+});
+var targetSchema = z30.object({
   agent: schedulableAgentSchema.optional(),
   /** Empty or omitted means the agent's default model. */
-  model: z31.string().optional()
+  model: z30.string().optional()
 });
 var planShape = {
   effort: optimizationEffortSchema.optional(),
-  sampleCount: z31.number().int().min(1).max(100).optional(),
-  maxRounds: z31.number().int().min(1).max(100).optional(),
-  maxTrialsPerRound: z31.number().int().min(1).max(10).optional()
+  sampleCount: z30.number().int().min(1).max(100).optional(),
+  maxRounds: z30.number().int().min(1).max(100).optional(),
+  maxTrialsPerRound: z30.number().int().min(1).max(10).optional()
 };
 function refinePlan(value, ctx) {
   if (value.effort && (value.sampleCount || value.maxRounds))
@@ -3511,18 +3236,18 @@ function refinePlan(value, ctx) {
       message: "Pin an agent with the model"
     });
 }
-var startOptimizationBodySchema = z31.object({
+var startOptimizationBodySchema = z30.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string().min(1),
-  name: z31.string().trim().min(1).max(200).optional(),
+  subjectId: z30.string().min(1),
+  name: z30.string().trim().min(1).max(200).optional(),
   ...planShape,
-  creditCap: z31.number().int().nonnegative().optional(),
-  targetScore: z31.number().min(0).max(1).optional(),
+  creditCap: z30.number().int().nonnegative().optional(),
+  targetScore: z30.number().min(0).max(1).optional(),
   target: targetSchema.extend({ agent: schedulableAgentSchema })
 }).strict().superRefine(refinePlan);
-var estimateOptimizationBodySchema = z31.object({
+var estimateOptimizationBodySchema = z30.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string().min(1),
+  subjectId: z30.string().min(1),
   ...planShape,
   target: targetSchema.optional()
 }).strict().superRefine(refinePlan);
@@ -3534,101 +3259,101 @@ var RUN_CREDIT_BASES = [
   "byok",
   "reserve"
 ];
-var runCreditBasisSchema = z31.enum(RUN_CREDIT_BASES);
-var optimizationEstimateSchema = z31.object({
-  sampleCount: z31.number().int(),
-  maxRounds: z31.number().int(),
-  runsPerTrial: z31.number(),
-  executionCredits: z31.number(),
-  judgeCredits: z31.number(),
-  leverPassCredits: z31.number(),
-  trialCredits: z31.number(),
+var runCreditBasisSchema = z30.enum(RUN_CREDIT_BASES);
+var optimizationEstimateSchema = z30.object({
+  sampleCount: z30.number().int(),
+  maxRounds: z30.number().int(),
+  runsPerTrial: z30.number(),
+  executionCredits: z30.number(),
+  judgeCredits: z30.number(),
+  leverPassCredits: z30.number(),
+  trialCredits: z30.number(),
   /** Estimate, not a reservation or enforced spending cap. */
-  estimate: z31.number().int(),
+  estimate: z30.number().int(),
   /** True when no price or history covered a model: a bound, not a forecast. */
-  approximate: z31.boolean().default(false),
+  approximate: z30.boolean().default(false),
   /** Which rung priced the run, so the UI can say why a figure is what it is. */
   basis: runCreditBasisSchema.optional()
 });
-var diagnoseBodySchema = z31.object({
+var diagnoseBodySchema = z30.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string().min(1)
+  subjectId: z30.string().min(1)
 }).strict();
-var diagnosisSchema = z31.object({
-  id: z31.string(),
-  status: z31.enum(["GENERATING", "READY", "FAILED"]),
+var diagnosisSchema = z30.object({
+  id: z30.string(),
+  status: z30.enum(["GENERATING", "READY", "FAILED"]),
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string(),
-  runCount: z31.number().int(),
-  summary: z31.string().nullable(),
+  subjectId: z30.string(),
+  runCount: z30.number().int(),
+  summary: z30.string().nullable(),
   recommendedLever: leverKindSchema.nullable(),
-  recommendedTarget: z31.unknown().nullable(),
-  clusters: z31.array(
-    z31.object({
-      title: z31.string(),
-      failureMode: z31.string(),
-      criterionIds: z31.array(z31.string()),
-      runIds: z31.array(z31.string()),
+  recommendedTarget: z30.unknown().nullable(),
+  clusters: z30.array(
+    z30.object({
+      title: z30.string(),
+      failureMode: z30.string(),
+      criterionIds: z30.array(z30.string()),
+      runIds: z30.array(z30.string()),
       lever: leverKindSchema.nullable(),
-      targetRef: z31.unknown().nullable(),
-      confidence: z31.number()
+      targetRef: z30.unknown().nullable(),
+      confidence: z30.number()
     })
   ),
-  unsupportedLevers: z31.array(leverKindSchema).default([]),
-  createdAt: z31.string()
+  unsupportedLevers: z30.array(leverKindSchema).default([]),
+  createdAt: z30.string()
 });
-var trialRunSchema = z31.object({
-  id: z31.string(),
-  status: z31.string(),
+var trialRunSchema = z30.object({
+  id: z30.string(),
+  status: z30.string(),
   cliCoverage: cliCoverageSchema.nullable().optional(),
-  passed: z31.boolean().nullable(),
-  criteria: z31.array(
-    z31.object({ name: z31.string(), passed: z31.boolean(), reasoning: z31.string() })
+  passed: z30.boolean().nullable(),
+  criteria: z30.array(
+    z30.object({ name: z30.string(), passed: z30.boolean(), reasoning: z30.string() })
   ),
-  levers: z31.array(
-    z31.object({
-      lever: z31.string(),
-      attributed: z31.boolean(),
-      note: z31.string().nullable()
+  levers: z30.array(
+    z30.object({
+      lever: z30.string(),
+      attributed: z30.boolean(),
+      note: z30.string().nullable()
     })
   )
 });
-var trialSchema = z31.object({
-  id: z31.string(),
-  climbId: z31.string(),
-  roundNumber: z31.number().int(),
-  key: z31.string(),
+var trialSchema = z30.object({
+  id: z30.string(),
+  climbId: z30.string(),
+  roundNumber: z30.number().int(),
+  key: z30.string(),
   /** @deprecated All trials branch from the baseline. */
-  parentTrialId: z31.string().nullable(),
+  parentTrialId: z30.string().nullable(),
   /** @deprecated Always the baseline key for non-baseline trials. */
-  parentKey: z31.string().nullable(),
-  title: z31.string(),
-  hypothesis: z31.string().nullable(),
+  parentKey: z30.string().nullable(),
+  title: z30.string(),
+  hypothesis: z30.string().nullable(),
   lever: leverKindSchema.nullable(),
   kind: interventionKindSchema,
-  status: z31.enum(TRIAL_STATUSES),
-  verdict: z31.enum(TRIAL_VERDICTS).nullable(),
-  score: z31.number().nullable(),
-  baselineScore: z31.number().nullable(),
+  status: z30.enum(TRIAL_STATUSES),
+  verdict: z30.enum(TRIAL_VERDICTS).nullable(),
+  score: z30.number().nullable(),
+  baselineScore: z30.number().nullable(),
   /** Judged sessions behind `score`. */
-  sessions: z31.number().int(),
-  isBaseline: z31.boolean(),
+  sessions: z30.number().int(),
+  isBaseline: z30.boolean(),
   /** The user marked this trial as the winner; it does not move the baseline. */
-  adopted: z31.boolean(),
-  adoptedAt: z31.string().nullable(),
-  outcome: z31.string().nullable(),
+  adopted: z30.boolean(),
+  adoptedAt: z30.string().nullable(),
+  outcome: z30.string().nullable(),
   /** The kind-specific `after` payload (skill version id, pages, package). */
-  after: z31.unknown(),
-  before: z31.unknown(),
-  runs: z31.array(trialRunSchema),
-  createdAt: z31.string()
-});
-var roundSchema = z31.object({
-  id: z31.string(),
-  number: z31.number().int(),
-  status: z31.enum(ROUND_STATUSES),
-  narrative: z31.string().nullable(),
-  trials: z31.array(trialSchema)
+  after: z30.unknown(),
+  before: z30.unknown(),
+  runs: z30.array(trialRunSchema),
+  createdAt: z30.string()
+});
+var roundSchema = z30.object({
+  id: z30.string(),
+  number: z30.number().int(),
+  status: z30.enum(ROUND_STATUSES),
+  narrative: z30.string().nullable(),
+  trials: z30.array(trialSchema)
 });
 var OPTIMIZATION_NEXT_ACTIONS = [
   "START",
@@ -3639,375 +3364,375 @@ var OPTIMIZATION_NEXT_ACTIONS = [
   "RESUME",
   "NONE"
 ];
-var optimizationNextActionSchema = z31.enum(OPTIMIZATION_NEXT_ACTIONS);
+var optimizationNextActionSchema = z30.enum(OPTIMIZATION_NEXT_ACTIONS);
 var optimizationDetailSchema = optimizationSummarySchema.extend({
-  baselineTrialId: z31.string().nullable(),
+  baselineTrialId: z30.string().nullable(),
   /** The one thing a client does next. WAIT and NONE need nobody. */
   nextAction: optimizationNextActionSchema,
-  settings: z31.object({
-    sampleCount: z31.number().int(),
-    maxRounds: z31.number().int(),
-    maxTrialsPerRound: z31.number().int(),
-    creditCap: z31.number().int(),
-    targetScore: z31.number(),
-    pinnedAgent: z31.string().nullable(),
-    pinnedModel: z31.string().nullable(),
-    continuedAtRound: z31.number().int().nullable()
+  settings: z30.object({
+    sampleCount: z30.number().int(),
+    maxRounds: z30.number().int(),
+    maxTrialsPerRound: z30.number().int(),
+    creditCap: z30.number().int(),
+    targetScore: z30.number(),
+    pinnedAgent: z30.string().nullable(),
+    pinnedModel: z30.string().nullable(),
+    continuedAtRound: z30.number().int().nullable()
   }),
   direction: climbDirectionSchema,
-  rounds: z31.array(roundSchema)
+  rounds: z30.array(roundSchema)
 });
-var listTrialsResponseSchema = z31.object({
-  items: z31.array(trialSchema)
+var listTrialsResponseSchema = z30.object({
+  items: z30.array(trialSchema)
 });
-var trialDocumentSchema = z31.object({
-  path: z31.string(),
-  before: z31.string(),
-  after: z31.string()
+var trialDocumentSchema = z30.object({
+  path: z30.string(),
+  before: z30.string(),
+  after: z30.string()
 });
-var trialContentSchema = z31.object({
-  trialId: z31.string(),
+var trialContentSchema = z30.object({
+  trialId: z30.string(),
   kind: interventionKindSchema,
-  documents: z31.array(trialDocumentSchema),
+  documents: z30.array(trialDocumentSchema),
   /** Full page bodies for a docs rewrite, ready to paste; null otherwise. */
-  copyableBody: z31.string().nullable(),
-  configSnapshot: z31.unknown()
+  copyableBody: z30.string().nullable(),
+  configSnapshot: z30.unknown()
 });
-var createTrialBodySchema = z31.object({
+var createTrialBodySchema = z30.object({
   trial: trialInputSchema,
   files: overrideFilesSchema.optional(),
-  fork: z31.object({ runId: z31.string().min(1), boundarySeq: z31.string().min(1) }).strict().optional(),
-  launch: z31.boolean().default(false),
+  fork: z30.object({ runId: z30.string().min(1), boundarySeq: z30.string().min(1) }).strict().optional(),
+  launch: z30.boolean().default(false),
   /** Replays return the trial the first call created instead of a second
    *  one. Scoped to the optimization. */
-  idempotencyKey: z31.string().min(1).max(200).optional()
+  idempotencyKey: z30.string().min(1).max(200).optional()
 }).strict();
-var skillFilesResponseSchema = z31.object({
-  versionId: z31.string(),
+var skillFilesResponseSchema = z30.object({
+  versionId: z30.string(),
   files: overrideFilesSchema
 });
-var pageBodyResponseSchema = z31.object({
-  url: z31.string(),
-  body: z31.string(),
-  contentType: z31.string().optional()
+var pageBodyResponseSchema = z30.object({
+  url: z30.string(),
+  body: z30.string(),
+  contentType: z30.string().optional()
 });
-var launchTrialResponseSchema = z31.object({
-  trialId: z31.string(),
-  batchIds: z31.array(z31.string()),
-  runIds: z31.array(z31.string())
+var launchTrialResponseSchema = z30.object({
+  trialId: z30.string(),
+  batchIds: z30.array(z30.string()),
+  runIds: z30.array(z30.string())
 });
-var createDraftOptimizationBodySchema = z31.object({
+var createDraftOptimizationBodySchema = z30.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z31.string().min(1),
-  name: z31.string().trim().min(1).max(200).optional(),
+  subjectId: z30.string().min(1),
+  name: z30.string().trim().min(1).max(200).optional(),
   ...planShape,
   target: targetSchema.optional(),
-  autonomous: z31.boolean().optional()
+  autonomous: z30.boolean().optional()
 }).strict().superRefine(refinePlan);
 var planPatchShape = {
-  name: z31.string().trim().min(1).max(200).optional(),
+  name: z30.string().trim().min(1).max(200).optional(),
   ...planShape,
   target: targetSchema.optional()
 };
-var optimizationPlanPatchSchema = z31.object(planPatchShape).strict().superRefine(refinePlan);
-var startDraftOptimizationBodySchema = z31.object({
+var optimizationPlanPatchSchema = z30.object(planPatchShape).strict().superRefine(refinePlan);
+var startDraftOptimizationBodySchema = z30.object({
   ...planPatchShape,
-  creditCap: z31.number().int().nonnegative().optional()
+  creditCap: z30.number().int().nonnegative().optional()
 }).strict().superRefine(refinePlan);
-var setModeBodySchema = z31.object({ autonomous: z31.boolean() }).strict();
-var launchRoundResponseSchema = z31.object({
-  roundNumber: z31.number().int().nullable(),
-  launched: z31.array(z31.string()),
+var setModeBodySchema = z30.object({ autonomous: z30.boolean() }).strict();
+var launchRoundResponseSchema = z30.object({
+  roundNumber: z30.number().int().nullable(),
+  launched: z30.array(z30.string()),
   /** True when nothing was left to launch: someone else got there first. */
-  alreadyLaunched: z31.boolean()
+  alreadyLaunched: z30.boolean()
 });
-var resolveChatResponseSchema = z31.object({
-  chatId: z31.string(),
-  href: z31.string()
+var resolveChatResponseSchema = z30.object({
+  chatId: z30.string(),
+  href: z30.string()
 });
-var continueOptimizationBodySchema = z31.object({
-  rounds: z31.number().int().min(1).max(20).default(1),
-  maxTrialsPerRound: z31.number().int().min(1).max(10).optional()
+var continueOptimizationBodySchema = z30.object({
+  rounds: z30.number().int().min(1).max(20).default(1),
+  maxTrialsPerRound: z30.number().int().min(1).max(10).optional()
 }).strict();
-var patchOptimizationBodySchema = z31.object({
+var patchOptimizationBodySchema = z30.object({
   ...planPatchShape,
   direction: climbDirectionPatchSchema.optional(),
-  autonomous: z31.boolean().optional()
+  autonomous: z30.boolean().optional()
 }).strict().superRefine(refinePlan);
 
 // ../packages/api-schemas/src/orgs.ts
-import { z as z32 } from "zod";
-var createOrgRequestSchema = z32.object({
+import { z as z31 } from "zod";
+var createOrgRequestSchema = z31.object({
   /** Workspace display name; the slug is derived server-side. */
-  name: z32.string().trim().min(1).max(200),
+  name: z31.string().trim().min(1).max(200),
   /** Optional company site (logo source; stamped onto the org). */
-  website: z32.string().trim().max(300).optional()
+  website: z31.string().trim().max(300).optional()
 });
-var createOrgResponseSchema = z32.object({
-  slug: z32.string(),
-  name: z32.string(),
+var createOrgResponseSchema = z31.object({
+  slug: z31.string(),
+  name: z31.string(),
   // LOCAL orgs never have a Gauge publicId.
-  publicId: z32.string().nullable()
+  publicId: z31.string().nullable()
 });
-var orgSettingsSchema = z32.object({
-  slug: z32.string(),
-  name: z32.string(),
-  publicId: z32.string().nullable(),
-  website: z32.string().nullable(),
+var orgSettingsSchema = z31.object({
+  slug: z31.string(),
+  name: z31.string(),
+  publicId: z31.string().nullable(),
+  website: z31.string().nullable(),
   /** Per-run max-spend override in USD; null = the server default. */
-  maxSpendUsd: z32.number().nullable(),
-  overageEnabled: z32.boolean(),
+  maxSpendUsd: z31.number().nullable(),
+  overageEnabled: z31.boolean(),
   /** Per-cycle overage cap in credits; null = uncapped. */
-  overageCapCredits: z32.number().int().nullable(),
+  overageCapCredits: z31.number().int().nullable(),
   /** Domain claimed for same-domain auto-join; null = off. */
-  autoJoinDomain: z32.string().nullable()
+  autoJoinDomain: z31.string().nullable()
 });
-var orgMemberSchema = z32.object({
-  userId: z32.string(),
-  name: z32.string().nullable(),
-  email: z32.string().nullable(),
-  joinedAt: z32.string()
+var orgMemberSchema = z31.object({
+  userId: z31.string(),
+  name: z31.string().nullable(),
+  email: z31.string().nullable(),
+  joinedAt: z31.string()
 });
-var listMembersResponseSchema = z32.object({
-  items: z32.array(orgMemberSchema)
+var listMembersResponseSchema = z31.object({
+  items: z31.array(orgMemberSchema)
 });
 
 // ../packages/api-schemas/src/personas.ts
-import { z as z33 } from "zod";
-var personaSchema = z33.object({
-  id: z33.string(),
-  name: z33.string(),
-  description: z33.string(),
+import { z as z32 } from "zod";
+var personaSchema = z32.object({
+  id: z32.string(),
+  name: z32.string(),
+  description: z32.string(),
   /** The judge model this persona calls (Claude only). */
-  model: z33.string(),
-  createdAt: z33.string(),
-  updatedAt: z33.string()
+  model: z32.string(),
+  createdAt: z32.string(),
+  updatedAt: z32.string()
 });
-var listPersonasResponseSchema = z33.object({
-  items: z33.array(personaSchema)
+var listPersonasResponseSchema = z32.object({
+  items: z32.array(personaSchema)
 });
-var createPersonaBodySchema = z33.object({
-  name: z33.string().min(1).max(120),
-  description: z33.string().min(1)
+var createPersonaBodySchema = z32.object({
+  name: z32.string().min(1).max(120),
+  description: z32.string().min(1)
 });
-var updatePersonaBodySchema = z33.object({
-  name: z33.string().min(1).max(120).optional(),
-  description: z33.string().min(1).optional()
+var updatePersonaBodySchema = z32.object({
+  name: z32.string().min(1).max(120).optional(),
+  description: z32.string().min(1).optional()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z34 } from "zod";
-var tagSchema = z34.object({
-  id: z34.string(),
-  name: z34.string(),
+import { z as z33 } from "zod";
+var tagSchema = z33.object({
+  id: z33.string(),
+  name: z33.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z34.string()
+  color: z33.string()
 });
-var createTagBodySchema = z34.object({
-  name: z34.string().min(1),
-  color: z34.string().optional()
+var createTagBodySchema = z33.object({
+  name: z33.string().min(1),
+  color: z33.string().optional()
 });
-var updateTagBodySchema = z34.object({
-  name: z34.string().min(1).optional(),
-  color: z34.string().optional()
+var updateTagBodySchema = z33.object({
+  name: z33.string().min(1).optional(),
+  color: z33.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z35 } from "zod";
-var topicSchema = z35.object({
-  id: z35.string(),
-  name: z35.string()
+import { z as z34 } from "zod";
+var topicSchema = z34.object({
+  id: z34.string(),
+  name: z34.string()
 });
-var createTopicBodySchema = z35.object({
-  name: z35.string().min(1, "name is required")
+var createTopicBodySchema = z34.object({
+  name: z34.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
 // ../packages/api-schemas/src/prompts.ts
-var promptSummarySchema = z36.object({
-  id: z36.string(),
-  text: z36.string(),
-  isBranded: z36.boolean(),
+var promptSummarySchema = z35.object({
+  id: z35.string(),
+  text: z35.string(),
+  isBranded: z35.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z36.string().nullable(),
+  externalKey: z35.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z36.array(tagSchema),
-  createdAt: z36.string()
+  tags: z35.array(tagSchema),
+  createdAt: z35.string()
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z36.string().min(1).optional(),
-  tag: z36.string().min(1).optional(),
-  q: z36.string().min(1).optional()
-});
-var createPromptBodySchema = z36.object({
-  text: z36.string().min(1, "text is required"),
-  isBranded: z36.boolean().default(false),
-  topic: z36.string().min(1).optional(),
-  tags: z36.array(z36.string().min(1)).default([])
-});
-var updatePromptBodySchema = z36.object({
-  text: z36.string().min(1).optional(),
-  isBranded: z36.boolean().optional(),
-  topicId: z36.string().min(1).nullish(),
-  tags: z36.array(z36.string().min(1)).optional()
-});
-var runPromptBodySchema = z36.object({
+  topic: z35.string().min(1).optional(),
+  tag: z35.string().min(1).optional(),
+  q: z35.string().min(1).optional()
+});
+var createPromptBodySchema = z35.object({
+  text: z35.string().min(1, "text is required"),
+  isBranded: z35.boolean().default(false),
+  topic: z35.string().min(1).optional(),
+  tags: z35.array(z35.string().min(1)).default([])
+});
+var updatePromptBodySchema = z35.object({
+  text: z35.string().min(1).optional(),
+  isBranded: z35.boolean().optional(),
+  topicId: z35.string().min(1).nullish(),
+  tags: z35.array(z35.string().min(1)).optional()
+});
+var runPromptBodySchema = z35.object({
   /** Preferred paired representation; each agent may pin its own model tiers. */
-  agentConfigs: z36.array(agentConfigInputSchema).min(1).optional(),
+  agentConfigs: z35.array(agentConfigInputSchema).min(1).optional(),
   /** Legacy agent set (no per-agent pins), kept during the API transition. */
-  agents: z36.array(z36.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
-  repoUrl: z36.string().min(1).nullish(),
-  repoRef: z36.string().min(1).nullish(),
-  samplesPerCycle: z36.number().int().min(1).max(10).default(1),
+  agents: z35.array(z35.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z35.string().min(1).nullish(),
+  repoRef: z35.string().min(1).nullish(),
+  samplesPerCycle: z35.number().int().min(1).max(10).default(1),
   webFixture: webFixtureSchema.optional()
 });
-var runPromptResponseSchema = z36.object({
-  batchIds: z36.array(z36.string()),
-  runIds: z36.array(z36.string()),
-  blocked: z36.enum(["insufficient_credits", "needs_provider_key"]).optional()
+var runPromptResponseSchema = z35.object({
+  batchIds: z35.array(z35.string()),
+  runIds: z35.array(z35.string()),
+  blocked: z35.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z37 } from "zod";
+import { z as z36 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z37.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z37.object({
-  url: z37.string(),
-  name: z37.string(),
-  isSystem: z37.boolean(),
-  languages: z37.array(z37.string()),
-  frameworks: z37.array(z37.string()),
+var repoSizeBucketSchema = z36.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z36.object({
+  url: z36.string(),
+  name: z36.string(),
+  isSystem: z36.boolean(),
+  languages: z36.array(z36.string()),
+  frameworks: z36.array(z36.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z37.array(z37.string()),
-  primaryLanguage: z37.string(),
-  sizeKb: z37.number(),
+  tags: z36.array(z36.string()),
+  primaryLanguage: z36.string(),
+  sizeKb: z36.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z37.number()
+  stars: z36.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z37.object({
-  url: z37.string().min(1, "url is required"),
+var addRepoBodySchema = z36.object({
+  url: z36.string().min(1, "url is required"),
   /**
    * Reserved (accepted, not yet persisted): the catalog keys repos by URL only
    * — `fact_repo` has no ref column and metadata sync always reads the default
    * branch. Kept in the wire format so `gauge repos add --ref` is stable once
    * the catalog learns refs.
    */
-  ref: z37.string().min(1).optional(),
+  ref: z36.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z37.string().min(1).optional(),
+  name: z36.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z37.array(z37.string()).optional(),
-  tags: z37.array(z37.string()).optional()
+  frameworks: z36.array(z36.string()).optional(),
+  tags: z36.array(z36.string()).optional()
 });
-var updateRepoBodySchema = z37.object({
-  url: z37.string().min(1, "url is required"),
-  name: z37.string().min(1).optional(),
-  frameworks: z37.array(z37.string()).optional(),
-  tags: z37.array(z37.string()).optional()
+var updateRepoBodySchema = z36.object({
+  url: z36.string().min(1, "url is required"),
+  name: z36.string().min(1).optional(),
+  frameworks: z36.array(z36.string()).optional(),
+  tags: z36.array(z36.string()).optional()
 });
-var resyncRepoBodySchema = z37.object({
-  url: z37.string().min(1, "url is required")
+var resyncRepoBodySchema = z36.object({
+  url: z36.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z37.object({
-  url: z37.string().min(1, "url is required")
+var deleteRepoQuerySchema = z36.object({
+  url: z36.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z37.object({
+var repoSyncResultSchema = z36.object({
   repo: repoSchema,
-  synced: z37.boolean()
+  synced: z36.boolean()
 });
 
 // ../packages/api-schemas/src/runAddons.ts
-import { z as z38 } from "zod";
-var runAddonsSchema = z38.object({
-  browser: z38.object({
-    session: z38.string().min(1),
-    projectId: z38.number().int().positive(),
-    region: z38.literal("us").default("us")
+import { z as z37 } from "zod";
+var runAddonsSchema = z37.object({
+  browser: z37.object({
+    session: z37.string().min(1),
+    projectId: z37.number().int().positive(),
+    region: z37.literal("us").default("us")
   }).strict().optional()
 }).strict();
 
 // ../packages/api-schemas/src/runDefinitions.ts
-import { z as z40 } from "zod";
+import { z as z39 } from "zod";
 
 // ../packages/api-schemas/src/runPlan.ts
-import { z as z39 } from "zod";
-var runPlanCriterionSchema = z39.object({
-  id: z39.string().min(1),
-  name: z39.string(),
-  rubric: z39.string()
+import { z as z38 } from "zod";
+var runPlanCriterionSchema = z38.object({
+  id: z38.string().min(1),
+  name: z38.string(),
+  rubric: z38.string()
 });
-var criteriaSnapshotV1Schema = z39.object({
-  version: z39.literal(1),
+var criteriaSnapshotV1Schema = z38.object({
+  version: z38.literal(1),
   // File-authored criteria have no saved EvalSet; their identity is frozen
   // in the request and result rows retain the criterion text without an FK.
-  evalSetId: z39.string().min(1).nullable(),
-  criteria: z39.array(runPlanCriterionSchema)
-});
-var runPlanCaseSchema = z39.object({
-  id: z39.string().min(1),
-  prompt: z39.object({ id: z39.string().min(1), text: z39.string() }),
-  workspace: z39.object({
-    repoUrl: z39.string().nullable(),
-    repoRef: z39.string().nullable()
+  evalSetId: z38.string().min(1).nullable(),
+  criteria: z38.array(runPlanCriterionSchema)
+});
+var runPlanCaseSchema = z38.object({
+  id: z38.string().min(1),
+  prompt: z38.object({ id: z38.string().min(1), text: z38.string() }),
+  workspace: z38.object({
+    repoUrl: z38.string().nullable(),
+    repoRef: z38.string().nullable()
   }),
-  agents: z39.array(
+  agents: z38.array(
     agentConfigSchema.extend({
       // Validated against the current catalog request schema when lowered.
-      catalogSelections: z39.record(z39.string(), z39.unknown()).optional()
+      catalogSelections: z38.record(z38.string(), z38.unknown()).optional()
     })
   ),
-  samples: z39.number().int().min(1).max(50),
-  evalSetId: z39.string().min(1).optional(),
+  samples: z38.number().int().min(1).max(50),
+  evalSetId: z38.string().min(1).optional(),
   criteriaSnapshot: criteriaSnapshotV1Schema.optional(),
-  sourceRepoCommit: z39.string().nullable().optional(),
-  experiment: z39.string().nullable().optional(),
-  membershipTagIds: z39.array(z39.string()).optional(),
-  profile: z39.object({
-    id: z39.string(),
-    name: z39.string(),
-    description: z39.string(),
-    model: z39.string()
+  sourceRepoCommit: z38.string().nullable().optional(),
+  experiment: z38.string().nullable().optional(),
+  membershipTagIds: z38.array(z38.string()).optional(),
+  profile: z38.object({
+    id: z38.string(),
+    name: z38.string(),
+    description: z38.string(),
+    model: z38.string()
   }).nullable().optional(),
   skillSet: skillSetSchema.optional(),
   mcpSet: mcpSetSchema.optional(),
   connectionSet: connectionSetSchema.optional(),
   // The server's agentContextSnapshotV1Schema validates this at lowering.
-  agentContext: z39.unknown().optional(),
-  agentContextDigest: z39.string().nullable().optional(),
+  agentContext: z38.unknown().optional(),
+  agentContextDigest: z38.string().nullable().optional(),
   addons: runAddonsSchema.optional(),
   /** Names of resources the coordinator must prepare before expansion. */
-  inputs: z39.array(z39.string().min(1)).default([])
-});
-var builtDirectoryResourceSchema = z39.object({
-  name: z39.string().min(1),
-  type: z39.literal("built-directory"),
-  source: z39.object({
-    type: z39.literal("git-checkout"),
-    repoUrl: z39.string().min(1),
-    commit: z39.string().regex(/^[a-f0-9]{40}$/i)
+  inputs: z38.array(z38.string().min(1)).default([])
+});
+var builtDirectoryResourceSchema = z38.object({
+  name: z38.string().min(1),
+  type: z38.literal("built-directory"),
+  source: z38.object({
+    type: z38.literal("git-checkout"),
+    repoUrl: z38.string().min(1),
+    commit: z38.string().regex(/^[a-f0-9]{40}$/i)
   }),
-  build: z39.object({
-    runtime: z39.literal("node-24"),
-    run: z39.string().min(1),
-    output: z39.string().min(1),
+  build: z38.object({
+    runtime: z38.literal("node-24"),
+    run: z38.string().min(1),
+    output: z38.string().min(1),
     /** Declared command name plus args, invoked from a clean cwd before a session. */
-    smoke: z39.array(z39.string().min(1)).min(1)
+    smoke: z38.array(z38.string().min(1)).min(1)
   }),
-  expose: z39.object({
-    type: z39.literal("command"),
-    commands: z39.record(z39.string().min(1), z39.array(z39.string().min(1)).min(1))
+  expose: z38.object({
+    type: z38.literal("command"),
+    commands: z38.record(z38.string().min(1), z38.array(z38.string().min(1)).min(1))
   })
 }).superRefine((resource, ctx) => {
   if (!(resource.build.smoke[0] in resource.expose.commands))
@@ -4017,24 +3742,24 @@ var builtDirectoryResourceSchema = z39.object({
       message: "Smoke command must name an exposed command"
     });
 });
-var bundleRelativeScriptSchema = z39.string().min(1).refine(
+var bundleRelativeScriptSchema = z38.string().min(1).refine(
   (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.includes("\0") && !path2.split("/").includes("..") && path2.split("/").some((part) => part !== "" && part !== "."),
   "Install script must be a bundle-relative path without traversal"
 );
-var preparedDirectoryPrepareSchema = z39.union([
-  z39.object({ run: z39.string().min(1) }).strict(),
-  z39.object({
-    type: z39.literal("npm-cli"),
-    build: z39.string().min(1).optional()
+var preparedDirectoryPrepareSchema = z38.union([
+  z38.object({ run: z38.string().min(1) }).strict(),
+  z38.object({
+    type: z38.literal("npm-cli"),
+    build: z38.string().min(1).optional()
   }).strict()
 ]);
-var preparedDirectoryResourceSchema = z39.object({
-  name: z39.string().min(1),
-  type: z39.literal("prepared-directory"),
-  source: z39.object({
-    type: z39.literal("git-checkout"),
-    repoUrl: z39.string().min(1),
-    commit: z39.string().regex(/^[a-f0-9]{40}$/i)
+var preparedDirectoryResourceSchema = z38.object({
+  name: z38.string().min(1),
+  type: z38.literal("prepared-directory"),
+  source: z38.object({
+    type: z38.literal("git-checkout"),
+    repoUrl: z38.string().min(1),
+    commit: z38.string().regex(/^[a-f0-9]{40}$/i)
   }).strict(),
   prepare: preparedDirectoryPrepareSchema,
   install: bundleRelativeScriptSchema.optional()
@@ -4046,46 +3771,46 @@ var preparedDirectoryResourceSchema = z39.object({
       message: "npm-cli products cannot declare an install script"
     });
 });
-var runPlanResourceSchema = z39.union([
+var runPlanResourceSchema = z38.union([
   builtDirectoryResourceSchema,
   preparedDirectoryResourceSchema
 ]);
-var runPlanSchema = z39.object({
-  version: z39.literal(1),
+var runPlanSchema = z38.object({
+  version: z38.literal(1),
   /** Existing launches keep their current measurement semantics. */
-  measurementMode: z39.enum(["EXISTING", "AGENT_EXPERIENCE"]),
-  cases: z39.array(runPlanCaseSchema).min(1),
-  resources: z39.array(runPlanResourceSchema).default([]),
+  measurementMode: z38.enum(["EXISTING", "AGENT_EXPERIENCE"]),
+  cases: z38.array(runPlanCaseSchema).min(1),
+  resources: z38.array(runPlanResourceSchema).default([]),
   /** Server-populated context retained across deferred preparation. */
-  launch: z39.object({
-    origin: z39.discriminatedUnion("initiator", [
-      z39.object({
-        initiator: z39.literal("API"),
-        userId: z39.string().min(1),
-        email: z39.string().nullable()
+  launch: z38.object({
+    origin: z38.discriminatedUnion("initiator", [
+      z38.object({
+        initiator: z38.literal("API"),
+        userId: z38.string().min(1),
+        email: z38.string().nullable()
       }).strict(),
-      z39.object({
-        initiator: z39.literal("GITHUB"),
-        userId: z39.null(),
-        email: z39.null()
+      z38.object({
+        initiator: z38.literal("GITHUB"),
+        userId: z38.null(),
+        email: z38.null()
       }).strict()
     ]),
-    funding: z39.enum(["ORG", "PLATFORM"]),
-    queueClass: z39.literal("INTERACTIVE")
+    funding: z38.enum(["ORG", "PLATFORM"]),
+    queueClass: z38.literal("INTERACTIVE")
   }).strict().optional(),
-  provenance: z39.object({
-    definition: z39.object({
-      repoUrl: z39.string().min(1),
-      commit: z39.string().regex(/^[a-f0-9]{40}$/i),
-      digest: z39.string().min(1),
+  provenance: z38.object({
+    definition: z38.object({
+      repoUrl: z38.string().min(1),
+      commit: z38.string().regex(/^[a-f0-9]{40}$/i),
+      digest: z38.string().min(1),
       /** File submissions are asserted by the caller until server-side
        * committed-byte fetching is available. */
-      verification: z39.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"]).optional()
+      verification: z38.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"]).optional()
     }).optional(),
-    liveDependencies: z39.array(
-      z39.object({
-        name: z39.string().min(1),
-        url: z39.string().url().optional()
+    liveDependencies: z38.array(
+      z38.object({
+        name: z38.string().min(1),
+        url: z38.string().url().optional()
       })
     ).default([])
   })
@@ -4136,7 +3861,7 @@ var runPlanSchema = z39.object({
 });
 
 // ../packages/api-schemas/src/runDefinitions.ts
-var uncredentialedRepoUrlSchema = z40.string().min(1).refine((raw) => {
+var uncredentialedRepoUrlSchema = z39.string().min(1).refine((raw) => {
   if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return true;
   try {
     const url = new URL(raw);
@@ -4145,36 +3870,36 @@ var uncredentialedRepoUrlSchema = z40.string().min(1).refine((raw) => {
     return false;
   }
 }, "Repository URL must not contain embedded credentials or query parameters");
-var runDefinitionConfigSchema = z40.object({
-  agents: z40.array(agentConfigInputSchema).min(1),
-  sampleCount: z40.number().int().min(1).max(50).optional(),
+var runDefinitionConfigSchema = z39.object({
+  agents: z39.array(agentConfigInputSchema).min(1),
+  sampleCount: z39.number().int().min(1).max(50).optional(),
   repoUrl: uncredentialedRepoUrlSchema.nullable().optional(),
-  repoRef: z40.string().min(1).nullable().optional(),
-  profileId: z40.string().min(1).nullable().optional(),
+  repoRef: z39.string().min(1).nullable().optional(),
+  profileId: z39.string().min(1).nullable().optional(),
   skillRefs: assetRefListSchema.optional(),
   mcpRefs: assetRefListSchema.optional(),
-  connectionIds: z40.array(z40.string().min(1)).max(32).optional(),
+  connectionIds: z39.array(z39.string().min(1)).max(32).optional(),
   addons: runAddonsSchema.optional()
 }).strict();
-var githubCasePathSchema = z40.string().regex(
+var githubCasePathSchema = z39.string().regex(
   /^evals\/[A-Za-z0-9_./-]+\.md$/,
   "Expected an explicit evals/*.md path"
 ).refine(
   (path2) => path2.split("/").every((part) => part !== "" && part !== "." && part !== ".."),
   "Case path must not contain traversal or empty segments"
 );
-var runDefinitionFileConfigSchema = z40.object({
-  version: z40.literal(1).default(1),
-  org: z40.string().min(1).optional(),
-  product: z40.object({
-    type: z40.literal("npm-cli"),
-    build: z40.string().min(1).optional()
+var runDefinitionFileConfigSchema = z39.object({
+  version: z39.literal(1).default(1),
+  org: z39.string().min(1).optional(),
+  product: z39.object({
+    type: z39.literal("npm-cli"),
+    build: z39.string().min(1).optional()
   }).strict().optional(),
-  prepare: z40.string().min(1).optional(),
+  prepare: z39.string().min(1).optional(),
   install: bundleRelativeScriptSchema.optional(),
-  github: z40.object({
-    enabled: z40.literal(true),
-    files: z40.array(githubCasePathSchema).min(1).max(20).refine(
+  github: z39.object({
+    enabled: z39.literal(true),
+    files: z39.array(githubCasePathSchema).min(1).max(20).refine(
       (paths) => new Set(paths).size === paths.length,
       "Case paths must be unique"
     )
@@ -4193,27 +3918,27 @@ var runDefinitionFileConfigSchema = z40.object({
       message: "npm-cli products cannot declare an install script"
     });
 });
-var runDefinitionCriterionSchema = z40.object({ name: z40.string().min(1), rubric: z40.string().min(1) }).strict();
-var runDefinitionFrontmatterSchema = z40.object({
-  criteria: z40.array(runDefinitionCriterionSchema).min(1),
+var runDefinitionCriterionSchema = z39.object({ name: z39.string().min(1), rubric: z39.string().min(1) }).strict();
+var runDefinitionFrontmatterSchema = z39.object({
+  criteria: z39.array(runDefinitionCriterionSchema).min(1),
   config: runDefinitionConfigSchema
 }).strict();
-var runDefinitionCaseSchema = z40.object({
-  path: z40.string().min(1),
-  prompt: z40.string().min(1),
-  criteria: z40.array(runDefinitionCriterionSchema).min(1),
+var runDefinitionCaseSchema = z39.object({
+  path: z39.string().min(1),
+  prompt: z39.string().min(1),
+  criteria: z39.array(runDefinitionCriterionSchema).min(1),
   config: runDefinitionConfigSchema
 }).strict();
-var runDefinitionSubmissionSchema = z40.object({
-  version: z40.literal(1),
-  source: z40.object({
+var runDefinitionSubmissionSchema = z39.object({
+  version: z39.literal(1),
+  source: z39.object({
     repoUrl: uncredentialedRepoUrlSchema,
-    commit: z40.string().regex(/^[a-f0-9]{40}$/i),
-    digest: z40.string().regex(/^sha256:[a-f0-9]{64}$/),
-    verification: z40.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"])
+    commit: z39.string().regex(/^[a-f0-9]{40}$/i),
+    digest: z39.string().regex(/^sha256:[a-f0-9]{64}$/),
+    verification: z39.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"])
   }).strict(),
-  resources: z40.array(preparedDirectoryResourceSchema).max(1).default([]),
-  cases: z40.array(runDefinitionCaseSchema).min(1)
+  resources: z39.array(preparedDirectoryResourceSchema).max(1).default([]),
+  cases: z39.array(runDefinitionCaseSchema).min(1)
 }).strict().superRefine((definition, ctx) => {
   const paths = /* @__PURE__ */ new Set();
   for (const [index, item] of definition.cases.entries()) {
@@ -4259,41 +3984,41 @@ var runDefinitionPublicSubmissionSchema = runDefinitionSubmissionSchema.refine(
     message: "Only the GitHub App may verify committed bytes"
   }
 );
-var runDefinitionPlanResponseSchema = z40.object({
+var runDefinitionPlanResponseSchema = z39.object({
   source: runDefinitionSubmissionSchema.shape.source,
-  measurementMode: z40.literal("AGENT_EXPERIENCE"),
-  cases: z40.array(
-    z40.object({
-      path: z40.string(),
-      agents: z40.array(agentConfigSchema),
-      samples: z40.number().int().nonnegative(),
-      expectedRuns: z40.number().int().nonnegative(),
-      workspace: z40.object({
-        repoUrl: z40.string().nullable(),
-        repoRef: z40.string().nullable()
+  measurementMode: z39.literal("AGENT_EXPERIENCE"),
+  cases: z39.array(
+    z39.object({
+      path: z39.string(),
+      agents: z39.array(agentConfigSchema),
+      samples: z39.number().int().nonnegative(),
+      expectedRuns: z39.number().int().nonnegative(),
+      workspace: z39.object({
+        repoUrl: z39.string().nullable(),
+        repoRef: z39.string().nullable()
       }),
-      criteriaCount: z40.number().int().nonnegative(),
-      inputs: z40.array(z40.string())
+      criteriaCount: z39.number().int().nonnegative(),
+      inputs: z39.array(z39.string())
     })
   ),
-  resources: z40.array(
-    z40.object({ name: z40.string(), type: z40.literal("prepared-directory") })
+  resources: z39.array(
+    z39.object({ name: z39.string(), type: z39.literal("prepared-directory") })
   ),
-  expectedRuns: z40.number().int().nonnegative(),
-  canRun: z40.boolean()
+  expectedRuns: z39.number().int().nonnegative(),
+  canRun: z39.boolean()
 });
-var runDefinitionRunResponseSchema = z40.object({
-  runRequestId: z40.string(),
-  batchIds: z40.array(z40.string()),
-  runIds: z40.array(z40.string()),
-  requestedRuns: z40.number().int().nonnegative(),
-  createdRuns: z40.number().int().nonnegative(),
-  aggregateUrl: z40.string()
+var runDefinitionRunResponseSchema = z39.object({
+  runRequestId: z39.string(),
+  batchIds: z39.array(z39.string()),
+  runIds: z39.array(z39.string()),
+  requestedRuns: z39.number().int().nonnegative(),
+  createdRuns: z39.number().int().nonnegative(),
+  aggregateUrl: z39.string()
 });
 
 // ../packages/api-schemas/src/runRequests.ts
-import { z as z41 } from "zod";
-var runRequestStatusSchema = z41.enum([
+import { z as z40 } from "zod";
+var runRequestStatusSchema = z40.enum([
   "PENDING",
   "PREPARING",
   "RUNNING",
@@ -4301,7 +4026,7 @@ var runRequestStatusSchema = z41.enum([
   "FAILED",
   "CANCELED"
 ]);
-var runRequestResultSchema = z41.enum([
+var runRequestResultSchema = z40.enum([
   "PENDING",
   "PASSED",
   "QUALITY_FAILED",
@@ -4311,222 +4036,222 @@ var runRequestResultSchema = z41.enum([
   "INCOMPLETE",
   "CANCELED"
 ]);
-var runRequestCriterionResultSchema = z41.object({
-  criterionId: z41.string().nullable(),
-  name: z41.string(),
-  passed: z41.boolean(),
-  reasoning: z41.string().nullable()
-});
-var runRequestRunSchema = z41.object({
-  id: z41.string(),
-  batchId: z41.string(),
-  status: z41.string(),
+var runRequestCriterionResultSchema = z40.object({
+  criterionId: z40.string().nullable(),
+  name: z40.string(),
+  passed: z40.boolean(),
+  reasoning: z40.string().nullable()
+});
+var runRequestRunSchema = z40.object({
+  id: z40.string(),
+  batchId: z40.string(),
+  status: z40.string(),
   agent: agentSchema,
-  model: z41.string(),
+  model: z40.string(),
   result: runRequestResultSchema,
-  judge: z41.object({ status: z41.string() }).nullable(),
-  criterionResults: z41.array(runRequestCriterionResultSchema)
+  judge: z40.object({ status: z40.string() }).nullable(),
+  criterionResults: z40.array(runRequestCriterionResultSchema)
 });
-var runRequestResponseSchema = z41.object({
-  id: z41.string(),
+var runRequestResponseSchema = z40.object({
+  id: z40.string(),
   status: runRequestStatusSchema,
   result: runRequestResultSchema,
-  settled: z41.boolean(),
-  counts: z41.object({
-    requestedRuns: z41.number().int().nonnegative(),
-    createdRuns: z41.number().int().nonnegative(),
-    terminalRuns: z41.number().int().nonnegative(),
-    judgedRuns: z41.number().int().nonnegative(),
-    passedRuns: z41.number().int().nonnegative(),
-    qualityFailedRuns: z41.number().int().nonnegative(),
-    executionFailedRuns: z41.number().int().nonnegative(),
-    judgeFailedRuns: z41.number().int().nonnegative(),
-    pendingRuns: z41.number().int().nonnegative()
+  settled: z40.boolean(),
+  counts: z40.object({
+    requestedRuns: z40.number().int().nonnegative(),
+    createdRuns: z40.number().int().nonnegative(),
+    terminalRuns: z40.number().int().nonnegative(),
+    judgedRuns: z40.number().int().nonnegative(),
+    passedRuns: z40.number().int().nonnegative(),
+    qualityFailedRuns: z40.number().int().nonnegative(),
+    executionFailedRuns: z40.number().int().nonnegative(),
+    judgeFailedRuns: z40.number().int().nonnegative(),
+    pendingRuns: z40.number().int().nonnegative()
   }),
-  batches: z41.array(
-    z41.object({ id: z41.string(), runs: z41.array(runRequestRunSchema) })
+  batches: z40.array(
+    z40.object({ id: z40.string(), runs: z40.array(runRequestRunSchema) })
   ),
-  createdAt: z41.string(),
-  updatedAt: z41.string(),
-  finishedAt: z41.string().nullable()
+  createdAt: z40.string(),
+  updatedAt: z40.string(),
+  finishedAt: z40.string().nullable()
 });
 
 // ../packages/api-schemas/src/summary.ts
-import { z as z42 } from "zod";
+import { z as z41 } from "zod";
 function cardResultSchema(data) {
-  return z42.union([
-    z42.object({ ok: z42.literal(true), data }),
-    z42.object({ ok: z42.literal(false), error: z42.string() })
+  return z41.union([
+    z41.object({ ok: z41.literal(true), data }),
+    z41.object({ ok: z41.literal(false), error: z41.string() })
   ]);
 }
-var summaryActionSchema = z42.object({
-  id: z42.string(),
-  title: z42.string(),
-  priority: z42.string(),
-  status: z42.string(),
-  evidenceCount: z42.number().int()
+var summaryActionSchema = z41.object({
+  id: z41.string(),
+  title: z41.string(),
+  priority: z41.string(),
+  status: z41.string(),
+  evidenceCount: z41.number().int()
 });
-var summaryAeCardSchema = z42.object({
-  id: z42.string(),
-  name: z42.string(),
-  judgedRuns: z42.number().int(),
-  passRate: z42.number().nullable(),
+var summaryAeCardSchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  judgedRuns: z41.number().int(),
+  passRate: z41.number().nullable(),
   /** pp delta vs the prior 30d; null with no prior. */
-  deltaPP: z42.number().nullable()
+  deltaPP: z41.number().nullable()
 });
-var summaryVisibilityCardSchema = z42.object({
-  name: z42.string(),
-  owned: z42.object({
-    name: z42.string(),
-    rank: z42.number(),
-    chosenRate: z42.number(),
-    mentionRate: z42.number()
+var summaryVisibilityCardSchema = z41.object({
+  name: z41.string(),
+  owned: z41.object({
+    name: z41.string(),
+    rank: z41.number(),
+    chosenRate: z41.number(),
+    mentionRate: z41.number()
   }).nullable(),
-  chosenDeltaPP: z42.number().nullable()
+  chosenDeltaPP: z41.number().nullable()
 });
-var homeSummarySchema = z42.object({
-  hasAnyRuns: z42.boolean(),
-  lastSynthesisAt: z42.string().nullable(),
-  actions: cardResultSchema(z42.array(summaryActionSchema)),
+var homeSummarySchema = z41.object({
+  hasAnyRuns: z41.boolean(),
+  lastSynthesisAt: z41.string().nullable(),
+  actions: cardResultSchema(z41.array(summaryActionSchema)),
   visibility: cardResultSchema(
-    z42.object({
-      cards: z42.array(summaryVisibilityCardSchema),
-      marketsTotal: z42.number().int(),
-      promptCount: z42.number().int()
+    z41.object({
+      cards: z41.array(summaryVisibilityCardSchema),
+      marketsTotal: z41.number().int(),
+      promptCount: z41.number().int()
     })
   ),
   agentExperience: cardResultSchema(
-    z42.object({
-      cards: z42.array(summaryAeCardSchema),
-      total: z42.number().int(),
-      setCount: z42.number().int()
+    z41.object({
+      cards: z41.array(summaryAeCardSchema),
+      total: z41.number().int(),
+      setCount: z41.number().int()
     })
   ),
-  notableSessions: cardResultSchema(z42.array(z42.unknown()))
+  notableSessions: cardResultSchema(z41.array(z41.unknown()))
 });
 
 // ../packages/api-schemas/src/tokens.ts
-import { z as z43 } from "zod";
-var apiTokenSchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
+import { z as z42 } from "zod";
+var apiTokenSchema = z42.object({
+  id: z42.string(),
+  name: z42.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z43.string(),
-  expiresAt: z43.iso.datetime().nullable(),
-  lastUsedAt: z43.iso.datetime().nullable(),
-  createdAt: z43.iso.datetime(),
-  revokedAt: z43.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z43.object({
-  name: z43.string().min(1).max(100),
+  last4: z42.string(),
+  expiresAt: z42.iso.datetime().nullable(),
+  lastUsedAt: z42.iso.datetime().nullable(),
+  createdAt: z42.iso.datetime(),
+  revokedAt: z42.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z42.object({
+  name: z42.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z43.iso.datetime({ offset: true }).optional()
+  expiresAt: z42.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z43.string()
+  token: z42.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
 // ../packages/api-schemas/src/visibility.ts
-import { z as z44 } from "zod";
+import { z as z43 } from "zod";
 var VISIBILITY_PROMPT_KINDS = ["HEAD_TO_HEAD", "RECOMMEND"];
-var visibilityPromptKindSchema = z44.enum(VISIBILITY_PROMPT_KINDS);
+var visibilityPromptKindSchema = z43.enum(VISIBILITY_PROMPT_KINDS);
 var visibilityPromptSchema = visibilityPromptSettingsSchema.extend({
-  id: z44.string(),
-  name: z44.string(),
+  id: z43.string(),
+  name: z43.string(),
   kind: visibilityPromptKindSchema,
-  promptText: z44.string(),
+  promptText: z43.string(),
   /** HEAD_TO_HEAD is always branded; RECOMMEND may be either. */
-  branded: z44.boolean(),
-  brandA: z44.string().nullable(),
-  brandB: z44.string().nullable(),
-  market: z44.object({ id: z44.string(), slug: z44.string(), name: z44.string() }).nullable(),
-  position: z44.number().int(),
-  createdAt: z44.string(),
+  branded: z43.boolean(),
+  brandA: z43.string().nullable(),
+  brandB: z43.string().nullable(),
+  market: z43.object({ id: z43.string(), slug: z43.string(), name: z43.string() }).nullable(),
+  position: z43.number().int(),
+  createdAt: z43.string(),
   /** User tag names on the hidden backing prompt (Surface:* excluded). */
-  tags: z44.array(z44.string()),
-  runCount: z44.number().int(),
-  lastRunAt: z44.string().nullable(),
-  scenarios: z44.array(visibilityScenarioSchema)
+  tags: z43.array(z43.string()),
+  runCount: z43.number().int(),
+  lastRunAt: z43.string().nullable(),
+  scenarios: z43.array(visibilityScenarioSchema)
 });
-var listVisibilityPromptsResponseSchema = z44.object({
-  items: z44.array(visibilityPromptSchema)
+var listVisibilityPromptsResponseSchema = z43.object({
+  items: z43.array(visibilityPromptSchema)
 });
-var createVisibilityPromptBodySchema = z44.object({
-  name: z44.string().min(1),
-  promptText: z44.string().min(1),
+var createVisibilityPromptBodySchema = z43.object({
+  name: z43.string().min(1),
+  promptText: z43.string().min(1),
   kind: visibilityPromptKindSchema,
-  branded: z44.boolean().optional(),
+  branded: z43.boolean().optional(),
   /** Required pair for HEAD_TO_HEAD (order-independent). */
-  brandA: z44.string().nullish(),
-  brandB: z44.string().nullish(),
+  brandA: z43.string().nullish(),
+  brandB: z43.string().nullish(),
   /** Measured market id from the org's tracked set. */
-  marketId: z44.string().nullish(),
-  tags: z44.array(z44.string()).optional(),
+  marketId: z43.string().nullish(),
+  tags: z43.array(z43.string()).optional(),
   agents: visibilityPromptSettingsInputShape.agents.optional(),
   skillRefs: visibilityPromptSettingsInputShape.skillRefs,
   mcpRefs: visibilityPromptSettingsInputShape.mcpRefs,
   connectionIds: visibilityPromptSettingsInputShape.connectionIds,
   cadence: visibilityPromptSettingsInputShape.cadence,
   sampleCount: visibilityPromptSettingsInputShape.sampleCount,
-  scenarios: z44.array(visibilityScenarioInputSchema).optional().default([])
+  scenarios: z43.array(visibilityScenarioInputSchema).optional().default([])
 }).strict();
-var synthesizeResponseSchema = z44.object({
+var synthesizeResponseSchema = z43.object({
   /** False when the pre-check found no new evidence and nothing was queued. */
-  queued: z44.boolean()
-});
-var updateVisibilityPromptBodySchema = z44.object({
-  name: z44.string().min(1).optional(),
-  promptText: z44.string().min(1).optional(),
-  branded: z44.boolean().optional(),
-  brandA: z44.string().nullish(),
-  brandB: z44.string().nullish(),
-  marketId: z44.string().nullish(),
-  tags: z44.array(z44.string()).optional(),
+  queued: z43.boolean()
+});
+var updateVisibilityPromptBodySchema = z43.object({
+  name: z43.string().min(1).optional(),
+  promptText: z43.string().min(1).optional(),
+  branded: z43.boolean().optional(),
+  brandA: z43.string().nullish(),
+  brandB: z43.string().nullish(),
+  marketId: z43.string().nullish(),
+  tags: z43.array(z43.string()).optional(),
   ...visibilityPromptSettingsPatchShape,
   /** Replaces the whole scenario set when present. */
-  scenarios: z44.array(visibilityScenarioInputSchema).optional()
+  scenarios: z43.array(visibilityScenarioInputSchema).optional()
 }).strict();
-var runVisibilityPromptResponseSchema = z44.object({
-  batchIds: z44.array(z44.string()),
-  runIds: z44.array(z44.string())
+var runVisibilityPromptResponseSchema = z43.object({
+  batchIds: z43.array(z43.string()),
+  runIds: z43.array(z43.string())
 });
-var visibilityPromptRunSchema = z44.object({
-  id: z44.string(),
-  status: z44.string(),
+var visibilityPromptRunSchema = z43.object({
+  id: z43.string(),
+  status: z43.string(),
   agent: agentSchema,
-  model: z44.string().nullable(),
-  resolvedModel: z44.string().nullable(),
-  createdAt: z44.string(),
-  startedAt: z44.string().nullable(),
-  finishedAt: z44.string().nullable(),
-  failureReason: z44.string().nullable(),
-  verdict: z44.object({
-    status: z44.string(),
-    error: z44.string().nullable(),
-    payload: z44.unknown().nullable()
+  model: z43.string().nullable(),
+  resolvedModel: z43.string().nullable(),
+  createdAt: z43.string(),
+  startedAt: z43.string().nullable(),
+  finishedAt: z43.string().nullable(),
+  failureReason: z43.string().nullable(),
+  verdict: z43.object({
+    status: z43.string(),
+    error: z43.string().nullable(),
+    payload: z43.unknown().nullable()
   }).nullable()
 });
-var listVisibilityPromptRunsResponseSchema = z44.object({
-  items: z44.array(visibilityPromptRunSchema)
+var listVisibilityPromptRunsResponseSchema = z43.object({
+  items: z43.array(visibilityPromptRunSchema)
 });
-var orgMarketSchema = z44.object({
-  marketId: z44.string(),
-  slug: z44.string(),
-  name: z44.string(),
+var orgMarketSchema = z43.object({
+  marketId: z43.string(),
+  slug: z43.string(),
+  name: z43.string(),
   /** The one line saying what the market measures. */
-  capability: z44.string(),
+  capability: z43.string(),
   /** SUGGESTED (the matcher) | USER (a human picked it). */
-  source: z44.string()
+  source: z43.string()
 });
 var addableMarketSchema = orgMarketSchema.omit({ source: true });
-var listMarketsResponseSchema = z44.object({
-  tracked: z44.array(orgMarketSchema),
+var listMarketsResponseSchema = z43.object({
+  tracked: z43.array(orgMarketSchema),
   /** Published markets the org does not track yet (closed set — no free-text
    *  market creation). */
-  addable: z44.array(addableMarketSchema)
+  addable: z43.array(addableMarketSchema)
 });
-var addMarketBodySchema = z44.object({ marketId: z44.string().min(1) });
+var addMarketBodySchema = z43.object({ marketId: z43.string().min(1) });
 
 // src/version.ts
 import { createRequire } from "module";
@@ -4911,7 +4636,7 @@ __export(apply_exports, {
   register: () => register2
 });
 import { readFileSync as readFileSync3 } from "fs";
-import { z as z45 } from "zod";
+import { z as z44 } from "zod";
 function assertRequiredExperiment(spec, required) {
   if (required.length === 0) {
     throw new CliError(
@@ -5063,7 +4788,7 @@ function register2(program2) {
   ).option("--schema", "print the battery spec JSON Schema and exit").option("--example", "print a minimal example battery spec and exit").action(
     async (opts, command) => {
       if (opts.schema) {
-        printJson(z45.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z44.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -6929,422 +6654,10 @@ function register11(program2) {
   );
 }
 
-// src/commands/experiments.ts
-var experiments_exports2 = {};
-__export(experiments_exports2, {
-  register: () => register12,
-  rewriteContentType: () => rewriteContentType
-});
-import { readFileSync as readFileSync7 } from "fs";
-import { extname } from "path";
-var TERMINAL = /* @__PURE__ */ new Set(["COMPLETE", "PARTIAL", "FAILED", "CANCELED"]);
-function experimentsPath(org) {
-  return `/api/v1/orgs/${encodeURIComponent(org)}/experiments`;
-}
-function itemPath(org, id) {
-  return `${experimentsPath(org)}/${encodeURIComponent(id)}`;
-}
-function readText(path2) {
-  return readFileSync7(path2 === "-" ? 0 : path2, "utf8");
-}
-var REWRITE_FILE_CONTENT_TYPES = {
-  ".md": "text/markdown",
-  ".markdown": "text/markdown",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".txt": "text/plain"
-};
-function rewriteContentType(path2, explicit) {
-  if (explicit !== void 0) return explicit;
-  if (path2 === void 0 || path2 === "-") return void 0;
-  return REWRITE_FILE_CONTENT_TYPES[extname(path2).toLowerCase()];
-}
-function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function toRow3(e) {
-  return {
-    id: e.id,
-    status: e.status,
-    problem: e.problem.length > 60 ? `${e.problem.slice(0, 57)}...` : e.problem,
-    page: e.boundaryUrl ?? "",
-    variants: e.variantCount,
-    "source run": e.sourceRunId,
-    created: e.createdAt
-  };
-}
-function printDetail3(e) {
-  console.log(`id:          ${e.id}`);
-  console.log(`status:      ${e.status}`);
-  console.log(`problem:     ${e.problem}`);
-  console.log(`page:        ${e.boundaryUrl ?? "(none)"}`);
-  console.log(`source run:  ${e.sourceRun.runId} (${e.sourceRun.agent})`);
-  if (e.launchError) console.log(`launch err:  ${e.launchError}`);
-  console.log("variants:");
-  for (const v of e.variants) {
-    const rewrite = v.hasRewrite ? `${v.rewriteChars} chars` : "no rewrite yet";
-    const state = v.invalidReason ? `invalid: ${v.invalidReason}` : v.planStatus ?? "draft";
-    console.log(
-      `  [${v.key}] ${v.title || "(untitled)"} \u2014 ${rewrite}, ${state}`
-    );
-    if (v.hypothesis) console.log(`      hypothesis: ${v.hypothesis}`);
-    for (const r of v.runs) {
-      console.log(
-        `      run ${r.runId}: ${r.status}${r.failureReason ? ` (${r.failureReason})` : ""}`
-      );
-    }
-  }
-}
-function register12(program2) {
-  const group = program2.command("experiments").description(
-    "Author, launch, and read content experiments (legacy: orgs with Optimizations reject writes; use `gauge optimizations`)"
-  );
-  group.command("list").description("List the org's experiments").option(
-    "--status <statuses>",
-    "comma-separated statuses (e.g. RUNNING,COMPLETE)"
-  ).option("--limit <n>", "max rows (default 25)").action(async (opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const res = await createClient().get(
-      experimentsPath(org),
-      { status: opts.status, limit: opts.limit }
-    );
-    if (resolveOutput(cmd) === "json") printJson(res.items);
-    else printItems(res.items.map(toRow3), "table");
-  });
-  group.command("eligible").description("Recent runs worth experimenting on (worst verdicts first)").action(async (_opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const res = await createClient().get(`${experimentsPath(org)}/eligible-runs`);
-    if (resolveOutput(cmd) === "json") printJson(res.items);
-    else
-      printItems(
-        res.items.map((r) => ({
-          "run id": r.runId,
-          agent: r.agent,
-          verdict: r.verdict ?? "-",
-          boundaries: r.boundaryCount,
-          created: r.createdAt
-        })),
-        "table"
-      );
-  });
-  group.command("boundaries").description("The forkable fetches of a run (pass boundarySeq to create)").requiredOption("--run <runId>", "source run id").action(async (opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const res = await createClient().get(`${experimentsPath(org)}/boundaries`, { runId: opts.run });
-    if (resolveOutput(cmd) === "json") printJson(res.items);
-    else
-      printItems(
-        res.items.map((b) => ({
-          boundarySeq: String(b.boundarySeq),
-          turn: b.turn ?? "?",
-          url: b.url,
-          prompt: b.fetchPrompt ?? ""
-        })),
-        "table"
-      );
-  });
-  group.command("create").description(
-    "Open (or resume) an experiment draft and start the plan round"
-  ).requiredOption("--run <runId>", "source run id").requiredOption(
-    "--boundary <seq>",
-    "opaque boundarySeq from `experiments boundaries`"
-  ).option("--problem <text>", "problem statement (derived if omitted)").option(
-    "--mode <mode>",
-    "who writes the rewrites: propose (default, directions are proposed then each is written), direct (one --change instruction, one write), manual (no generation \u2014 the rewrite is seeded with the page the agent read)",
-    "propose"
-  ).option(
-    "--change <text>",
-    "--mode direct only: the one change to make, in your words"
-  ).action(
-    async (opts, cmd) => {
-      const org = resolveOrg(cmd);
-      const parsedMode = experiments_exports.experimentModeSchema.safeParse(
-        opts.mode.toUpperCase()
-      );
-      if (!parsedMode.success) {
-        throw new Error(
-          `--mode must be one of ${experiments_exports.EXPERIMENT_MODES.map((m) => m.toLowerCase()).join(", ")}`
-        );
-      }
-      const mode = parsedMode.data;
-      if (mode === "DIRECT" && !opts.change?.trim()) {
-        throw new Error("--mode direct requires --change <text>");
-      }
-      if (mode !== "DIRECT" && opts.change !== void 0) {
-        throw new Error(`--change only applies to --mode direct`);
-      }
-      const body = {
-        runId: opts.run,
-        boundarySeq: opts.boundary,
-        ...opts.problem !== void 0 ? { problemText: opts.problem } : {},
-        mode,
-        ...opts.change !== void 0 ? { changeInstruction: opts.change.trim() } : {}
-      };
-      const result = await createClient().post(
-        experimentsPath(org),
-        body
-      );
-      if (resolveOutput(cmd) === "json") {
-        printJson(result);
-        return;
-      }
-      console.log(
-        `${result.created ? "Created" : "Resumed"} experiment ${result.experimentId}`
-      );
-      console.log(`Problem: ${result.problemText}`);
-      console.log(`Mode: ${result.mode.toLowerCase()}`);
-      if (!result.created && result.mode !== mode) {
-        console.error(
-          `Note: this fetch already had a live ${result.mode.toLowerCase()} draft, so --mode ${mode.toLowerCase()} was not applied \u2014 that draft was resumed instead.`
-        );
-      }
-      console.error(
-        result.mode === "MANUAL" ? `Tip: \`gauge experiments get ${result.experimentId}\` shows the seeded rewrite once the page is recovered` : `Tip: \`gauge experiments watch ${result.experimentId}\` follows the ${result.mode === "DIRECT" ? "write" : "plan"} round`
-      );
-    }
-  );
-  group.command("get <id>").description("Full detail: directions, rewrites, arms, verdicts").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const detail = await createClient().get(
-      itemPath(org, id)
-    );
-    if (resolveOutput(cmd) === "json") printJson(detail);
-    else printDetail3(detail);
-  });
-  group.command("status <id>").description("The async round/launch state (carries launchError)").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const status = await createClient().get(
-      `${itemPath(org, id)}/status`
-    );
-    if (resolveOutput(cmd) === "json") printJson(status);
-    else {
-      console.log(`status: ${status.status}`);
-      if (status.launchError)
-        console.log(`launch error: ${status.launchError}`);
-      if (status.shippedVariantId)
-        console.log(
-          `shipped: ${status.shippedVariantId} at ${status.shippedAt}`
-        );
-    }
-  });
-  const variants = group.command("variants").description("Manage a draft's rewrite directions");
-  variants.command("add <experimentId>").description("Add a direction (a candidate rewrite slot)").option("--title <title>", "direction title").option("--hypothesis <text>", "what this rewrite should change").action(
-    async (experimentId, opts, cmd) => {
-      const org = resolveOrg(cmd);
-      const created = await createClient().post(
-        `${itemPath(org, experimentId)}/variants`,
-        opts
-      );
-      if (resolveOutput(cmd) === "json") printJson(created);
-      else console.log(`Added variant ${created.key} (${created.id})`);
-    }
-  );
-  variants.command("edit <experimentId> <variantId>").description("Retitle / re-hypothesize a direction").option("--title <title>", "direction title").option("--hypothesis <text>", "hypothesis").action(
-    async (experimentId, variantId, opts, cmd) => {
-      if (opts.title === void 0 && opts.hypothesis === void 0)
-        throw new CliError("usage", "nothing to change");
-      const org = resolveOrg(cmd);
-      await createClient().patch(
-        `${itemPath(org, experimentId)}/variants/${encodeURIComponent(variantId)}`,
-        opts
-      );
-      if (resolveOutput(cmd) !== "json") console.log("Updated");
-    }
-  );
-  variants.command("rm <experimentId> <variantId>").description("Remove a direction from the draft").action(
-    async (experimentId, variantId, _o, cmd) => {
-      const org = resolveOrg(cmd);
-      await createClient().delete(
-        `${itemPath(org, experimentId)}/variants/${encodeURIComponent(variantId)}`
-      );
-      if (resolveOutput(cmd) !== "json") console.log("Removed");
-    }
-  );
-  group.command("content <id>").description("Read the live page (or a rewrite) in bounded windows").option("--variant <variantId>", "read this variant's rewrite instead").option("--offset <n>", "start offset (default 0)").option("--max-chars <n>", "window size (default 20000, max 40000)").action(
-    async (id, opts, cmd) => {
-      const org = resolveOrg(cmd);
-      const result = await createClient().get(
-        `${itemPath(org, id)}/content`,
-        {
-          variantId: opts.variant,
-          offset: opts.offset,
-          maxChars: opts.maxChars
-        }
-      );
-      if (resolveOutput(cmd) === "json") {
-        printJson(result);
-        return;
-      }
-      process.stdout.write(result.content);
-      if (result.nextOffset != null)
-        console.error(
-          `
---- ${result.returnedChars}/${result.totalChars} chars; continue with --offset ${result.nextOffset}`
-        );
-    }
-  );
-  group.command("rewrite <id> <variantId>").description(
-    "Write a variant's page: --file replaces it; --edits-file applies {find, replace} ops"
-  ).option("--file <path>", 'full content ("-" for stdin)').option(
-    "--content-type <mime>",
-    "rewrite MIME type (inferred for .md, .markdown, .html, .htm, and .txt)"
-  ).option(
-    "--edits-file <path>",
-    'JSON array of {find, replace} ops ("-" for stdin)'
-  ).action(
-    async (id, variantId, opts, cmd) => {
-      if (opts.file === void 0 === (opts.editsFile === void 0))
-        throw new CliError(
-          "usage",
-          "pass exactly one of --file or --edits-file"
-        );
-      const org = resolveOrg(cmd);
-      const body = {};
-      if (opts.file !== void 0) body.content = readText(opts.file);
-      else {
-        let parsed;
-        try {
-          parsed = JSON.parse(readText(opts.editsFile));
-        } catch (e) {
-          throw new CliError(
-            "usage",
-            `could not read --edits-file: ${e instanceof Error ? e.message : e}`
-          );
-        }
-        if (!Array.isArray(parsed) || parsed.length === 0)
-          throw new CliError(
-            "usage",
-            "--edits-file must be a non-empty JSON array of {find, replace}"
-          );
-        body.edits = parsed;
-      }
-      body.contentType = rewriteContentType(opts.file, opts.contentType);
-      const result = await createClient().put(
-        `${itemPath(org, id)}/variants/${encodeURIComponent(variantId)}/content`,
-        body
-      );
-      if (resolveOutput(cmd) === "json") printJson(result);
-      else {
-        console.log(`Wrote ${result.chars} chars`);
-        if (body.edits)
-          console.log(
-            `Edits: ${result.applied} applied, ${result.skipped} skipped`
-          );
-        if (result.truncated) console.error("warning: content was truncated");
-      }
-    }
-  );
-  group.command("replan <id>").description("Discard the directions and propose fresh ones").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    await createClient().post(`${itemPath(org, id)}/replan`, {});
-    if (resolveOutput(cmd) !== "json")
-      console.log("Replanning \u2014 follow with `gauge experiments watch`");
-  });
-  group.command("write <id>").description("Write rewrites for directions that lack one").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const result = await createClient().post(
-      `${itemPath(org, id)}/write`,
-      {}
-    );
-    if (resolveOutput(cmd) === "json") {
-      printJson(result);
-      return;
-    }
-    if (result.queued > 0) console.log(`Queued ${result.queued} rewrite(s)`);
-    else if (result.reason === "round_in_flight")
-      console.log("A round is already running");
-    else console.log("Nothing pending \u2014 every direction has a rewrite");
-  });
-  group.command("launch <id>").description("Claim the draft for launch (spends credits; async fan-out)").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const result = await createClient().post(
-      `${itemPath(org, id)}/launch`,
-      {}
-    );
-    if (resolveOutput(cmd) === "json") printJson(result);
-    else
-      console.log(
-        `Launching ${result.experimentId} \u2014 \`gauge experiments watch ${result.experimentId}\` follows it`
-      );
-  });
-  group.command("watch <id>").description(
-    "Follow the running round or launch; prints the recommendation on settle"
-  ).option("--interval <seconds>", "poll interval (default 10)").action(async (id, opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const client = createClient();
-    const intervalMs = Math.max(Number(opts.interval ?? 10) * 1e3, 2e3);
-    const GRACE_POLLS = 3;
-    let sawActive = false;
-    let draftPolls = 0;
-    let last = "";
-    for (; ; ) {
-      const status = await client.get(
-        `${itemPath(org, id)}/status`
-      );
-      if (status.status !== last) {
-        last = status.status;
-        console.error(`status: ${status.status}`);
-        if (status.launchError)
-          console.error(`launch error: ${status.launchError}`);
-      }
-      if (TERMINAL.has(status.status)) break;
-      if (status.status === "DRAFT") {
-        if (status.launchError) {
-          process.exitCode = 1;
-          return;
-        }
-        if (sawActive) {
-          console.error(
-            `Round finished \u2014 \`gauge experiments get ${id}\` shows the directions and rewrites.`
-          );
-          return;
-        }
-        draftPolls += 1;
-        if (draftPolls >= GRACE_POLLS) {
-          console.error(
-            `Nothing is running \u2014 \`gauge experiments get ${id}\` shows the draft.`
-          );
-          return;
-        }
-      } else {
-        sawActive = true;
-      }
-      await sleep2(intervalMs);
-    }
-    const rec = await client.get(
-      `${itemPath(org, id)}/recommendation`
-    );
-    printJson(rec);
-  });
-  group.command("export <id>").description("Print the settled recommendation (JSON)").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const rec = await createClient().get(
-      `${itemPath(org, id)}/recommendation`
-    );
-    printJson(rec);
-  });
-  group.command("ship <id> <variantId>").description("Mark a variant as shipped to your live docs").action(
-    async (id, variantId, _o, cmd) => {
-      const org = resolveOrg(cmd);
-      await createClient().post(`${itemPath(org, id)}/ship`, { variantId });
-      if (resolveOutput(cmd) !== "json") console.log("Marked shipped");
-    }
-  );
-  group.command("unship <id>").description("Clear the shipped mark").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    await createClient().delete(`${itemPath(org, id)}/ship`);
-    if (resolveOutput(cmd) !== "json") console.log("Cleared");
-  });
-  group.command("cancel <id>").description("Cancel a draft/generating/launching experiment").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    await createClient().post(`${itemPath(org, id)}/cancel`, {});
-    if (resolveOutput(cmd) !== "json") console.log(`Canceled ${id}`);
-  });
-}
-
 // src/commands/instructions.ts
 var instructions_exports = {};
 __export(instructions_exports, {
-  register: () => register13
+  register: () => register12
 });
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join3 } from "path";
@@ -7463,7 +6776,7 @@ function resolveTopic(topic) {
 
 // src/commands/instructions.ts
 var INSTALL_ROOT = ".claude/skills";
-function register13(program2) {
+function register12(program2) {
   program2.command("instructions [topic]").description(
     `Instructions for a coding agent using this CLI. Run before your first gauge command; a topic reprints one group: ${TOPIC_NAMES.join(", ")}`
   ).option("--list", "print the topic names only").option(
@@ -7496,7 +6809,7 @@ function register13(program2) {
 // src/commands/keys.ts
 var keys_exports2 = {};
 __export(keys_exports2, {
-  register: () => register14
+  register: () => register13
 });
 function keysPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/provider-keys`;
@@ -7539,7 +6852,7 @@ async function readKeyInput(opts) {
   }
   return key;
 }
-function register14(program2) {
+function register13(program2) {
   const group = program2.command("keys").description("Manage BYOK provider keys (write-only; reads show last4)");
   group.command("set <provider>").description(
     "Set a provider key (anthropic|openai); reads it from stdin or GAUGE_PROVIDER_KEY"
@@ -7595,9 +6908,9 @@ function register14(program2) {
 // src/commands/mcp.ts
 var mcp_exports2 = {};
 __export(mcp_exports2, {
-  register: () => register15
+  register: () => register14
 });
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function mcpPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/mcp-servers`;
 }
@@ -7613,7 +6926,7 @@ function specFromOpts(opts) {
       throw new CliError("usage", "--spec-file conflicts with --command/--url");
     try {
       return JSON.parse(
-        readFileSync8(opts.specFile === "-" ? 0 : opts.specFile, "utf8")
+        readFileSync7(opts.specFile === "-" ? 0 : opts.specFile, "utf8")
       );
     } catch (e) {
       throw new CliError(
@@ -7642,7 +6955,7 @@ function specFromOpts(opts) {
     ...tools.length ? { tools } : {}
   };
 }
-function register15(program2) {
+function register14(program2) {
   const group = program2.command("mcp").description("Manage MCP servers used by eval and visibility runs");
   group.command("list").description("List the org's MCP servers with their newest version").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7773,9 +7086,9 @@ function register15(program2) {
 // src/commands/members.ts
 var members_exports = {};
 __export(members_exports, {
-  register: () => register16
+  register: () => register15
 });
-function register16(program2) {
+function register15(program2) {
   const group = program2.command("members").description("Team members and pending invites (read-only)");
   group.command("list").description("List members and pending invites").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7817,7 +7130,7 @@ var models_exports = {};
 __export(models_exports, {
   capabilityLabel: () => capabilityLabel,
   executionTargetsPath: () => executionTargetsPath,
-  register: () => register17
+  register: () => register16
 });
 function executionTargetsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/execution-targets`;
@@ -7825,7 +7138,7 @@ function executionTargetsPath(org) {
 function capabilityLabel(capabilities) {
   return Object.entries(capabilities).filter(([, supported]) => supported).map(([name]) => name === "agentContext" ? "context" : name).join(", ");
 }
-function register17(program2) {
+function register16(program2) {
   const group = program2.command("models").description("Discover supported models, harnesses, and providers");
   group.command("list", { isDefault: true }).description("List execution targets available to the organization").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7852,7 +7165,7 @@ function register17(program2) {
 // src/commands/onboard.ts
 var onboard_exports = {};
 __export(onboard_exports, {
-  register: () => register18
+  register: () => register17
 });
 function orgNameFromEmail(email) {
   const domain = email?.split("@")[1] ?? "";
@@ -7860,7 +7173,7 @@ function orgNameFromEmail(email) {
   if (!base) return "My Workspace";
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
-function register18(program2) {
+function register17(program2) {
   program2.command("onboard").description(
     "Self-serve onboarding: sign in (device flow) and create your first workspace"
   ).option("--email <email>", "email a sign-in link (device-flow convenience)").option("--org-name <name>", "workspace name (default: from your email)").option("--website <url>", "company site (scanned to seed the workspace)").option("--new", "create a new workspace even if you already belong to one").option(
@@ -7967,28 +7280,28 @@ __export(optimizations_exports2, {
   parseTarget: () => parseTarget,
   planFromOpts: () => planFromOpts,
   readSkillDir: () => readSkillDir,
-  register: () => register19,
+  register: () => register18,
   trialBodyFromOpts: () => trialBodyFromOpts,
   trialTemplate: () => trialTemplate,
   watchStops: () => watchStops
 });
-import { readdirSync, readFileSync as readFileSync9, statSync } from "fs";
+import { readdirSync, readFileSync as readFileSync8, statSync } from "fs";
 import { join as join4, relative as relative2, sep as sep2 } from "path";
-var TERMINAL2 = /* @__PURE__ */ new Set(["DONE", "ARCHIVED"]);
+var TERMINAL = /* @__PURE__ */ new Set(["DONE", "ARCHIVED"]);
 var EFFORTS = ["low", "medium", "high", "xhigh"];
 function basePath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/optimizations`;
 }
-function itemPath2(org, id) {
+function itemPath(org, id) {
   return `${basePath(org)}/${encodeURIComponent(id)}`;
 }
 function trialPath(org, id, trialId) {
-  return `${itemPath2(org, id)}/trials/${encodeURIComponent(trialId)}`;
+  return `${itemPath(org, id)}/trials/${encodeURIComponent(trialId)}`;
 }
-function readText2(path2) {
-  return readFileSync9(path2 === "-" ? 0 : path2, "utf8");
+function readText(path2) {
+  return readFileSync8(path2 === "-" ? 0 : path2, "utf8");
 }
-function sleep3(ms) {
+function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function parseSubject(opts) {
@@ -8041,19 +7354,19 @@ var NEXT_ACTION_HINT = {
   AUTHOR_TRIAL: "author the next trial: `gauge optimizations trials add <id>`",
   LAUNCH_ROUND: "launch the saved round: `gauge optimizations launch <id>`",
   ADOPT: "adopt the winning trial: `gauge optimizations adopt <id> <trial>`",
-  RESUME: "resume it: `gauge optimizations resume <id>`",
+  RESUME: "resume it in the web app, or `gauge optimizations cancel <id>`",
   NONE: "nothing to do in Gauge"
 };
 function awaitingInput(detail) {
   return detail.nextAction !== "WAIT" && detail.nextAction !== "NONE";
 }
 function watchStops(detail, follow) {
-  return TERMINAL2.has(detail.status) || detail.nextAction === "NONE" || !follow && awaitingInput(detail);
+  return TERMINAL.has(detail.status) || detail.nextAction === "NONE" || !follow && awaitingInput(detail);
 }
 function readObject(path2) {
   let value;
   try {
-    value = JSON.parse(readText2(path2));
+    value = JSON.parse(readText(path2));
   } catch {
     throw new CliError("usage", "the file must contain valid JSON");
   }
@@ -8086,7 +7399,7 @@ function parseStatuses(raw) {
       );
   return parts.join(",");
 }
-function readSkillDir(dir, read = readText2, walk = listFiles) {
+function readSkillDir(dir, read = readText, walk = listFiles) {
   const paths = walk(dir).sort();
   if (!paths.length)
     throw new CliError("usage", `no files under ${dir} to send`);
@@ -8113,7 +7426,7 @@ function listFiles(dir) {
     return statSync(path2).isDirectory() ? listFiles(path2) : [path2];
   });
 }
-function trialBodyFromOpts(opts, read = readText2, walk) {
+function trialBodyFromOpts(opts, read = readText, walk) {
   const launch = opts.launch === true;
   const idempotencyKey = opts.idempotencyKey;
   const fork = opts.forkRun || opts.forkBoundary ? (() => {
@@ -8255,7 +7568,7 @@ function pct(value) {
 function subjectLabel(kind) {
   return kind === "EVAL_SET" ? "eval" : "preference";
 }
-function toRow4(o) {
+function toRow3(o) {
   return {
     id: o.id,
     name: o.name.length > 40 ? `${o.name.slice(0, 37)}...` : o.name,
@@ -8284,7 +7597,7 @@ function trialRow(t) {
     id: t.id
   };
 }
-function printDetail4(o) {
+function printDetail3(o) {
   console.log(`id:        ${o.id}`);
   console.log(`name:      ${o.name}`);
   console.log(
@@ -8408,7 +7721,7 @@ function addPlanOptions(command) {
     "the one harness/model every session runs on, e.g. claude-code:claude-opus-4-8"
   );
 }
-function register19(program2) {
+function register18(program2) {
   const group = program2.command("optimizations").alias("optimize").description(
     "Start, steer, and read optimizations: Gauge changes one owned surface per trial and reports the best measured change against the baseline"
   );
@@ -8430,14 +7743,14 @@ function register19(program2) {
         }
       );
       if (resolveOutput(cmd) === "json") printJson(res.items);
-      else printItems(res.items.map(toRow4), "table");
+      else printItems(res.items.map(toRow3), "table");
     }
   );
   group.command("get <id>").description("One optimization: settings, score, and its trial ladder").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
-    const detail = await createClient().get(itemPath2(org, id));
+    const detail = await createClient().get(itemPath(org, id));
     if (resolveOutput(cmd) === "json") printJson(detail);
-    else printDetail4(detail);
+    else printDetail3(detail);
   });
   addSubjectOptions(
     group.command("diagnose").description(
@@ -8520,7 +7833,7 @@ function register19(program2) {
       opts.yes
     );
     const detail = await createClient().post(
-      `${itemPath2(org, id)}/cancel`,
+      `${itemPath(org, id)}/cancel`,
       {}
     );
     if (resolveOutput(cmd) === "json") printJson(detail);
@@ -8544,7 +7857,7 @@ function register19(program2) {
         }
       );
       if (resolveOutput(cmd) === "json") printJson(detail);
-      else printDetail4(detail);
+      else printDetail3(detail);
     }
   );
   addPlanOptions(
@@ -8563,11 +7876,11 @@ function register19(program2) {
       if (!Object.keys(body).length)
         throw new CliError("usage", "pass plan flags, --name, or --file");
       const detail = await createClient().patch(
-        itemPath2(resolveOrg(cmd), id),
+        itemPath(resolveOrg(cmd), id),
         body
       );
       if (resolveOutput(cmd) === "json") printJson(detail);
-      else printDetail4(detail);
+      else printDetail3(detail);
     }
   );
   addPlanOptions(
@@ -8578,11 +7891,11 @@ function register19(program2) {
       const client = createClient();
       const plan = planFromOpts(opts);
       const creditCap = parseCreditEstimate(opts.creditCap);
-      const current = await client.get(itemPath2(org, id));
+      const current = await client.get(itemPath(org, id));
       if (current.status !== "DRAFT")
         throw new CliError(
           "usage",
-          "only a draft can start; use resume or continue instead"
+          "only a draft can start; use continue instead"
         );
       const target = plan.target ?? (current.settings.pinnedAgent ? {
         agent: current.settings.pinnedAgent,
@@ -8610,13 +7923,13 @@ function register19(program2) {
         `Start baseline for ${id}? Estimated full optimization: ${creditCap ?? estimate.estimate} credits, not a spending cap.`,
         opts.yes
       );
-      const detail = await client.post(`${itemPath2(org, id)}/start`, {
+      const detail = await client.post(`${itemPath(org, id)}/start`, {
         ...plan,
         name: opts.name,
         creditCap
       });
       if (resolveOutput(cmd) === "json") printJson(detail);
-      else printDetail4(detail);
+      else printDetail3(detail);
     }
   );
   group.command("launch <id>").description(
@@ -8627,7 +7940,7 @@ function register19(program2) {
       opts.yes
     );
     const result = await createClient().post(
-      `${itemPath2(resolveOrg(cmd), id)}/rounds/current/launch`,
+      `${itemPath(resolveOrg(cmd), id)}/rounds/current/launch`,
       {}
     );
     if (resolveOutput(cmd) === "json") printJson(result);
@@ -8651,26 +7964,16 @@ function register19(program2) {
         opts.yes
       );
       const detail = await createClient().post(
-        `${itemPath2(resolveOrg(cmd), id)}/continue`,
+        `${itemPath(resolveOrg(cmd), id)}/continue`,
         { rounds, maxTrialsPerRound }
       );
       if (resolveOutput(cmd) === "json") printJson(detail);
-      else printDetail4(detail);
+      else printDetail3(detail);
     }
   );
-  group.command("resume <id>").description(
-    "Resume a legacy paused optimization with interactive authoring"
-  ).action(async (id, _opts, cmd) => {
-    const detail = await createClient().post(
-      `${itemPath2(resolveOrg(cmd), id)}/resume`,
-      {}
-    );
-    if (resolveOutput(cmd) === "json") printJson(detail);
-    else printDetail4(detail);
-  });
   group.command("activity <id>").description("Read the optimization's decision log").option("--after <timestamp>", "entries after this ISO timestamp").option("--limit <n>", "maximum entries (1\u2013500)").action(
     async (id, opts, cmd) => {
-      const res = await createClient().get(`${itemPath2(resolveOrg(cmd), id)}/activity`, {
+      const res = await createClient().get(`${itemPath(resolveOrg(cmd), id)}/activity`, {
         after: opts.after,
         limit: parseCount(opts.limit, "--limit", 500)
       });
@@ -8689,7 +7992,7 @@ function register19(program2) {
   );
   group.command("chat <id>").description("Resolve your optimization chat and print its URL path").action(async (id, _opts, cmd) => {
     const res = await createClient().post(
-      `${itemPath2(resolveOrg(cmd), id)}/chat`,
+      `${itemPath(resolveOrg(cmd), id)}/chat`,
       {}
     );
     if (resolveOutput(cmd) === "json") printJson(res);
@@ -8700,7 +8003,7 @@ function register19(program2) {
       `Delete optimization ${id}, its rounds, trials, and activity? Session history is kept.`,
       opts.yes
     );
-    await createClient().delete(itemPath2(resolveOrg(cmd), id));
+    await createClient().delete(itemPath(resolveOrg(cmd), id));
     if (resolveOutput(cmd) === "json") printJson({ deleted: id });
     else console.log(`Deleted ${id}.`);
   });
@@ -8712,7 +8015,7 @@ function register19(program2) {
         opts.yes
       );
       const detail = await createClient().post(
-        `${itemPath2(org, id)}/complete`,
+        `${itemPath(org, id)}/complete`,
         opts.adopt ? { adoptTrialId: opts.adopt } : {}
       );
       if (resolveOutput(cmd) === "json") printJson(detail);
@@ -8735,7 +8038,7 @@ function register19(program2) {
       const intervalMs = Math.max(interval * 1e3, 2e3);
       let last = "";
       for (; ; ) {
-        const detail = await client.get(itemPath2(org, id));
+        const detail = await client.get(itemPath(org, id));
         const trials2 = detail.rounds.flatMap((round2) => round2.trials);
         const line = `${detail.status}${detail.stopReason ? ` (${detail.stopReason})` : ""} \xB7 round ${detail.round}/${detail.maxRounds} \xB7 ${pct(detail.before)} \u2192 ${pct(detail.after)} \xB7 ${detail.creditsSpent} credits spent \xB7 ${trials2.filter((t) => t.status === "RUNNING").map((t) => t.key).join(",") || "idle"}`;
         if (line !== last) {
@@ -8745,11 +8048,11 @@ function register19(program2) {
         const needsInput = awaitingInput(detail);
         if (watchStops(detail, !!opts.follow)) {
           if (resolveOutput(cmd) === "json") printJson(detail);
-          else printDetail4(detail);
+          else printDetail3(detail);
           if (needsInput) process.exitCode = NEEDS_INPUT_EXIT;
           return;
         }
-        await sleep3(intervalMs);
+        await sleep2(intervalMs);
       }
     }
   );
@@ -8757,7 +8060,7 @@ function register19(program2) {
     "What the next round may change: kinds, CLI targets and commands, baseline invocations, revision"
   ).action(async (id, _opts, cmd) => {
     printJson(
-      await createClient().get(`${itemPath2(resolveOrg(cmd), id)}/authoring`)
+      await createClient().get(`${itemPath(resolveOrg(cmd), id)}/authoring`)
     );
   });
   group.command("invocation <id> <invocationId>").description(
@@ -8766,7 +8069,7 @@ function register19(program2) {
     async (id, invocationId, _opts, cmd) => {
       printJson(
         await createClient().get(
-          `${itemPath2(resolveOrg(cmd), id)}/authoring/target`,
+          `${itemPath(resolveOrg(cmd), id)}/authoring/target`,
           { cliInvocationId: invocationId }
         )
       );
@@ -8777,7 +8080,7 @@ function register19(program2) {
   ).requiredOption("--file <path>", "the change JSON; '-' for stdin").action(async (id, opts, cmd) => {
     printJson(
       await createClient().post(
-        `${itemPath2(resolveOrg(cmd), id)}/cli-changes`,
+        `${itemPath(resolveOrg(cmd), id)}/cli-changes`,
         readObject(opts.file)
       )
     );
@@ -8787,7 +8090,7 @@ function register19(program2) {
   );
   round.command("preview <id>").description("Validate a round file and print its diff and previewDigest").requiredOption("--file <path>", "the round JSON; '-' for stdin").action(async (id, opts, cmd) => {
     const preview = await createClient().post(
-      `${itemPath2(resolveOrg(cmd), id)}/rounds/current/preview`,
+      `${itemPath(resolveOrg(cmd), id)}/rounds/current/preview`,
       readObject(opts.file)
     );
     if (resolveOutput(cmd) === "json") printJson(preview);
@@ -8798,7 +8101,7 @@ function register19(program2) {
   ).requiredOption("--file <path>", "the round JSON you previewed").requiredOption("--digest <digest>", "previewDigest from `round preview`").action(
     async (id, opts, cmd) => {
       const result = await createClient().put(
-        `${itemPath2(resolveOrg(cmd), id)}/rounds/current`,
+        `${itemPath(resolveOrg(cmd), id)}/rounds/current`,
         { ...readObject(opts.file), previewDigest: opts.digest }
       );
       if (resolveOutput(cmd) === "json") printJson(result);
@@ -8811,7 +8114,7 @@ function register19(program2) {
   trials.command("list <id>").description("Every trial of an optimization with score and verdict").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
     const res = await createClient().get(
-      `${itemPath2(org, id)}/trials`
+      `${itemPath(org, id)}/trials`
     );
     if (resolveOutput(cmd) === "json") printJson(res.items);
     else printItems(res.items.map(trialRow), "table");
@@ -8829,7 +8132,7 @@ function register19(program2) {
     "local directory holding the complete edited bundle, SKILL.md included"
   ).option("--page <url>", "docs page to rewrite (with --body-file)").option("--body-file <path>", "the rewritten page body; '-' for stdin").option("--fork-run <runId>", "fork-at-fetch source run for a docs rewrite").option(
     "--fork-boundary <seq>",
-    "fork-at-fetch boundary from `gauge experiments boundaries`"
+    "fork-at-fetch boundary from `gauge runs fork-boundaries`"
   ).option(
     "--launch",
     "run the trial after saving (spends credits); otherwise save a draft"
@@ -8845,7 +8148,7 @@ function register19(program2) {
           `Run trial "${body.trial.title}" on ${id} now? Spends credits.`,
           opts.yes
         );
-      const result = await createClient().post(`${itemPath2(org, id)}/trials`, body);
+      const result = await createClient().post(`${itemPath(org, id)}/trials`, body);
       if (resolveOutput(cmd) === "json") printJson(result);
       else if (result.replayed)
         console.log(
@@ -8951,7 +8254,7 @@ function register19(program2) {
   ).requiredOption("--url <url>", "the page URL").action(async (id, opts, cmd) => {
     const org = resolveOrg(cmd);
     const res = await createClient().get(
-      `${itemPath2(org, id)}/page`,
+      `${itemPath(org, id)}/page`,
       { url: opts.url }
     );
     if (resolveOutput(cmd) === "json") printJson(res);
@@ -8962,7 +8265,7 @@ function register19(program2) {
 // src/commands/org.ts
 var org_exports = {};
 __export(org_exports, {
-  register: () => register20
+  register: () => register19
 });
 function printSettings(s) {
   console.log(`slug:            ${s.slug}`);
@@ -8976,7 +8279,7 @@ function printSettings(s) {
   );
   console.log(`auto-join:       ${s.autoJoinDomain ?? "off"}`);
 }
-function register20(program2) {
+function register19(program2) {
   const group = program2.command("org").description(
     "This org's settings, read-only (see `gauge orgs` for the org list)"
   );
@@ -8993,12 +8296,12 @@ function register20(program2) {
 // src/commands/orgs.ts
 var orgs_exports2 = {};
 __export(orgs_exports2, {
-  register: () => register21
+  register: () => register20
 });
 function isDefault(org, defaultOrg) {
   return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
 }
-function register21(program2) {
+function register20(program2) {
   const orgs = program2.command("orgs").description("Organizations");
   orgs.command("list").description("List orgs you belong to").action(async (_opts, command) => {
     const output = resolveOutput(command);
@@ -9069,12 +8372,12 @@ function register21(program2) {
 // src/commands/personas.ts
 var personas_exports2 = {};
 __export(personas_exports2, {
-  register: () => register22
+  register: () => register21
 });
 function personasPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/personas`;
 }
-function register22(program2) {
+function register21(program2) {
   const group = program2.command("personas").description("Manage simulated-user personas for eval and visibility runs");
   group.command("list").description("List the org's personas").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -9147,7 +8450,7 @@ function register22(program2) {
 // src/commands/query.ts
 var query_exports2 = {};
 __export(query_exports2, {
-  register: () => register23
+  register: () => register22
 });
 var collect3 = (value, prev = []) => [
   ...prev,
@@ -9339,7 +8642,7 @@ async function showMetadata(command, mode, dataset) {
   console.error(`dataset: ${ds.name} \u2014 ${ds.grain}`);
   printItems(rows, "table");
 }
-function register23(program2) {
+function register22(program2) {
   const group = program2.command("query").description(
     "Flexible reports over your event warehouse (run a report, or discover the catalog)"
   );
@@ -9375,7 +8678,7 @@ function register23(program2) {
 // src/commands/repos.ts
 var repos_exports2 = {};
 __export(repos_exports2, {
-  register: () => register24
+  register: () => register23
 });
 function reposPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/repos`;
@@ -9383,7 +8686,7 @@ function reposPath(org) {
 async function fetchAllRepos(client, org) {
   return fetchAllPages(client, reposPath(org));
 }
-function toRow5(repo) {
+function toRow4(repo) {
   return {
     name: repo.name,
     url: repo.url,
@@ -9398,7 +8701,7 @@ function toRow5(repo) {
 function syncWarning(repo) {
   return `warning: GitHub metadata sync failed; retry with \`gauge repos resync ${repo.url}\``;
 }
-function register24(program2) {
+function register23(program2) {
   const repos = program2.command("repos").description("Manage repositories");
   repos.command("list").description("List repositories (yours + read-only Gauge-provided ones)").action(async (_opts, command) => {
     const org = resolveOrg(command);
@@ -9408,7 +8711,7 @@ function register24(program2) {
       printJson(items);
       return;
     }
-    printItems(items.map(toRow5), "table");
+    printItems(items.map(toRow4), "table");
   });
   repos.command("add <url>").description("Add a repository (pulls languages/size/stars from GitHub)").option(
     "--ref <ref>",
@@ -9495,10 +8798,10 @@ function register24(program2) {
 // src/commands/runRequests.ts
 var runRequests_exports2 = {};
 __export(runRequests_exports2, {
-  register: () => register25
+  register: () => register24
 });
 var pollIntervalMs = 5e3;
-function register25(program2) {
+function register24(program2) {
   program2.command("run-requests").description("Read a durable launch and its aggregate verdict").command("wait <id>").description("Wait for all sessions and judging in a launch request").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
     const path2 = `/api/v1/orgs/${encodeURIComponent(org)}/run-requests/${encodeURIComponent(id)}`;
@@ -9533,7 +8836,7 @@ function register25(program2) {
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register26
+  register: () => register25
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -9554,7 +8857,7 @@ function compact(value, max = 140) {
   const one = s.replace(/\s+/g, " ").trim();
   return one.length > max ? `${one.slice(0, max - 1)}\u2026` : one;
 }
-function toRow6(run) {
+function toRow5(run) {
   const selected = run.selectedProvider?.slug ?? "";
   const observed = run.observedProvider?.slug;
   return {
@@ -9793,7 +9096,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register26(program2) {
+function register25(program2) {
   const runs = program2.command("runs").description("Inspect and manage runs");
   runs.command("list").description("List runs (newest first)").option("--status <status>", "filter by status, e.g. running,queued").option("--batch <id>", "filter by batch").option("--prompt <id>", "filter by prompt").option("--experiment <experiment>", "filter by experiment label").option("--eval-set <id>", "filter by eval set").option("--since <window>", "e.g. 24h, 7d, or an ISO date").option("--limit <n>", "page size (1-200)", "50").option("--cursor <cursor>", "resume from a previous page's nextCursor").action(
     async (opts, command) => {
@@ -9816,7 +9119,7 @@ function register26(program2) {
         printJson(page);
         return;
       }
-      printItems(page.items.map(toRow6), "table");
+      printItems(page.items.map(toRow5), "table");
       if (page.nextCursor) {
         console.error(
           `(more results \u2014 rerun with --cursor ${page.nextCursor})`
@@ -9932,7 +9235,7 @@ function register26(program2) {
 var skills_exports2 = {};
 __export(skills_exports2, {
   buildSkillEditBody: () => buildSkillEditBody,
-  register: () => register27
+  register: () => register26
 });
 function skillsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/skills`;
@@ -9994,7 +9297,7 @@ async function buildSkillEditBody(opts, fetchCurrentSource) {
     throw new CliError("usage", "nothing to change");
   return body;
 }
-function register27(program2) {
+function register26(program2) {
   const group = program2.command("skills").description("Manage agent skills used by eval and visibility runs");
   group.command("list").description("List the org's skills with their newest version").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -10135,7 +9438,7 @@ function register27(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register28
+  register: () => register27
 });
 function addFilterOptions(cmd) {
   return cmd.option("--prompt <id>", "filter to a single prompt").option("--tag <ids>", "comma-separated tag ids").option("--repo <urls>", "comma-separated base repo urls").option("--language <langs>", "comma-separated repo languages").option("--framework <names>", "comma-separated repo frameworks").option("--size <buckets>", "comma-separated codebase-size buckets").option("--branded", "only branded prompts").option("--unbranded", "only non-branded prompts").option("--limit <n>", "max rows (default 50)").option("--full", "return all rows (up to 1000)");
@@ -10168,7 +9471,7 @@ function noteFreshness2(f) {
     );
   }
 }
-async function runStats(command, resource, opts, toRow8) {
+async function runStats(command, resource, opts, toRow7) {
   const org = resolveOrg(command);
   const output = resolveOutput(command);
   const res = await createClient().get(
@@ -10179,7 +9482,7 @@ async function runStats(command, resource, opts, toRow8) {
     printJson(res);
     return;
   }
-  printItems(res.items.map(toRow8), "table");
+  printItems(res.items.map(toRow7), "table");
   noteFreshness2(res.freshness);
 }
 var rankingRow = (r) => ({
@@ -10218,7 +9521,7 @@ var domainRow = (r) => ({
   rate: pct3(r.rate),
   requests: r.requests
 });
-function register28(program2) {
+function register27(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -10250,7 +9553,7 @@ function register28(program2) {
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
-  register: () => register29
+  register: () => register28
 });
 function pct4(rate) {
   return rate == null ? "\u2014" : `${Math.round(rate * 100)}%`;
@@ -10260,7 +9563,7 @@ function delta2(pp) {
   const rounded = Math.round(pp);
   return rounded === 0 ? "" : ` (${rounded > 0 ? "+" : ""}${rounded}pp)`;
 }
-function register29(program2) {
+function register28(program2) {
   program2.command("status").description("One-shot org summary: actions, visibility, agent experience").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
     const s = await createClient().get(
@@ -10322,12 +9625,12 @@ function register29(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register30
+  register: () => register29
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register30(program2) {
+function register29(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -10370,9 +9673,9 @@ function register30(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register31
+  register: () => register30
 });
-function register31(program2) {
+function register30(program2) {
   program2.command("usage").description("List credit ledger entries").option("--since <window>", 'e.g. "30d", "24h", or an ISO date').option("--limit <n>", "page size (1-200)", parseLimit, 50).option("--cursor <cursor>", "resume from a previous page's nextCursor").action(
     async (opts, cmd) => {
       const org = resolveOrg(cmd);
@@ -10419,7 +9722,7 @@ function register31(program2) {
 // src/commands/visibility.ts
 var visibility_exports2 = {};
 __export(visibility_exports2, {
-  register: () => register32,
+  register: () => register31,
   visibilityPath: () => visibilityPath
 });
 import { Option as Option3 } from "commander";
@@ -10451,7 +9754,7 @@ function brandsLabel(v) {
   if (v.kind === "HEAD_TO_HEAD") return `${v.brandA} vs ${v.brandB}`;
   return v.branded ? v.brandA ?? "branded" : "organic";
 }
-function toRow7(v) {
+function toRow6(v) {
   return {
     id: v.id,
     name: v.name,
@@ -10463,7 +9766,7 @@ function toRow7(v) {
     "last run": v.lastRunAt ?? "-"
   };
 }
-function printDetail5(v) {
+function printDetail4(v) {
   console.log(`id:      ${v.id}`);
   console.log(`name:    ${v.name}`);
   console.log(`kind:    ${v.kind}`);
@@ -10498,7 +9801,7 @@ function registerPreferenceGroup(group) {
       visibilityPath(org)
     );
     if (resolveOutput(cmd) === "json") printJson(res.items);
-    else printItems(res.items.map(toRow7), "table");
+    else printItems(res.items.map(toRow6), "table");
   });
   group.command("get <id>").description("Show one preference prompt").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -10506,7 +9809,7 @@ function registerPreferenceGroup(group) {
       `${visibilityPath(org)}/${encodeURIComponent(id)}`
     );
     if (resolveOutput(cmd) === "json") printJson(vp);
-    else printDetail5(vp);
+    else printDetail4(vp);
   });
   addRunSettingsCreateOptions(
     group.command("create").description(
@@ -10775,7 +10078,7 @@ function registerPreferenceGroup(group) {
     );
   });
 }
-function register32(program2) {
+function register31(program2) {
   const preference = program2.command("preference").description("Manage Agent Preference prompts and measured markets");
   registerPreferenceGroup(preference);
   const legacy = program2.command("visibility", { hidden: true });
@@ -10811,7 +10114,6 @@ for (const group of [
   runs_exports2,
   runRequests_exports2,
   optimizations_exports2,
-  experiments_exports2,
   apply_exports,
   batches_exports,
   brands_exports2,