@withgauge/cli 0.12.0 → 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({
-  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)
-  }),
-  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({
+var inviteSchema = 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()
+  email: z22.string(),
+  invitedBy: z22.object({
+    name: z22.string().nullable(),
+    email: z22.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,125 +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";
-
-// ../packages/api-schemas/src/climb.ts
 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",
@@ -2598,13 +2320,48 @@ var cliLaunchFormSchema = z28.enum([
   "execveat-path",
   "execveat-fd"
 ]);
-var cliIoProfileSchema = z28.enum([
+var cliObservationReasonSchema = z27.enum([
+  "eligible",
+  "other-target",
+  "other-command",
+  "selector-mismatch",
+  "unknown-command",
+  "identity-unresolved",
+  "artifact-mismatch",
+  "runtime-mismatch",
+  "launch-form",
+  "io-profile",
+  "operation-profile",
+  "descriptor-lifetime"
+]);
+var cliIoProfileSchema = z27.enum([
   "pipes",
   "redirected",
   "shared-descriptor",
   "pty"
 ]);
-var cliOperationKindSchema = z28.enum([
+var cliObservationSchema = z27.object({
+  invocationId: z27.string().regex(/^[a-f0-9]{32}$/),
+  targetId: token,
+  commandId: token.nullable(),
+  entrypointSha256: digest,
+  runtimeSha256: digest.nullable(),
+  launchForm: cliLaunchFormSchema.nullable(),
+  ioProfile: cliIoProfileSchema.nullable(),
+  reason: cliObservationReasonSchema
+});
+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",
@@ -2614,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,
@@ -2633,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)
@@ -2728,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({
@@ -2748,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;
@@ -2779,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,
@@ -2866,34 +2623,36 @@ var baselineInvocationSchema = z28.object({
   artifactSha256: digest.nullable(),
   entrypointSha256: digest,
   engineSha256: digest.optional(),
+  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)]),
+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",
@@ -2904,6 +2663,13 @@ var cliInterventionSchema = z28.object({
   const fail = (path2, message) => ctx.addIssue({ code: "custom", path: path2, message });
   if (bundle.schemaVersion !== bundle.catalog.version)
     fail(["schemaVersion"], "Bundle and catalog schema versions differ");
+  if (bundle.identityPolicy && bundle.schemaVersion !== 2)
+    fail(["identityPolicy"], "Artifact identity requires schema version 2");
+  if (bundle.identityPolicy && bundle.baselineInvocations.some((row2) => !row2.runtimeSha256))
+    fail(
+      ["baselineInvocations"],
+      "Artifact identity requires the recorded runtime bytes"
+    );
   if (!bundle.engineSha256 && (bundle.schemaVersion === 1 || bundle.mode !== "record"))
     fail(["engineSha256"], "A trial must pin the recorded engine bytes");
   if (!bundle.catalog.targets.length)
@@ -3087,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(),
@@ -3095,6 +2861,9 @@ var cliTrialChangeSchema = z28.object({
   shippingIntent: cliInterventionSchema.shape.shippingIntent.unwrap()
 }).strict();
 
+// ../packages/api-schemas/src/climb.ts
+import { z as z29 } from "zod";
+
 // ../packages/api-schemas/src/climb-kinds.ts
 var LEVER_KINDS = [
   "DOCS",
@@ -3123,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()
@@ -3178,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) {
@@ -3195,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",
@@ -3282,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))
@@ -3368,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",
@@ -3397,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))
@@ -3467,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);
@@ -3490,100 +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()
-});
-var trialRunSchema = z31.object({
-  id: z31.string(),
-  status: z31.string(),
-  passed: z31.boolean().nullable(),
-  criteria: z31.array(
-    z31.object({ name: z31.string(), passed: z31.boolean(), reasoning: z31.string() })
+  unsupportedLevers: z30.array(leverKindSchema).default([]),
+  createdAt: z30.string()
+});
+var trialRunSchema = z30.object({
+  id: z30.string(),
+  status: z30.string(),
+  cliCoverage: cliCoverageSchema.nullable().optional(),
+  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",
@@ -3594,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))
@@ -3972,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()
@@ -4001,39 +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.object({
-      initiator: z39.literal("API"),
-      userId: z39.string().min(1),
-      email: z39.string().nullable()
-    }).strict(),
-    funding: z39.enum(["ORG", "PLATFORM"]),
-    queueClass: z39.literal("INTERACTIVE")
+  launch: z38.object({
+    origin: z38.discriminatedUnion("initiator", [
+      z38.object({
+        initiator: z38.literal("API"),
+        userId: z38.string().min(1),
+        email: z38.string().nullable()
+      }).strict(),
+      z38.object({
+        initiator: z38.literal("GITHUB"),
+        userId: z38.null(),
+        email: z38.null()
+      }).strict()
+    ]),
+    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.literal("SUBMITTED_UNVERIFIED").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([])
   })
@@ -4084,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);
@@ -4093,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"
     )
@@ -4141,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.literal("SUBMITTED_UNVERIFIED")
+    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()) {
@@ -4200,41 +3977,48 @@ var runDefinitionSubmissionSchema = z40.object({
       });
   }
 });
-var runDefinitionPlanResponseSchema = z40.object({
+var runDefinitionPublicSubmissionSchema = runDefinitionSubmissionSchema.refine(
+  (definition) => definition.source.verification === "SUBMITTED_UNVERIFIED",
+  {
+    path: ["source", "verification"],
+    message: "Only the GitHub App may verify committed bytes"
+  }
+);
+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",
@@ -4242,7 +4026,7 @@ var runRequestStatusSchema = z41.enum([
   "FAILED",
   "CANCELED"
 ]);
-var runRequestResultSchema = z41.enum([
+var runRequestResultSchema = z40.enum([
   "PENDING",
   "PASSED",
   "QUALITY_FAILED",
@@ -4252,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";
@@ -4852,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(
@@ -5004,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) {
@@ -6347,67 +6131,137 @@ function cadenceLabel(cadence) {
 
 // src/lib/runDefinitionFiles.ts
 import { execFileSync } from "child_process";
-import { createHash as createHash2 } from "crypto";
 import { isAbsolute, relative, resolve, sep } from "path";
+
+// ../packages/api-schemas/src/compileRunDefinition.ts
+import { createHash as createHash2 } from "crypto";
 import { parseDocument } from "yaml";
-function git(cwd, args) {
-  try {
-    return execFileSync("git", args, {
-      cwd,
-      encoding: "buffer",
-      maxBuffer: 10 * 1024 * 1024,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (error) {
-    const detail = error && typeof error === "object" && "stderr" in error ? String(error.stderr).trim() : String(error);
-    throw new CliError("usage", `git ${args[0]} failed: ${detail}`);
-  }
-}
-function committedBlob(root, commit, path2) {
-  return git(root, ["show", `${commit}:${path2}`]);
-}
-function decode(blob, path2) {
+function utf8(bytes, path2) {
   try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(blob);
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
   } catch {
-    throw new CliError("usage", `${path2} is not UTF-8 text`);
-  }
-}
-function parseYaml(text, path2) {
-  const document = parseDocument(text, { uniqueKeys: true });
-  if (document.errors.length) {
-    throw new CliError(
-      "usage",
-      `${path2}: ${document.errors.map((error) => error.message).join("; ")}`
-    );
+    throw new Error(`${path2} is not UTF-8 text`);
   }
-  return document.toJS();
 }
-function caseFromMarkdown(path2, source) {
+function markdownCase(path2, bytes) {
+  const source = utf8(bytes, path2);
   const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(source);
   if (!match)
-    throw new CliError(
-      "usage",
-      `${path2}: expected YAML frontmatter between --- lines`
+    throw new Error(`${path2}: expected YAML frontmatter between --- lines`);
+  const document = parseDocument(match[1], { uniqueKeys: true });
+  if (document.errors.length)
+    throw new Error(
+      `${path2}: ${document.errors.map((error) => error.message).join("; ")}`
     );
-  const parsed = runDefinitionFrontmatterSchema.safeParse(
-    parseYaml(match[1], path2)
-  );
-  if (!parsed.success)
-    throw new CliError("usage", `${path2}: ${parsed.error.message}`);
+  const parsed = runDefinitionFrontmatterSchema.safeParse(document.toJS());
+  if (!parsed.success) throw new Error(`${path2}: ${parsed.error.message}`);
   const prompt = match[2].trim();
-  if (!prompt) throw new CliError("usage", `${path2}: Markdown body is empty`);
+  if (!prompt) throw new Error(`${path2}: Markdown body is empty`);
   return { path: path2, prompt, ...parsed.data };
 }
-function relativeGitPath(root, cwd, input) {
-  if (!input || input.includes("\0") || /[*?[\]{}]/.test(input))
-    throw new CliError("usage", `expected an explicit case path: ${input}`);
-  const absolute = resolve(cwd, input);
-  const path2 = relative(root, absolute);
-  if (!path2 || path2 === ".." || path2.startsWith(`..${sep}`) || isAbsolute(path2))
-    throw new CliError(
-      "usage",
-      `case path is outside this Git repository: ${input}`
+function compileRunDefinitionFromBlobs(input) {
+  if (!uncredentialedRepoUrlSchema.safeParse(input.repoUrl).success)
+    throw new Error("Git origin must not contain embedded credentials");
+  if (!/^[a-f0-9]{40}$/i.test(input.commit))
+    throw new Error("Expected a full Git commit SHA");
+  if (input.casePaths.length === 0)
+    throw new Error("At least one Markdown case is required");
+  if (new Set(input.casePaths).size !== input.casePaths.length)
+    throw new Error("Case paths must be unique");
+  const configBytes = input.blobs.get("gauge.json");
+  let config;
+  if (configBytes) {
+    try {
+      config = runDefinitionFileConfigSchema.parse(
+        JSON.parse(utf8(configBytes, "gauge.json"))
+      );
+    } catch (error) {
+      throw new Error(
+        `gauge.json: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+  const conventionalPrepare = input.blobs.has(".gauge/prepare.sh");
+  if (config?.product && conventionalPrepare)
+    throw new Error(
+      "gauge.json: product and .gauge/prepare.sh are alternatives"
+    );
+  const prepare = config?.prepare ?? (conventionalPrepare ? "bash .gauge/prepare.sh" : void 0);
+  const preparation = config?.product ?? (prepare ? { run: prepare } : void 0);
+  if (config?.install && !prepare)
+    throw new Error("gauge.json: install requires prepare");
+  if (preparation && !input.repoUrl.startsWith("https://"))
+    throw new Error("Project preparation requires a public HTTPS Git origin");
+  const cases = input.casePaths.map((path2) => {
+    const bytes = input.blobs.get(path2);
+    if (!path2.endsWith(".md") || !bytes)
+      throw new Error(`Missing committed Markdown case: ${path2}`);
+    return markdownCase(path2, bytes);
+  });
+  const hash = createHash2("sha256");
+  hash.update("gauge-run-definition-v1\0");
+  for (const [path2, bytes] of [...input.blobs.entries()].sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    hash.update(path2);
+    hash.update("\0");
+    hash.update(String(bytes.length));
+    hash.update("\0");
+    hash.update(bytes);
+    hash.update("\0");
+  }
+  const submission = runDefinitionSubmissionSchema.parse({
+    version: 1,
+    source: {
+      repoUrl: input.repoUrl,
+      commit: input.commit,
+      digest: `sha256:${hash.digest("hex")}`,
+      verification: input.verification
+    },
+    resources: preparation ? [
+      {
+        name: "project",
+        type: "prepared-directory",
+        source: {
+          type: "git-checkout",
+          repoUrl: input.repoUrl,
+          commit: input.commit
+        },
+        prepare: preparation,
+        ...config?.install ? { install: config.install } : {}
+      }
+    ] : [],
+    cases
+  });
+  return { definition: submission, org: config?.org, github: config?.github };
+}
+
+// src/lib/runDefinitionFiles.ts
+function git(cwd, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "buffer",
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const detail = error && typeof error === "object" && "stderr" in error ? String(error.stderr).trim() : String(error);
+    throw new CliError("usage", `git ${args[0]} failed: ${detail}`);
+  }
+}
+function committedBlob(root, commit, path2) {
+  return git(root, ["show", `${commit}:${path2}`]);
+}
+function relativeGitPath(root, cwd, input) {
+  if (!input || input.includes("\0") || /[*?[\]{}]/.test(input))
+    throw new CliError("usage", `expected an explicit case path: ${input}`);
+  const absolute = resolve(cwd, input);
+  const path2 = relative(root, absolute);
+  if (!path2 || path2 === ".." || path2.startsWith(`..${sep}`) || isAbsolute(path2))
+    throw new CliError(
+      "usage",
+      `case path is outside this Git repository: ${input}`
     );
   const gitPath = path2.split(sep).join("/");
   if (!gitPath.endsWith(".md"))
@@ -6436,83 +6290,34 @@ function loadCommittedRunDefinitionWithContext(files, cwd = process.cwd()) {
   const paths = files.map((file) => relativeGitPath(root, cwd, file));
   if (new Set(paths).size !== paths.length)
     throw new CliError("usage", "case paths must be unique");
-  const blobs = [];
-  let config;
+  const blobs = /* @__PURE__ */ new Map();
   const hasConfig = git(root, ["ls-tree", "--name-only", commit, "--", "gauge.json"]).toString("utf8").trim() === "gauge.json";
   if (hasConfig) {
-    try {
-      const bytes = committedBlob(root, commit, "gauge.json");
-      blobs.push({ path: "gauge.json", bytes });
-      config = runDefinitionFileConfigSchema.parse(
-        JSON.parse(decode(bytes, "gauge.json"))
-      );
-    } catch (error) {
-      throw new CliError(
-        "usage",
-        `gauge.json: ${error instanceof Error ? error.message : error}`
-      );
-    }
+    blobs.set("gauge.json", committedBlob(root, commit, "gauge.json"));
   }
   const hasConventionalPrepare = git(root, ["ls-tree", "--name-only", commit, "--", ".gauge/prepare.sh"]).toString("utf8").trim() === ".gauge/prepare.sh";
   if (hasConventionalPrepare) {
-    blobs.push({
-      path: ".gauge/prepare.sh",
-      bytes: committedBlob(root, commit, ".gauge/prepare.sh")
-    });
-  }
-  if (config?.product && hasConventionalPrepare)
-    throw new CliError(
-      "usage",
-      "gauge.json: product and .gauge/prepare.sh are alternatives"
-    );
-  const prepare = config?.prepare ?? (hasConventionalPrepare ? "bash .gauge/prepare.sh" : void 0);
-  const preparation = config?.product ?? (prepare ? { run: prepare } : void 0);
-  if (config?.install && !prepare)
-    throw new CliError("usage", "gauge.json: install requires prepare");
-  if (preparation && !repoUrl.startsWith("https://"))
-    throw new CliError(
-      "usage",
-      "Project preparation requires a public HTTPS Git origin"
+    blobs.set(
+      ".gauge/prepare.sh",
+      committedBlob(root, commit, ".gauge/prepare.sh")
     );
-  const cases = paths.map((path2) => {
-    const bytes = committedBlob(root, commit, path2);
-    blobs.push({ path: path2, bytes });
-    return caseFromMarkdown(path2, decode(bytes, path2));
-  });
-  const hash = createHash2("sha256");
-  hash.update("gauge-run-definition-v1\0");
-  for (const entry of blobs.sort(
-    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
-  )) {
-    hash.update(entry.path);
-    hash.update("\0");
-    hash.update(String(entry.bytes.length));
-    hash.update("\0");
-    hash.update(entry.bytes);
-    hash.update("\0");
   }
-  const submission = runDefinitionSubmissionSchema.safeParse({
-    version: 1,
-    source: {
+  for (const path2 of paths) blobs.set(path2, committedBlob(root, commit, path2));
+  try {
+    const result = compileRunDefinitionFromBlobs({
       repoUrl,
       commit,
-      digest: `sha256:${hash.digest("hex")}`,
+      casePaths: paths,
+      blobs,
       verification: "SUBMITTED_UNVERIFIED"
-    },
-    resources: preparation ? [
-      {
-        name: "project",
-        type: "prepared-directory",
-        source: { type: "git-checkout", repoUrl, commit },
-        prepare: preparation,
-        ...config?.install ? { install: config.install } : {}
-      }
-    ] : [],
-    cases
-  });
-  if (!submission.success)
-    throw new CliError("usage", submission.error.message);
-  return { definition: submission.data, org: config?.org };
+    });
+    return { definition: result.definition, org: result.org };
+  } catch (error) {
+    throw new CliError(
+      "usage",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
 }
 
 // src/lib/staff.ts
@@ -6744,527 +6549,115 @@ function register11(program2) {
       else console.log(`Updated eval set ${updated.id}`);
     }
   );
-  group.command("rm <id>").description("Delete an eval set (its run history survives)").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    await createClient().delete(
-      `${evalSetsPath(org)}/${encodeURIComponent(id)}`
-    );
-    if (resolveOutput(cmd) !== "json") console.log(`Deleted eval set ${id}`);
-  });
-  group.command("run [id]").description(
-    staffCommandsVisible() ? "Run an eval set now with its stored configuration (superusers run without billing the org by default)" : "Run an eval set now with its stored configuration"
-  ).addOption(
-    new Option2(
-      "--bill-to-org",
-      "bill this run to the org's credits instead (superusers)"
-    ).hideHelp(!staffCommandsVisible())
-  ).option("--files <paths...>", "explicit committed Markdown paths").option("--yes", "skip the confirmation").action(
-    async (id, opts, cmd) => {
-      if (opts.files !== void 0) {
-        if (id !== void 0)
-          throw new CliError(
-            "usage",
-            "pass either an eval ID or --files, not both"
-          );
-        const { definition, org: fileOrg } = loadCommittedRunDefinitionWithContext(opts.files);
-        const org2 = resolveOrg(cmd, fileOrg);
-        await confirmOrAbort("Run these committed eval cases now?", opts.yes);
-        const result2 = await createClient().post(
-          `/api/v1/orgs/${encodeURIComponent(org2)}/run-definitions/run`,
-          definition,
-          opts.billToOrg ? { billToOrg: true } : void 0
-        );
-        if (resolveOutput(cmd) === "json") printJson(result2);
-        else {
-          console.log(
-            `Started ${result2.createdRuns}/${result2.requestedRuns} sessions in request ${result2.runRequestId}`
-          );
-          console.log(`Wait: gauge run-requests wait ${result2.runRequestId}`);
-        }
-        return;
-      }
-      if (id === void 0)
-        throw new CliError("usage", "pass an eval ID or --files <paths...>");
-      const org = resolveOrg(cmd);
-      await confirmOrAbort(
-        "Run this eval's stored configuration now?",
-        opts.yes
-      );
-      const result = await createClient().post(
-        `${evalSetsPath(org)}/${encodeURIComponent(id)}/run`,
-        opts.billToOrg ? { billToOrg: true } : {}
-      );
-      if (resolveOutput(cmd) === "json") printJson(result);
-      else
-        console.log(
-          `Started ${result.runIds.length} run${result.runIds.length === 1 ? "" : "s"} in batch ${result.batchIds[0] ?? ""}`
-        );
-    }
-  );
-  group.command("runs <id>").description("The eval set's run log with per-criterion verdicts").option("--limit <n>", "max runs (default 100)").action(async (id, opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const res = await createClient().get(
-      `${evalSetsPath(org)}/${encodeURIComponent(id)}/runs`,
-      { limit: opts.limit }
-    );
-    if (resolveOutput(cmd) === "json") {
-      printJson(res.items);
-      return;
-    }
-    printItems(
-      res.items.map((r) => ({
-        id: r.id,
-        status: r.status,
-        agent: r.agent,
-        model: r.resolvedModel ?? r.model ?? "",
-        created: r.createdAt,
-        judge: r.judge?.status ?? "-",
-        verdicts: r.criterionResults.length === 0 ? "-" : `${r.criterionResults.filter((c) => c.passed).length}/${r.criterionResults.length} passed`
-      })),
-      "table"
-    );
-  });
-  group.command("tag <id>").description("Replace an eval set's user tags (Surface:* is preserved)").option(
-    "--tag <name>",
-    "tag name, create-on-type (repeatable)",
-    collect,
-    []
-  ).option("--clear", "remove all user tags").action(
-    async (id, opts, cmd) => {
-      const org = resolveOrg(cmd);
-      if (opts.tag.length > 0 && opts.clear)
-        throw new CliError("usage", "--tag and --clear conflict");
-      if (opts.tag.length === 0 && !opts.clear)
-        throw new CliError(
-          "usage",
-          "pass --tag <name> (repeatable) or --clear"
-        );
-      const updated = await createClient().patch(
-        `${evalSetsPath(org)}/${encodeURIComponent(id)}`,
-        { tags: opts.clear ? [] : opts.tag }
-      );
-      if (resolveOutput(cmd) === "json") printJson(updated);
-      else console.log(`Tags: ${updated.tags.join(", ") || "(none)"}`);
-    }
-  );
-}
-
-// 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) {
+  group.command("rm <id>").description("Delete an eval set (its run history survives)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().delete(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}`
+    );
+    if (resolveOutput(cmd) !== "json") console.log(`Deleted eval set ${id}`);
+  });
+  group.command("run [id]").description(
+    staffCommandsVisible() ? "Run an eval set now with its stored configuration (superusers run without billing the org by default)" : "Run an eval set now with its stored configuration"
+  ).addOption(
+    new Option2(
+      "--bill-to-org",
+      "bill this run to the org's credits instead (superusers)"
+    ).hideHelp(!staffCommandsVisible())
+  ).option("--files <paths...>", "explicit committed Markdown paths").option("--yes", "skip the confirmation").action(
+    async (id, opts, cmd) => {
+      if (opts.files !== void 0) {
+        if (id !== void 0)
           throw new CliError(
             "usage",
-            `could not read --edits-file: ${e instanceof Error ? e.message : e}`
+            "pass either an eval ID or --files, not both"
           );
-        }
-        if (!Array.isArray(parsed) || parsed.length === 0)
-          throw new CliError(
-            "usage",
-            "--edits-file must be a non-empty JSON array of {find, replace}"
+        const { definition, org: fileOrg } = loadCommittedRunDefinitionWithContext(opts.files);
+        const org2 = resolveOrg(cmd, fileOrg);
+        await confirmOrAbort("Run these committed eval cases now?", opts.yes);
+        const result2 = await createClient().post(
+          `/api/v1/orgs/${encodeURIComponent(org2)}/run-definitions/run`,
+          definition,
+          opts.billToOrg ? { billToOrg: true } : void 0
+        );
+        if (resolveOutput(cmd) === "json") printJson(result2);
+        else {
+          console.log(
+            `Started ${result2.createdRuns}/${result2.requestedRuns} sessions in request ${result2.runRequestId}`
           );
-        body.edits = parsed;
+          console.log(`Wait: gauge run-requests wait ${result2.runRequestId}`);
+        }
+        return;
       }
-      body.contentType = rewriteContentType(opts.file, opts.contentType);
-      const result = await createClient().put(
-        `${itemPath(org, id)}/variants/${encodeURIComponent(variantId)}/content`,
-        body
+      if (id === void 0)
+        throw new CliError("usage", "pass an eval ID or --files <paths...>");
+      const org = resolveOrg(cmd);
+      await confirmOrAbort(
+        "Run this eval's stored configuration now?",
+        opts.yes
+      );
+      const result = await createClient().post(
+        `${evalSetsPath(org)}/${encodeURIComponent(id)}/run`,
+        opts.billToOrg ? { billToOrg: true } : {}
       );
       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");
-      }
+      else
+        console.log(
+          `Started ${result.runIds.length} run${result.runIds.length === 1 ? "" : "s"} in batch ${result.batchIds[0] ?? ""}`
+        );
     }
   );
-  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) => {
+  group.command("runs <id>").description("The eval set's run log with per-criterion verdicts").option("--limit <n>", "max runs (default 100)").action(async (id, opts, cmd) => {
     const org = resolveOrg(cmd);
-    const result = await createClient().post(
-      `${itemPath(org, id)}/write`,
-      {}
+    const res = await createClient().get(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}/runs`,
+      { limit: opts.limit }
     );
     if (resolveOutput(cmd) === "json") {
-      printJson(result);
+      printJson(res.items);
       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`
+    printItems(
+      res.items.map((r) => ({
+        id: r.id,
+        status: r.status,
+        agent: r.agent,
+        model: r.resolvedModel ?? r.model ?? "",
+        created: r.createdAt,
+        judge: r.judge?.status ?? "-",
+        verdicts: r.criterionResults.length === 0 ? "-" : `${r.criterionResults.filter((c) => c.passed).length}/${r.criterionResults.length} passed`
+      })),
+      "table"
     );
-    printJson(rec);
   });
-  group.command("ship <id> <variantId>").description("Mark a variant as shipped to your live docs").action(
-    async (id, variantId, _o, cmd) => {
+  group.command("tag <id>").description("Replace an eval set's user tags (Surface:* is preserved)").option(
+    "--tag <name>",
+    "tag name, create-on-type (repeatable)",
+    collect,
+    []
+  ).option("--clear", "remove all user tags").action(
+    async (id, opts, cmd) => {
       const org = resolveOrg(cmd);
-      await createClient().post(`${itemPath(org, id)}/ship`, { variantId });
-      if (resolveOutput(cmd) !== "json") console.log("Marked shipped");
+      if (opts.tag.length > 0 && opts.clear)
+        throw new CliError("usage", "--tag and --clear conflict");
+      if (opts.tag.length === 0 && !opts.clear)
+        throw new CliError(
+          "usage",
+          "pass --tag <name> (repeatable) or --clear"
+        );
+      const updated = await createClient().patch(
+        `${evalSetsPath(org)}/${encodeURIComponent(id)}`,
+        { tags: opts.clear ? [] : opts.tag }
+      );
+      if (resolveOutput(cmd) === "json") printJson(updated);
+      else console.log(`Tags: ${updated.tags.join(", ") || "(none)"}`);
     }
   );
-  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";
@@ -7383,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(
@@ -7416,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`;
@@ -7459,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"
@@ -7515,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`;
 }
@@ -7533,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(
@@ -7562,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);
@@ -7693,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);
@@ -7737,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`;
@@ -7745,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);
@@ -7772,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] ?? "";
@@ -7780,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(
@@ -7887,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) {
@@ -7961,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");
   }
@@ -8006,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`);
@@ -8033,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 ? (() => {
@@ -8175,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,
@@ -8204,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(
@@ -8269,6 +7662,18 @@ function printChange(content) {
     console.log(doc.after || "(empty)");
   }
 }
+function printRoundPreview(preview) {
+  for (const trial of preview.trials) {
+    console.log(trial.title);
+    for (const change of trial.changes ?? []) {
+      console.log(`=== ${change.path}`);
+      console.log(change.hunks);
+    }
+    for (const path2 of trial.droppedFiles ?? [])
+      console.log(`  ${path2}: dropped`);
+  }
+  console.log(`previewDigest ${preview.previewDigest}`);
+}
 function printEstimate(e) {
   console.log(
     `plan:      ${e.sampleCount} session${e.sampleCount === 1 ? "" : "s"} per trial \xD7 up to ${e.maxRounds} rounds`
@@ -8316,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"
   );
@@ -8338,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(
@@ -8428,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);
@@ -8452,7 +7857,7 @@ function register19(program2) {
         }
       );
       if (resolveOutput(cmd) === "json") printJson(detail);
-      else printDetail4(detail);
+      else printDetail3(detail);
     }
   );
   addPlanOptions(
@@ -8471,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(
@@ -8486,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,
@@ -8518,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(
@@ -8535,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);
@@ -8559,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)
       });
@@ -8597,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);
@@ -8608,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}.`);
   });
@@ -8620,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);
@@ -8643,8 +8038,8 @@ function register19(program2) {
       const intervalMs = Math.max(interval * 1e3, 2e3);
       let last = "";
       for (; ; ) {
-        const detail = await client.get(itemPath2(org, id));
-        const trials2 = detail.rounds.flatMap((round) => round.trials);
+        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) {
           last = line;
@@ -8653,19 +8048,73 @@ 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);
       }
     }
   );
+  group.command("authoring <id>").description(
+    "What the next round may change: kinds, CLI targets and commands, baseline invocations, revision"
+  ).action(async (id, _opts, cmd) => {
+    printJson(
+      await createClient().get(`${itemPath(resolveOrg(cmd), id)}/authoring`)
+    );
+  });
+  group.command("invocation <id> <invocationId>").description(
+    "One baseline CLI invocation from `authoring`, with its recorded command evidence"
+  ).action(
+    async (id, invocationId, _opts, cmd) => {
+      printJson(
+        await createClient().get(
+          `${itemPath(resolveOrg(cmd), id)}/authoring/target`,
+          { cliInvocationId: invocationId }
+        )
+      );
+    }
+  );
+  group.command("cli-change <id>").description(
+    "Build a CLI_INTERVENTION bundle from {targetId, commandId, selector, operations, shippingIntent}; use the output as intervention.after in a round file. Saves nothing"
+  ).requiredOption("--file <path>", "the change JSON; '-' for stdin").action(async (id, opts, cmd) => {
+    printJson(
+      await createClient().post(
+        `${itemPath(resolveOrg(cmd), id)}/cli-changes`,
+        readObject(opts.file)
+      )
+    );
+  });
+  const round = group.command("round").description(
+    "Preview and save the round waiting to launch. A round file is {revision, trials: [{trial: {title, hypothesis, lever, intervention}, files?}]}; revision comes from `authoring`"
+  );
+  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(
+      `${itemPath(resolveOrg(cmd), id)}/rounds/current/preview`,
+      readObject(opts.file)
+    );
+    if (resolveOutput(cmd) === "json") printJson(preview);
+    else printRoundPreview(preview);
+  });
+  round.command("save <id>").description(
+    "Save a previewed round as drafts, replacing every pending draft. Never launches"
+  ).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(
+        `${itemPath(resolveOrg(cmd), id)}/rounds/current`,
+        { ...readObject(opts.file), previewDigest: opts.digest }
+      );
+      if (resolveOutput(cmd) === "json") printJson(result);
+      else
+        for (const trial of result.trials)
+          console.log(`Saved ${trial.key} "${trial.title}"`);
+    }
+  );
   const trials = group.command("trials").description("List, author, and run trials");
   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");
@@ -8683,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"
@@ -8699,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(
@@ -8732,6 +8181,16 @@ function register19(program2) {
         );
     }
   );
+  trials.command("remove <id> <trialId>").description("Drop one draft trial from the round waiting to launch").option("--yes", "skip the confirmation").action(
+    async (id, trialId, opts, cmd) => {
+      await confirmOrAbort(`Remove draft ${trialId} from ${id}?`, opts.yes);
+      const detail = await createClient().delete(
+        trialPath(resolveOrg(cmd), id, trialId)
+      );
+      if (resolveOutput(cmd) === "json") printJson(detail);
+      else console.log(`Removed ${trialId}.`);
+    }
+  );
   group.command("trial <id> <trialId>").description("One trial by id or key (B0, R1.1, \u2026) with its sessions").action(
     async (id, trialId, _opts, cmd) => {
       const org = resolveOrg(cmd);
@@ -8795,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);
@@ -8806,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}`);
@@ -8820,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)"
   );
@@ -8837,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);
@@ -8913,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);
@@ -8991,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,
@@ -9183,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)"
   );
@@ -9219,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`;
@@ -9227,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,
@@ -9242,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);
@@ -9252,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>",
@@ -9339,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)}`;
@@ -9377,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)}`;
@@ -9398,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 {
@@ -9637,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) => {
@@ -9660,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})`
@@ -9776,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`;
@@ -9838,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);
@@ -9979,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)");
@@ -10012,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(
@@ -10023,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) => ({
@@ -10062,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")
@@ -10094,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)}%`;
@@ -10104,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(
@@ -10166,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);
@@ -10214,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);
@@ -10263,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";
@@ -10295,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,
@@ -10307,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}`);
@@ -10342,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);
@@ -10350,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(
@@ -10619,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 });
@@ -10655,7 +10114,6 @@ for (const group of [
   runs_exports2,
   runRequests_exports2,
   optimizations_exports2,
-  experiments_exports2,
   apply_exports,
   batches_exports,
   brands_exports2,