@withgauge/cli 0.5.0 → 0.6.0

package/dist/index.js

@@ -37,6 +37,8 @@ __export(batteries_exports, {
   batteryPlanSchema: () => batteryPlanSchema,
   batteryPromptSpecSchema: () => batteryPromptSpecSchema,
   batteryScheduleSpecSchema: () => batteryScheduleSpecSchema,
+  batterySkillRefSchema: () => batterySkillRefSchema,
+  batterySkillsSchema: () => batterySkillsSchema,
   batterySpecSchema: () => batterySpecSchema
 });
 import { z as z2 } from "zod";
@@ -52,7 +54,11 @@ var ERROR_CODES = [
   "needs_provider_key",
   "rate_limited",
   "conflict",
-  "internal"
+  "internal",
+  // Recognized by CLI >= 0.6.0 only; the server sends `forbidden` with an
+  // instructive message until the older install base is negligible, because
+  // pre-0.6 clients drop the message on any code outside their enum.
+  "upgrade_required"
 ];
 var errorCodeSchema = z.enum(ERROR_CODES);
 var errorEnvelopeSchema = z.object({
@@ -93,6 +99,11 @@ var batteryLimitsSchema = z2.object({
   wallClockS: z2.number().positive().max(BATTERY_MAX_LIMITS.wallClockS).optional(),
   maxUsd: z2.number().positive().max(BATTERY_MAX_LIMITS.maxUsd).optional()
 });
+var batterySkillRefSchema = z2.string().regex(
+  /^[A-Za-z0-9][A-Za-z0-9._-]*@\S+$/,
+  'skills entries must be "name@label" (a bare name is a search, not a reference)'
+);
+var batterySkillsSchema = z2.array(batterySkillRefSchema);
 var batteryScheduleSpecSchema = z2.object({
   repoUrl: z2.string().nullish(),
   repoRef: z2.string().nullish(),
@@ -104,7 +115,10 @@ var batteryScheduleSpecSchema = z2.object({
   cadence: z2.enum(BATTERY_CADENCES).optional(),
   daysPerWeek: z2.number().int().min(1).max(7).optional(),
   experiment: z2.string().optional(),
-  limits: batteryLimitsSchema.optional()
+  limits: batteryLimitsSchema.optional(),
+  /** ALG-217 — ordered `name@label` skill references staged into this target's
+   *  runs. `cadence: NONE` targets only in v1. */
+  skills: batterySkillsSchema.optional()
 });
 var batteryDefaultsSchema = z2.object({
   isBranded: z2.boolean().optional(),
@@ -114,7 +128,9 @@ var batteryDefaultsSchema = z2.object({
   agents: z2.array(batteryAgentSchema).optional(),
   samplesPerCycle: z2.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),
   cadence: z2.enum(BATTERY_CADENCES).optional(),
-  limits: batteryLimitsSchema.optional()
+  limits: batteryLimitsSchema.optional(),
+  /** ALG-217 — the skill set every target inherits unless it names its own. */
+  skills: batterySkillsSchema.optional()
 });
 var batteryPromptSpecSchema = z2.object({
   /** Idempotency key, unique per org (→ Prompt.externalKey). */
@@ -554,66 +570,227 @@ var cliAuthorizationTokenResponseSchema = z6.object({
   expiresAt: z6.string().nullable()
 });
 
+// ../packages/api-schemas/src/cycles.ts
+import { z as z8 } from "zod";
+
+// ../packages/api-schemas/src/schedules.ts
+import { z as z7 } from "zod";
+var AGENTS = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
+var agentSchema = z7.enum(AGENTS);
+var CADENCES = [
+  "NONE",
+  "DAILY",
+  "WEEKLY",
+  "MONTHLY",
+  "DAYS_PER_WEEK"
+];
+var cadenceSchema = z7.enum(CADENCES);
+var daysPerWeekSchema = z7.number().int().min(1).max(7);
+var scheduleRepoSchema = z7.object({
+  repoUrl: z7.string().nullable(),
+  /** Branch/ref; null = the repo's default branch (always null for greenfield). */
+  repoRef: z7.string().nullable()
+});
+var scheduleAgentConfigSchema = z7.object({
+  agent: agentSchema,
+  models: z7.array(z7.string().min(1)).default([])
+});
+var scheduleAgentConfigInputSchema = z7.object({
+  agent: agentSchema,
+  models: z7.array(z7.string().min(1)).optional(),
+  model: z7.string().min(1).nullish()
+}).transform(({ agent, models, model }) => ({
+  agent,
+  models: models ?? (model ? [model] : [])
+}));
+var scheduleSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  cadence: cadenceSchema,
+  /** Only set when cadence is DAYS_PER_WEEK (1–7). */
+  daysPerWeek: z7.number().int().nullable(),
+  samplesPerCycle: z7.number().int(),
+  /** Authoritative per-agent configuration. */
+  agentConfigs: z7.array(scheduleAgentConfigSchema),
+  /** Deprecated compatibility projection of agentConfigs. */
+  agents: z7.array(agentSchema),
+  /** Deprecated: null for schedules with per-agent pins. */
+  model: z7.string().nullable(),
+  /** Repo targets in stable expansion order; empty = the default scaffold. A
+   *  null-repoUrl entry is greenfield alongside named repos. */
+  repos: z7.array(scheduleRepoSchema),
+  /** Cohort label for experiment analysis; null outside labeled experiments. */
+  experiment: z7.string().nullable(),
+  enabled: z7.boolean(),
+  lastExpandedAt: z7.string().nullable(),
+  /** Membership tag ids — the schedule runs the live union of these tags'
+   *  prompts (resolved at dispatch, not stored). */
+  tagIds: z7.array(z7.string()),
+  tagCount: z7.number().int(),
+  /** Persona matrix (ALG-155): member UserProfile ids, in stable expansion
+   *  order. Empty = the default, unconfigured HaikuJudge (no persona). */
+  profileIds: z7.array(z7.string()),
+  /** ALG-155.1: when profileIds is non-empty, also expand once per (prompt ×
+   *  repo) with no persona alongside the persona batches. Ignored when
+   *  profileIds is empty (always the implicit default judge). */
+  includeDefaultPersona: z7.boolean(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var scheduleListResponseSchema = listResponseSchema(scheduleSchema);
+var scheduleRepoInputSchema = z7.object({
+  /** null/omitted = the greenfield scaffold as an explicit target. */
+  repoUrl: z7.string().min(1).nullish(),
+  repoRef: z7.string().min(1).nullish()
+});
+var createScheduleBodyObject = z7.object({
+  name: z7.string().min(1, "name is required"),
+  cadence: cadenceSchema.default("NONE"),
+  daysPerWeek: daysPerWeekSchema.optional(),
+  samplesPerCycle: z7.number().int().min(1).default(1),
+  /** Preferred paired representation (per-agent model tiers). */
+  agentConfigs: z7.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  /** Legacy shared-model input, accepted during the API transition. */
+  agents: z7.array(agentSchema).min(1, "Select at least one agent").optional(),
+  model: z7.string().min(1).nullish(),
+  /** Repo targets; empty = the default scaffold (greenfield). Add a
+   *  null-repoUrl entry to run greenfield alongside named repos. */
+  repos: z7.array(scheduleRepoInputSchema).default([]),
+  /** Membership tag ids — the schedule runs the live union of these tags'
+   *  prompts (specs/schedules-tags-migration.md). Must belong to the org. */
+  tagIds: z7.array(z7.string().min(1)).default([]),
+  /** Persona matrix (ALG-155): member UserProfile ids. Empty/omitted = the
+   *  default, unconfigured HaikuJudge (no persona). */
+  profileIds: z7.array(z7.string().min(1)).default([]),
+  /** ALG-155.1: also expand once per (prompt × repo) with no persona
+   *  alongside the persona batches, when profileIds is non-empty. Ignored
+   *  when profileIds is empty. */
+  includeDefaultPersona: z7.boolean().default(false),
+  enabled: z7.boolean().default(true)
+});
+var createScheduleBodySchema = createScheduleBodyObject.refine(
+  (body) => body.agentConfigs !== void 0 || body.agents !== void 0,
+  {
+    message: "Select at least one agent (agentConfigs or agents)",
+    path: ["agentConfigs"]
+  }
+);
+var updateScheduleBodySchema = z7.object({
+  name: z7.string().min(1).optional(),
+  cadence: cadenceSchema.optional(),
+  daysPerWeek: daysPerWeekSchema.optional(),
+  samplesPerCycle: z7.number().int().min(1).optional(),
+  /** Full replacement of the enabled agent/model set (per-agent model tiers). */
+  agentConfigs: z7.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  /** Legacy shared-model input, accepted during the API transition. */
+  agents: z7.array(agentSchema).min(1, "Select at least one agent").optional(),
+  model: z7.string().min(1).nullish(),
+  repos: z7.array(scheduleRepoInputSchema).optional(),
+  tagIds: z7.array(z7.string().min(1)).optional(),
+  profileIds: z7.array(z7.string().min(1)).optional(),
+  includeDefaultPersona: z7.boolean().optional(),
+  enabled: z7.boolean().optional()
+});
+var runScheduleResponseSchema = z7.object({
+  batchIds: z7.array(z7.string()),
+  runIds: z7.array(z7.string()),
+  blocked: z7.enum(["insufficient_credits", "needs_provider_key"]).optional(),
+  notReady: z7.array(
+    z7.object({
+      repoUrl: z7.string(),
+      status: z7.enum(["building", "failed", "none"])
+    })
+  ).optional()
+});
+
+// ../packages/api-schemas/src/cycles.ts
+var cycleAgentSchema = z8.object({
+  agent: agentSchema,
+  /** Model pins; empty = the agent's platform default. */
+  models: z8.array(z8.string())
+});
+var cycleSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  cadence: cadenceSchema,
+  samplesPerCycle: z8.number().int(),
+  enabled: z8.boolean(),
+  agents: z8.array(cycleAgentSchema)
+});
+var cycleWithCountsSchema = cycleSchema.extend({
+  evalSetCount: z8.number().int(),
+  visibilityPromptCount: z8.number().int()
+});
+var listCyclesResponseSchema = z8.object({
+  items: z8.array(cycleWithCountsSchema)
+});
+var CYCLE_CADENCES = ["NONE", "DAILY", "WEEKLY", "MONTHLY"];
+var cycleCadenceSchema = z8.enum(CYCLE_CADENCES);
+var updateCycleBodySchema = z8.object({
+  cadence: cycleCadenceSchema,
+  agents: z8.array(agentSchema).min(1)
+});
+
 // ../packages/api-schemas/src/dashboards.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // ../packages/api-schemas/src/query.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // ../packages/api-schemas/src/stats.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 var BRAND_KINDS2 = ["OWNED", "COMPETITOR", "OTHER"];
-var brandKindSchema2 = z7.enum(BRAND_KINDS2);
-var brandRankingSchema = z7.object({
-  rank: z7.number().int(),
-  brandId: z7.string(),
-  brandName: z7.string(),
+var brandKindSchema2 = z9.enum(BRAND_KINDS2);
+var brandRankingSchema = z9.object({
+  rank: z9.number().int(),
+  brandId: z9.string(),
+  brandName: z9.string(),
   kind: brandKindSchema2,
-  installs: z7.number().int(),
-  installRate: z7.number(),
-  mentionRate: z7.number(),
+  installs: z9.number().int(),
+  installRate: z9.number(),
+  mentionRate: z9.number(),
   /** Movement between the two most recent batch windows; null if not ranked in both. */
-  deltaRank: z7.number().int().nullable()
+  deltaRank: z9.number().int().nullable()
 });
-var packageRateSchema = z7.object({
-  ecosystem: z7.string(),
-  name: z7.string(),
-  brandName: z7.string().optional(),
+var packageRateSchema = z9.object({
+  ecosystem: z9.string(),
+  name: z9.string(),
+  brandName: z9.string().optional(),
   kind: brandKindSchema2.optional(),
-  installs: z7.number().int(),
-  rate: z7.number()
+  installs: z9.number().int(),
+  rate: z9.number()
 });
-var brandRateSchema = z7.object({
-  brandId: z7.string(),
-  brandName: z7.string(),
+var brandRateSchema = z9.object({
+  brandId: z9.string(),
+  brandName: z9.string(),
   kind: brandKindSchema2,
-  installs: z7.number().int(),
-  rate: z7.number()
+  installs: z9.number().int(),
+  rate: z9.number()
 });
-var brandFunnelRowSchema = z7.object({
-  brandId: z7.string(),
-  brandName: z7.string(),
+var brandFunnelRowSchema = z9.object({
+  brandId: z9.string(),
+  brandName: z9.string(),
   kind: brandKindSchema2,
-  mentionRate: z7.number(),
-  installRate: z7.number()
-});
-var domainRateSchema = z7.object({
-  domain: z7.string(),
-  runs: z7.number().int(),
-  rate: z7.number(),
-  requests: z7.number().int(),
-  brandName: z7.string().optional(),
-  owned: z7.boolean().optional()
-});
-var statsFreshnessSchema = z7.object({
+  mentionRate: z9.number(),
+  installRate: z9.number()
+});
+var domainRateSchema = z9.object({
+  domain: z9.string(),
+  runs: z9.number().int(),
+  rate: z9.number(),
+  requests: z9.number().int(),
+  brandName: z9.string().optional(),
+  owned: z9.boolean().optional()
+});
+var statsFreshnessSchema = z9.object({
   /** Newest run-ingest time across the org (ISO), or null if nothing ingested. */
-  watermark: z7.string().nullable(),
+  watermark: z9.string().nullable(),
   /** Runs that succeeded recently but haven't landed in the warehouse yet. */
-  pending: z7.number().int(),
+  pending: z9.number().int(),
   /** False when the freshness read itself failed (distinguish from genuine zero). */
-  available: z7.boolean()
+  available: z9.boolean()
 });
-var statsResponseSchema = (item) => z7.object({ items: z7.array(item), freshness: statsFreshnessSchema });
+var statsResponseSchema = (item) => z9.object({ items: z9.array(item), freshness: statsFreshnessSchema });
 var rankingsResponseSchema = statsResponseSchema(brandRankingSchema);
 var installsResponseSchema = statsResponseSchema(packageRateSchema);
 var brandsResponseSchema = statsResponseSchema(brandRateSchema);
@@ -632,7 +809,7 @@ var DATASETS = [
   "tokens",
   "brand_rollup"
 ];
-var datasetSchema = z8.enum(DATASETS);
+var datasetSchema = z10.enum(DATASETS);
 var WHERE_OPS = [
   "eq",
   "neq",
@@ -644,213 +821,320 @@ var WHERE_OPS = [
   "lt",
   "lte"
 ];
-var whereOpSchema = z8.enum(WHERE_OPS);
+var whereOpSchema = z10.enum(WHERE_OPS);
 var GRANULARITIES = ["day", "week", "month"];
-var granularitySchema = z8.enum(GRANULARITIES);
+var granularitySchema = z10.enum(GRANULARITIES);
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_QUERY_LIMIT = 1e3;
-var scalar = z8.union([z8.string(), z8.number(), z8.boolean()]);
-var whereClauseSchema = z8.object({
-  dimension: z8.string().min(1),
+var scalar = z10.union([z10.string(), z10.number(), z10.boolean()]);
+var whereClauseSchema = z10.object({
+  dimension: z10.string().min(1),
   op: whereOpSchema,
-  value: z8.union([scalar, z8.array(scalar)])
-});
-var queryFiltersSchema = z8.object({
-  prompt: z8.string(),
-  topic: z8.array(z8.string()),
-  tag: z8.array(z8.string()),
-  repo: z8.array(z8.string()),
-  language: z8.array(z8.string()),
-  framework: z8.array(z8.string()),
-  size: z8.array(z8.string()),
-  agent: z8.array(z8.string()),
+  value: z10.union([scalar, z10.array(scalar)])
+});
+var queryFiltersSchema = z10.object({
+  prompt: z10.string(),
+  topic: z10.array(z10.string()),
+  tag: z10.array(z10.string()),
+  repo: z10.array(z10.string()),
+  language: z10.array(z10.string()),
+  framework: z10.array(z10.string()),
+  size: z10.array(z10.string()),
+  agent: z10.array(z10.string()),
   /** Persona UserProfile ids; the NO_PERSONA sentinel = default judge. */
-  persona: z8.array(z8.string()),
-  model: z8.array(z8.string()),
-  scenario: z8.array(z8.string()),
-  experiment: z8.array(z8.string()),
-  branded: z8.boolean()
+  persona: z10.array(z10.string()),
+  model: z10.array(z10.string()),
+  scenario: z10.array(z10.string()),
+  experiment: z10.array(z10.string()),
+  branded: z10.boolean()
 }).partial();
-var dateRangeSchema = z8.object({
-  since: z8.string(),
-  until: z8.string(),
-  lastDays: z8.number().int().positive()
+var dateRangeSchema = z10.object({
+  since: z10.string(),
+  until: z10.string(),
+  lastDays: z10.number().int().positive()
 }).partial();
-var orderBySchema = z8.object({
+var orderBySchema = z10.object({
   /** A selected dimension or metric name. */
-  key: z8.string().min(1),
-  dir: z8.enum(["asc", "desc"]).default("desc")
+  key: z10.string().min(1),
+  dir: z10.enum(["asc", "desc"]).default("desc")
 });
-var querySpecSchema = z8.object({
+var querySpecSchema = z10.object({
   dataset: datasetSchema.default("runs"),
-  dimensions: z8.array(z8.string()).default([]),
-  metrics: z8.array(z8.string()).min(1, "at least one metric is required"),
+  dimensions: z10.array(z10.string()).default([]),
+  metrics: z10.array(z10.string()).min(1, "at least one metric is required"),
   filters: queryFiltersSchema.default({}),
-  where: z8.array(whereClauseSchema).default([]),
+  where: z10.array(whereClauseSchema).default([]),
   dateRange: dateRangeSchema.optional(),
-  orderBy: z8.array(orderBySchema).default([]),
-  limit: z8.number().int().min(1).max(MAX_QUERY_LIMIT).default(DEFAULT_QUERY_LIMIT),
+  orderBy: z10.array(orderBySchema).default([]),
+  limit: z10.number().int().min(1).max(MAX_QUERY_LIMIT).default(DEFAULT_QUERY_LIMIT),
   granularity: granularitySchema.default("day"),
   /** When true, the response echoes the compiled SQL (params bound, not inlined). */
-  explain: z8.boolean().default(false)
+  explain: z10.boolean().default(false)
 });
-var columnKindSchema = z8.enum(["dimension", "metric"]);
-var queryColumnSchema = z8.object({
-  key: z8.string(),
+var columnKindSchema = z10.enum(["dimension", "metric"]);
+var queryColumnSchema = z10.object({
+  key: z10.string(),
   kind: columnKindSchema
 });
-var queryRowSchema = z8.record(
-  z8.string(),
-  z8.union([z8.string(), z8.number(), z8.boolean(), z8.null()])
+var queryRowSchema = z10.record(
+  z10.string(),
+  z10.union([z10.string(), z10.number(), z10.boolean(), z10.null()])
 );
-var queryResponseSchema = z8.object({
-  columns: z8.array(queryColumnSchema),
-  rows: z8.array(queryRowSchema),
+var queryResponseSchema = z10.object({
+  columns: z10.array(queryColumnSchema),
+  rows: z10.array(queryRowSchema),
   /** Present only when the request set explain=true. */
-  sql: z8.string().optional(),
+  sql: z10.string().optional(),
   freshness: statsFreshnessSchema
 });
-var fieldTypeSchema = z8.enum([
+var fieldTypeSchema = z10.enum([
   "string",
   "number",
   "rate",
   "date",
   "boolean"
 ]);
-var fieldSchema = z8.object({
-  name: z8.string(),
+var fieldSchema = z10.object({
+  name: z10.string(),
   type: fieldTypeSchema,
   /** One-line human/agent hint. */
-  description: z8.string().optional()
+  description: z10.string().optional()
 });
-var datasetMetaSchema = z8.object({
+var datasetMetaSchema = z10.object({
   name: datasetSchema,
-  grain: z8.string(),
-  dimensions: z8.array(fieldSchema),
-  metrics: z8.array(fieldSchema)
+  grain: z10.string(),
+  dimensions: z10.array(fieldSchema),
+  metrics: z10.array(fieldSchema)
 });
-var metadataResponseSchema = z8.object({
-  datasets: z8.array(datasetMetaSchema)
+var metadataResponseSchema = z10.object({
+  datasets: z10.array(datasetMetaSchema)
 });
 
 // ../packages/api-schemas/src/dashboards.ts
 var VIZ_TYPES = ["line", "bar", "table", "kpi"];
-var vizTypeSchema = z9.enum(VIZ_TYPES);
-var widgetEncodingSchema = z9.object({
-  x: z9.string(),
+var vizTypeSchema = z11.enum(VIZ_TYPES);
+var widgetEncodingSchema = z11.object({
+  x: z11.string(),
   // dimension key for the x axis (line)
-  series: z9.string(),
+  series: z11.string(),
   // dimension key split into one series per value (line)
-  y: z9.array(z9.string())
+  y: z11.array(z11.string())
   // metric keys for the value axis
 }).partial();
 var widgetFields = {
-  id: z9.string().min(1),
-  title: z9.string(),
+  id: z11.string().min(1),
+  title: z11.string(),
   viz: vizTypeSchema,
   spec: querySpecSchema,
   // 12-col grid placement.
-  x: z9.number().int().min(0).max(11),
-  y: z9.number().int().min(0),
-  w: z9.number().int().min(1).max(12),
-  h: z9.number().int().min(1),
+  x: z11.number().int().min(0).max(11),
+  y: z11.number().int().min(0),
+  w: z11.number().int().min(1).max(12),
+  h: z11.number().int().min(1),
   encoding: widgetEncodingSchema.optional()
 };
-var widgetSchema = z9.object(widgetFields).refine((w) => w.x + w.w <= 12, {
+var widgetSchema = z11.object(widgetFields).refine((w) => w.x + w.w <= 12, {
   message: "widget spills past the 12-column grid (x + w must be \u2264 12)"
 });
-var widgetPatchSchema = z9.object(widgetFields).partial();
-var dashboardFiltersSchema = z9.object({
+var widgetPatchSchema = z11.object(widgetFields).partial();
+var dashboardFiltersSchema = z11.object({
   filters: queryFiltersSchema,
   dateRange: dateRangeSchema
 }).partial();
-var overlayPatchSchema = z9.object({
-  name: z9.string(),
+var overlayPatchSchema = z11.object({
+  name: z11.string(),
   defaultFilters: dashboardFiltersSchema,
-  widgets: z9.record(z9.string(), widgetPatchSchema.nullable()),
+  widgets: z11.record(z11.string(), widgetPatchSchema.nullable()),
   // Explicit widget-id ordering (for reordering and from-scratch widgets).
-  order: z9.array(z9.string())
+  order: z11.array(z11.string())
 }).partial();
-var resolvedDashboardSchema = z9.object({
-  key: z9.string(),
-  name: z9.string(),
-  widgets: z9.array(widgetSchema),
+var resolvedDashboardSchema = z11.object({
+  key: z11.string(),
+  name: z11.string(),
+  widgets: z11.array(widgetSchema),
   defaultFilters: dashboardFiltersSchema,
-  hasOrgOverlay: z9.boolean(),
-  hasUserOverlay: z9.boolean()
-});
-var dashboardTemplateSchema = z9.object({
-  key: z9.string().min(1),
-  name: z9.string(),
-  description: z9.string().optional(),
-  widgets: z9.array(widgetSchema),
+  hasOrgOverlay: z11.boolean(),
+  hasUserOverlay: z11.boolean()
+});
+var dashboardTemplateSchema = z11.object({
+  key: z11.string().min(1),
+  name: z11.string(),
+  description: z11.string().optional(),
+  widgets: z11.array(widgetSchema),
   defaultFilters: dashboardFiltersSchema.optional()
 });
-var dashboardSummarySchema = z9.object({
-  key: z9.string(),
-  name: z9.string(),
-  source: z9.enum(["template", "org", "user"]),
-  isUserDefault: z9.boolean(),
-  isOrgDefault: z9.boolean()
+var dashboardSummarySchema = z11.object({
+  key: z11.string(),
+  name: z11.string(),
+  source: z11.enum(["template", "org", "user"]),
+  isUserDefault: z11.boolean(),
+  isOrgDefault: z11.boolean()
 });
 
 // ../packages/api-schemas/src/device.ts
-import { z as z10 } from "zod";
-var deviceAuthorizeRequestSchema = z10.object({
+import { z as z12 } from "zod";
+var deviceAuthorizeRequestSchema = z12.object({
   /** Device label (the CLI's hostname) for display + token naming. */
-  deviceName: z10.string().trim().max(64).optional(),
+  deviceName: z12.string().trim().max(64).optional(),
   /** Optional: email a magic-link that lands on the approval page pre-scoped
    *  to this device (best-effort — the printed URL always works regardless). */
-  email: z10.string().trim().email().max(320).optional()
+  email: z12.string().trim().email().max(320).optional()
 });
-var deviceAuthorizeResponseSchema = z10.object({
+var deviceAuthorizeResponseSchema = z12.object({
   /** The one-time secret the CLI polls with (never shown again). */
-  deviceCode: z10.string(),
+  deviceCode: z12.string(),
   /** Short human-typed code the user confirms in the browser (e.g. WXYZ-1234). */
-  userCode: z10.string(),
+  userCode: z12.string(),
   /** Where the user approves (e.g. https://…/cli/authorize). */
-  verificationUri: z10.string(),
+  verificationUri: z12.string(),
   /** verificationUri with the code pre-filled, for one-click / QR. */
-  verificationUriComplete: z10.string(),
+  verificationUriComplete: z12.string(),
   /** Minimum seconds between polls. */
-  interval: z10.number().int().positive(),
+  interval: z12.number().int().positive(),
   /** Seconds until the device code expires. */
-  expiresIn: z10.number().int().positive(),
+  expiresIn: z12.number().int().positive(),
   /** Whether a magic-link email was dispatched (best-effort). */
-  emailSent: z10.boolean()
+  emailSent: z12.boolean()
 });
-var deviceTokenRequestSchema = z10.object({
-  deviceCode: z10.string().min(1)
+var deviceTokenRequestSchema = z12.object({
+  deviceCode: z12.string().min(1)
 });
-var deviceTokenApprovedSchema = z10.object({
-  status: z10.literal("approved"),
+var deviceTokenApprovedSchema = z12.object({
+  status: z12.literal("approved"),
   /** The `gauge_…` bearer secret. Store it now — never returned again. */
-  accessToken: z10.string(),
-  tokenType: z10.literal("bearer"),
+  accessToken: z12.string(),
+  tokenType: z12.literal("bearer"),
   /** ISO-8601 expiry, or null for no expiry. */
-  expiresAt: z10.string().nullable()
+  expiresAt: z12.string().nullable()
 });
-var deviceTokenResultSchema = z10.discriminatedUnion("status", [
+var deviceTokenResultSchema = z12.discriminatedUnion("status", [
   // Not yet approved — keep polling at `interval`.
-  z10.object({ status: z10.literal("pending") }),
+  z12.object({ status: z12.literal("pending") }),
   // Polled faster than `interval` — back off by `interval` seconds.
-  z10.object({ status: z10.literal("slow_down"), interval: z10.number().int() }),
+  z12.object({ status: z12.literal("slow_down"), interval: z12.number().int() }),
   // The user explicitly denied the request. Stop.
-  z10.object({ status: z10.literal("denied") }),
+  z12.object({ status: z12.literal("denied") }),
   // The device code expired or is unknown/already-redeemed. Stop and restart.
-  z10.object({ status: z10.literal("expired") }),
+  z12.object({ status: z12.literal("expired") }),
   deviceTokenApprovedSchema
 ]);
 
-// ../packages/api-schemas/src/experiments.ts
-import { z as z11 } from "zod";
-var contentExperimentIntentSchema = z11.object({
-  sourceRunId: z11.string().min(1),
-  problemText: z11.string().trim().min(1)
+// ../packages/api-schemas/src/evals.ts
+import { z as z13 } from "zod";
+var criterionSchema = z13.object({
+  id: z13.string(),
+  name: z13.string(),
+  rubric: z13.string(),
+  position: z13.number().int()
+});
+var criterionInputSchema = z13.object({
+  /** Present = update in place; absent = create. */
+  id: z13.string().optional(),
+  name: z13.string().min(1),
+  rubric: z13.string().min(1)
+});
+var evalSetSchema = z13.object({
+  id: z13.string(),
+  name: z13.string(),
+  promptText: z13.string(),
+  /** null = the greenfield scaffold. */
+  repoUrl: z13.string().nullable(),
+  repoRef: z13.string().nullable(),
+  /** Persona judging the runs; null = the default judge. */
+  profile: z13.object({ id: z13.string(), name: z13.string() }).nullable(),
+  enabled: z13.boolean(),
+  createdAt: z13.string(),
+  cycle: cycleSchema,
+  criteria: z13.array(criterionSchema),
+  /** User tag names on the hidden backing prompt (Surface:* excluded). */
+  tags: z13.array(z13.string())
+});
+var agentPassRateSchema = z13.object({
+  agent: agentSchema,
+  model: z13.string(),
+  runId: z13.string(),
+  finishedAt: z13.string().nullable(),
+  passed: z13.number().int(),
+  total: z13.number().int()
+});
+var evalSetStatSchema = z13.object({
+  passRates: z13.array(agentPassRateSchema),
+  runCount: z13.number().int(),
+  /** Run-level aggregate: a run passes only when every criterion passed. */
+  judgedRuns: z13.number().int(),
+  passedRuns: z13.number().int()
+});
+var csv = z13.string().transform(
+  (s) => s.split(",").map((x) => x.trim()).filter(Boolean)
+);
+var listEvalSetsQuerySchema = z13.object({
+  agents: csv.pipe(z13.array(agentSchema)).optional(),
+  models: csv.optional(),
+  since: z13.coerce.date().optional()
+});
+var evalSetListItemSchema = evalSetSchema.extend({
+  stats: evalSetStatSchema
+});
+var listEvalSetsResponseSchema = z13.object({
+  items: z13.array(evalSetListItemSchema)
+});
+var createEvalSetBodySchema = z13.object({
+  name: z13.string().min(1),
+  promptText: z13.string().min(1),
+  /** Omit/null = the greenfield scaffold. */
+  repoUrl: z13.string().nullish(),
+  repoRef: z13.string().nullish(),
+  /** Persona id; must belong to the org. */
+  profileId: z13.string().nullish(),
+  criteria: z13.array(criterionInputSchema).min(1),
+  enabled: z13.boolean().optional(),
+  /** User tag names, create-on-type (Surface:* rejected/dropped). */
+  tags: z13.array(z13.string()).optional()
+});
+var updateEvalSetBodySchema = z13.object({
+  name: z13.string().min(1).optional(),
+  promptText: z13.string().min(1).optional(),
+  repoUrl: z13.string().nullish(),
+  repoRef: z13.string().nullish(),
+  profileId: z13.string().nullish(),
+  criteria: z13.array(criterionInputSchema).min(1).optional(),
+  enabled: z13.boolean().optional(),
+  tags: z13.array(z13.string()).optional()
+});
+var runEvalSetResponseSchema = z13.object({
+  batchId: z13.string(),
+  runIds: z13.array(z13.string())
+});
+var evalSetRunSchema = z13.object({
+  id: z13.string(),
+  status: z13.string(),
+  agent: agentSchema,
+  model: z13.string().nullable(),
+  resolvedModel: z13.string().nullable(),
+  createdAt: z13.string(),
+  startedAt: z13.string().nullable(),
+  finishedAt: z13.string().nullable(),
+  failureReason: z13.string().nullable(),
+  judge: z13.object({ status: z13.string(), error: z13.string().nullable() }).nullable(),
+  criterionResults: z13.array(
+    z13.object({
+      criterionId: z13.string().nullable(),
+      name: z13.string(),
+      passed: z13.boolean(),
+      reasoning: z13.string().nullable()
+    })
+  )
 });
+var listEvalSetRunsResponseSchema = z13.object({
+  items: z13.array(evalSetRunSchema)
+});
+
+// ../packages/api-schemas/src/experiments.ts
+import { z as z14 } from "zod";
 var EXPERIMENT_STATUSES = [
   "DRAFT",
   "GENERATING",
+  "LAUNCHING",
   "RUNNING",
   "SYNTHESIZING",
   "COMPLETE",
@@ -858,135 +1142,194 @@ var EXPERIMENT_STATUSES = [
   "FAILED",
   "CANCELED"
 ];
-var experimentStatusSchema = z11.enum(EXPERIMENT_STATUSES);
-var EXPERIMENT_ORIGINS = ["USER_NAMED", "DETECTED"];
-var experimentOriginSchema = z11.enum(EXPERIMENT_ORIGINS);
-var VARIANT_KINDS = ["CANDIDATE"];
-var variantKindSchema = z11.enum(VARIANT_KINDS);
+var experimentStatusSchema = z14.enum(EXPERIMENT_STATUSES);
 var SUPPORT_CLASSES = [
   "RECOMMENDED",
   "PROMISING",
   "NOT_SUPPORTED",
   "NOT_EVALUABLE"
 ];
-var supportClassSchema = z11.enum(SUPPORT_CLASSES);
-var createExperimentBodySchema = contentExperimentIntentSchema.extend({
-  candidates: z11.number().int().optional(),
-  samples: z11.number().int().optional()
-});
-var launchExperimentBodySchema = z11.object({
-  samples: z11.number().int().optional()
+var supportClassSchema = z14.enum(SUPPORT_CLASSES);
+var jsonValue = z14.unknown();
+var createExperimentBodySchema = z14.object({
+  runId: z14.string().min(1),
+  boundarySeq: z14.string().min(1),
+  problemText: z14.string().trim().min(1).optional()
+});
+var createExperimentResponseSchema = z14.object({
+  experimentId: z14.string(),
+  /** false = an existing draft for this (run, boundary) was resumed. */
+  created: z14.boolean(),
+  /** What is persisted — a resume keeps the statement it was opened with. */
+  problemText: z14.string()
+});
+var experimentListQuerySchema = z14.object({
+  status: z14.string().transform(
+    (s) => s.split(",").map((x) => x.trim().toUpperCase()).filter(Boolean)
+  ).pipe(z14.array(experimentStatusSchema)).optional(),
+  limit: z14.coerce.number().int().min(1).max(100).default(25)
+});
+var experimentSummarySchema = z14.object({
+  id: z14.string(),
+  status: experimentStatusSchema,
+  problem: z14.string(),
+  boundaryUrl: z14.string().nullable(),
+  sourceRunId: z14.string(),
+  variantCount: z14.number().int(),
+  createdAt: z14.string()
 });
-var experimentListQuerySchema = z11.object({
-  status: experimentStatusSchema.optional(),
-  since: z11.string().optional(),
-  limit: z11.coerce.number().int().min(1).max(100).default(50)
+var experimentListResponseSchema = z14.object({
+  items: z14.array(experimentSummarySchema)
 });
-var experimentSummarySchema = z11.object({
-  id: z11.string(),
+var eligibleExperimentRunSchema = z14.object({
+  runId: z14.string(),
+  agent: agentSchema,
+  promptText: z14.string(),
+  createdAt: z14.string(),
+  verdict: z14.string().nullable(),
+  boundaryCount: z14.number().int()
+});
+var experimentBoundarySchema = z14.object({
+  boundarySeq: z14.union([z14.string(), z14.number()]),
+  turn: z14.number().int().nullable(),
+  url: z14.string(),
+  domain: z14.string().nullable(),
+  fetchPrompt: z14.string().nullable(),
+  source: z14.string(),
+  boundaryCheckpointId: z14.string().nullable(),
+  boundaryOrdinal: z14.number().int().nullable(),
+  capturedOccurrence: z14.number().int().nullable()
+});
+var variantRunSchema = z14.object({
+  runId: z14.string(),
+  status: z14.string(),
+  failureReason: z14.string().nullable(),
+  integrations: z14.array(jsonValue)
+});
+var experimentVariantSchema = z14.object({
+  variantId: z14.string(),
+  key: z14.string(),
+  title: z14.string(),
+  hypothesis: z14.string(),
+  rewriteChars: z14.number().int(),
+  hasRewrite: z14.boolean(),
+  invalidReason: z14.string().nullable(),
+  planStatus: z14.string().nullable(),
+  planError: z14.string().nullable(),
+  runs: z14.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 = z14.object({
+  id: z14.string(),
   status: experimentStatusSchema,
-  sourceRunId: z11.string(),
-  problemText: z11.string(),
-  origin: experimentOriginSchema,
-  cohortLabel: z11.string(),
-  createdAt: z11.string()
-});
-var experimentListResponseSchema = listResponseSchema(
-  experimentSummarySchema
-);
-var variantSummarySchema = z11.object({
-  id: z11.string(),
-  key: z11.string(),
-  kind: variantKindSchema,
-  title: z11.string(),
-  hypothesis: z11.string(),
-  supportClass: supportClassSchema.nullable(),
-  effect: z11.number().nullable(),
-  invalidReason: z11.string().nullable(),
-  batchId: z11.string().nullable()
-});
-var variantRefSchema = z11.object({
-  key: z11.string(),
-  title: z11.string(),
-  effect: z11.number().nullable(),
-  consistency: z11.string().nullable(),
-  note: z11.string().nullable()
-});
-var recommendationSchema = z11.object({
-  evaluatorVersion: z11.string(),
-  summary: z11.string(),
-  groups: z11.object({
-    recommended: z11.array(variantRefSchema),
-    promising: z11.array(variantRefSchema),
-    notSupported: z11.array(variantRefSchema),
-    notEvaluable: z11.array(variantRefSchema)
+  problem: z14.string(),
+  boundaryUrl: z14.string().nullable(),
+  createdAt: z14.string(),
+  editable: z14.boolean(),
+  roundInFlight: z14.boolean(),
+  launching: z14.boolean(),
+  launchError: z14.string().nullable(),
+  planned: z14.boolean(),
+  livePage: jsonValue.nullable(),
+  sourceRun: z14.object({
+    runId: z14.string(),
+    agent: agentSchema,
+    status: z14.string(),
+    task: z14.string(),
+    repoUrl: z14.string().nullable(),
+    verdict: jsonValue.nullable(),
+    integrations: z14.array(jsonValue)
   }),
-  tradeoffs: z11.array(z11.string())
+  variants: z14.array(experimentVariantSchema),
+  /** The settled comparison (winners vs baseline) — null until launched. */
+  summary: jsonValue.nullable()
 });
-var jsonValue = z11.unknown();
-var experimentDetailSchema = z11.object({
-  id: z11.string(),
-  status: experimentStatusSchema,
-  sourceRunId: z11.string(),
-  problemText: z11.string(),
-  origin: experimentOriginSchema,
-  evaluationContract: jsonValue,
-  recommendation: recommendationSchema.nullable(),
-  cohortLabel: z11.string(),
-  createdAt: z11.string(),
-  variants: z11.array(variantSummarySchema)
-});
-var createdExperimentSchema = z11.object({
-  id: z11.string(),
+var experimentStatusResponseSchema = z14.object({
+  id: z14.string(),
   status: experimentStatusSchema,
-  cohortLabel: z11.string(),
-  sourceCheckpointId: z11.string().nullable(),
-  checkpointTurn: z11.number().int().nullable(),
-  contract: jsonValue,
-  variants: z11.array(
-    z11.object({
-      id: z11.string(),
-      key: z11.string(),
-      kind: variantKindSchema,
-      invalidReason: z11.string().nullable()
-    })
-  )
-});
-var plannedVariantSchema = z11.object({
-  key: z11.string(),
-  kind: variantKindSchema,
-  title: z11.string(),
-  hypothesis: z11.string(),
-  webFixtureSha256: z11.string(),
-  invalidReason: z11.string().nullable()
-});
-var experimentPlanSchema = z11.object({
-  sourceRunId: z11.string(),
-  organizationId: z11.string(),
-  problemText: z11.string(),
-  origin: experimentOriginSchema,
-  contract: jsonValue,
-  variants: z11.array(plannedVariantSchema),
-  samples: z11.number().int(),
-  estimatedForks: z11.number().int()
-});
-var launchResultSchema = z11.object({
-  experimentId: z11.string(),
-  forks: z11.array(
-    z11.object({
-      variantId: z11.string(),
-      key: z11.string(),
-      batchId: z11.string(),
-      runIds: z11.array(z11.string())
-    })
-  ),
-  skipped: z11.array(
-    z11.object({
-      variantId: z11.string(),
-      key: z11.string(),
-      reason: z11.string()
-    })
-  )
+  planned: z14.boolean(),
+  writeStartedAt: z14.string().nullable(),
+  launchStartedAt: z14.string().nullable(),
+  launchError: z14.string().nullable(),
+  shippedVariantId: z14.string().nullable(),
+  shippedAt: z14.string().nullable()
+});
+var addVariantBodySchema = z14.object({
+  title: z14.string().optional(),
+  hypothesis: z14.string().optional()
+});
+var patchVariantBodySchema = z14.object({
+  title: z14.string().optional(),
+  hypothesis: z14.string().optional()
+});
+var fixerEditSchema = z14.object({
+  find: z14.string().min(1),
+  replace: z14.string()
+});
+var writeVariantContentBodySchema = z14.object({
+  content: z14.string().optional(),
+  edits: z14.array(fixerEditSchema).optional()
+});
+var writeVariantContentResponseSchema = z14.object({
+  variantId: z14.string(),
+  chars: z14.number().int(),
+  truncated: z14.boolean(),
+  applied: z14.number().int(),
+  skipped: z14.number().int()
+});
+var experimentContentQuerySchema = z14.object({
+  variantId: z14.string().optional(),
+  offset: z14.coerce.number().int().min(0).default(0),
+  maxChars: z14.coerce.number().int().min(1).max(4e4).default(2e4)
+});
+var experimentContentResponseSchema = z14.object({
+  source: z14.string(),
+  totalChars: z14.number().int(),
+  offset: z14.number().int(),
+  returnedChars: z14.number().int(),
+  nextOffset: z14.number().int().nullable(),
+  content: z14.string()
+});
+var writeRoundResponseSchema = z14.object({
+  queued: z14.number().int(),
+  reason: z14.enum(["round_in_flight", "nothing_pending"]).optional()
+});
+var launchResultSchema = z14.object({
+  experimentId: z14.string(),
+  status: z14.literal("LAUNCHING")
+});
+var shipBodySchema = z14.object({ variantId: z14.string().min(1) });
+var cancelResponseSchema = z14.object({
+  id: z14.string(),
+  status: z14.literal("CANCELED")
+});
+var variantDeltaSchema = z14.object({
+  changed: z14.boolean().nullable(),
+  hypothesisSupported: z14.enum(["supported", "refuted", "inconclusive"]).nullable(),
+  summary: z14.string().nullable()
+});
+var variantRefSchema = z14.object({
+  key: z14.string(),
+  title: z14.string(),
+  effect: z14.number().nullable(),
+  consistency: z14.string().nullable(),
+  note: z14.string().nullable(),
+  delta: variantDeltaSchema.nullable().optional()
+});
+var recommendationSchema = z14.object({
+  evaluatorVersion: z14.string(),
+  summary: z14.string(),
+  groups: z14.object({
+    recommended: z14.array(variantRefSchema),
+    promising: z14.array(variantRefSchema),
+    notSupported: z14.array(variantRefSchema),
+    notEvaluable: z14.array(variantRefSchema)
+  }),
+  tradeoffs: z14.array(z14.string())
 });
 
 // ../packages/api-schemas/src/keys.ts
@@ -999,222 +1342,92 @@ __export(keys_exports, {
   setProviderKeyBodySchema: () => setProviderKeyBodySchema,
   setProviderKeyResponseSchema: () => setProviderKeyResponseSchema
 });
-import { z as z12 } from "zod";
+import { z as z15 } from "zod";
 var PROVIDER_TYPES = ["anthropic", "openai"];
-var providerTypeSchema = z12.enum(PROVIDER_TYPES);
-var setProviderKeyBodySchema = z12.object({
+var providerTypeSchema = z15.enum(PROVIDER_TYPES);
+var setProviderKeyBodySchema = z15.object({
   /** The raw provider API key. Verified + stored server-side (AWS Secrets
    *  Manager); never persisted in the app DB and never echoed back. */
-  key: z12.string().min(1)
+  key: z15.string().min(1)
 });
-var setProviderKeyResponseSchema = z12.object({
+var setProviderKeyResponseSchema = z15.object({
   providerType: providerTypeSchema,
-  last4: z12.string()
+  last4: z15.string()
 });
-var providerKeySchema = z12.object({
+var providerKeySchema = z15.object({
   providerType: providerTypeSchema,
-  last4: z12.string(),
-  createdAt: z12.string(),
+  last4: z15.string(),
+  createdAt: z15.string(),
   /** When the key was last saved/rotated. */
-  updatedAt: z12.string()
+  updatedAt: z15.string()
 });
 var providerKeyListResponseSchema = listResponseSchema(providerKeySchema);
 
 // ../packages/api-schemas/src/me.ts
-import { z as z13 } from "zod";
-var meUserSchema = z13.object({
-  id: z13.string(),
-  email: z13.string().nullable(),
-  isSuperuser: z13.boolean()
+import { z as z16 } from "zod";
+var meUserSchema = z16.object({
+  id: z16.string(),
+  email: z16.string().nullable(),
+  isSuperuser: z16.boolean()
 });
-var meOrgSchema = z13.object({
-  slug: z13.string(),
+var meOrgSchema = z16.object({
+  slug: z16.string(),
   // Gauge's immutable Organization.public_id; null for LOCAL orgs.
-  publicId: z13.string().nullable(),
-  name: z13.string()
+  publicId: z16.string().nullable(),
+  name: z16.string()
 });
-var meResponseSchema = z13.object({
+var meResponseSchema = z16.object({
   user: meUserSchema,
   // Membership-scoped for normal users; superusers see every org (mirrors the
   // web tier's userOrgs).
-  orgs: z13.array(meOrgSchema)
+  orgs: z16.array(meOrgSchema)
 });
 
 // ../packages/api-schemas/src/orgs.ts
-import { z as z14 } from "zod";
-var createOrgRequestSchema = z14.object({
+import { z as z17 } from "zod";
+var createOrgRequestSchema = z17.object({
   /** Workspace display name; the slug is derived server-side. */
-  name: z14.string().trim().min(1).max(200),
+  name: z17.string().trim().min(1).max(200),
   /** Optional company site (logo source; stamped onto the org). */
-  website: z14.string().trim().max(300).optional()
+  website: z17.string().trim().max(300).optional()
 });
-var createOrgResponseSchema = z14.object({
-  slug: z14.string(),
-  name: z14.string(),
+var createOrgResponseSchema = z17.object({
+  slug: z17.string(),
+  name: z17.string(),
   // LOCAL orgs never have a Gauge publicId.
-  publicId: z14.string().nullable()
+  publicId: z17.string().nullable()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z19 } from "zod";
-
-// ../packages/api-schemas/src/schedules.ts
-import { z as z15 } from "zod";
-var AGENTS = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema = z15.enum(AGENTS);
-var CADENCES = [
-  "NONE",
-  "DAILY",
-  "WEEKLY",
-  "MONTHLY",
-  "DAYS_PER_WEEK"
-];
-var cadenceSchema = z15.enum(CADENCES);
-var daysPerWeekSchema = z15.number().int().min(1).max(7);
-var scheduleRepoSchema = z15.object({
-  repoUrl: z15.string().nullable(),
-  /** Branch/ref; null = the repo's default branch (always null for greenfield). */
-  repoRef: z15.string().nullable()
-});
-var scheduleAgentConfigSchema = z15.object({
-  agent: agentSchema,
-  models: z15.array(z15.string().min(1)).default([])
-});
-var scheduleAgentConfigInputSchema = z15.object({
-  agent: agentSchema,
-  models: z15.array(z15.string().min(1)).optional(),
-  model: z15.string().min(1).nullish()
-}).transform(({ agent, models, model }) => ({
-  agent,
-  models: models ?? (model ? [model] : [])
-}));
-var scheduleSchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  cadence: cadenceSchema,
-  /** Only set when cadence is DAYS_PER_WEEK (1–7). */
-  daysPerWeek: z15.number().int().nullable(),
-  samplesPerCycle: z15.number().int(),
-  /** Authoritative per-agent configuration. */
-  agentConfigs: z15.array(scheduleAgentConfigSchema),
-  /** Deprecated compatibility projection of agentConfigs. */
-  agents: z15.array(agentSchema),
-  /** Deprecated: null for schedules with per-agent pins. */
-  model: z15.string().nullable(),
-  /** Repo targets in stable expansion order; empty = the default scaffold. A
-   *  null-repoUrl entry is greenfield alongside named repos. */
-  repos: z15.array(scheduleRepoSchema),
-  /** Cohort label for experiment analysis; null outside labeled experiments. */
-  experiment: z15.string().nullable(),
-  enabled: z15.boolean(),
-  lastExpandedAt: z15.string().nullable(),
-  /** Membership tag ids — the schedule runs the live union of these tags'
-   *  prompts (resolved at dispatch, not stored). */
-  tagIds: z15.array(z15.string()),
-  tagCount: z15.number().int(),
-  /** Persona matrix (ALG-155): member UserProfile ids, in stable expansion
-   *  order. Empty = the default, unconfigured HaikuJudge (no persona). */
-  profileIds: z15.array(z15.string()),
-  /** ALG-155.1: when profileIds is non-empty, also expand once per (prompt ×
-   *  repo) with no persona alongside the persona batches. Ignored when
-   *  profileIds is empty (always the implicit default judge). */
-  includeDefaultPersona: z15.boolean(),
-  createdAt: z15.string(),
-  updatedAt: z15.string()
-});
-var scheduleListResponseSchema = listResponseSchema(scheduleSchema);
-var scheduleRepoInputSchema = z15.object({
-  /** null/omitted = the greenfield scaffold as an explicit target. */
-  repoUrl: z15.string().min(1).nullish(),
-  repoRef: z15.string().min(1).nullish()
-});
-var createScheduleBodyObject = z15.object({
-  name: z15.string().min(1, "name is required"),
-  cadence: cadenceSchema.default("NONE"),
-  daysPerWeek: daysPerWeekSchema.optional(),
-  samplesPerCycle: z15.number().int().min(1).default(1),
-  /** Preferred paired representation (per-agent model tiers). */
-  agentConfigs: z15.array(scheduleAgentConfigInputSchema).min(1).optional(),
-  /** Legacy shared-model input, accepted during the API transition. */
-  agents: z15.array(agentSchema).min(1, "Select at least one agent").optional(),
-  model: z15.string().min(1).nullish(),
-  /** Repo targets; empty = the default scaffold (greenfield). Add a
-   *  null-repoUrl entry to run greenfield alongside named repos. */
-  repos: z15.array(scheduleRepoInputSchema).default([]),
-  /** Membership tag ids — the schedule runs the live union of these tags'
-   *  prompts (specs/schedules-tags-migration.md). Must belong to the org. */
-  tagIds: z15.array(z15.string().min(1)).default([]),
-  /** Persona matrix (ALG-155): member UserProfile ids. Empty/omitted = the
-   *  default, unconfigured HaikuJudge (no persona). */
-  profileIds: z15.array(z15.string().min(1)).default([]),
-  /** ALG-155.1: also expand once per (prompt × repo) with no persona
-   *  alongside the persona batches, when profileIds is non-empty. Ignored
-   *  when profileIds is empty. */
-  includeDefaultPersona: z15.boolean().default(false),
-  enabled: z15.boolean().default(true)
-});
-var createScheduleBodySchema = createScheduleBodyObject.refine(
-  (body) => body.agentConfigs !== void 0 || body.agents !== void 0,
-  {
-    message: "Select at least one agent (agentConfigs or agents)",
-    path: ["agentConfigs"]
-  }
-);
-var updateScheduleBodySchema = z15.object({
-  name: z15.string().min(1).optional(),
-  cadence: cadenceSchema.optional(),
-  daysPerWeek: daysPerWeekSchema.optional(),
-  samplesPerCycle: z15.number().int().min(1).optional(),
-  /** Full replacement of the enabled agent/model set (per-agent model tiers). */
-  agentConfigs: z15.array(scheduleAgentConfigInputSchema).min(1).optional(),
-  /** Legacy shared-model input, accepted during the API transition. */
-  agents: z15.array(agentSchema).min(1, "Select at least one agent").optional(),
-  model: z15.string().min(1).nullish(),
-  repos: z15.array(scheduleRepoInputSchema).optional(),
-  tagIds: z15.array(z15.string().min(1)).optional(),
-  profileIds: z15.array(z15.string().min(1)).optional(),
-  includeDefaultPersona: z15.boolean().optional(),
-  enabled: z15.boolean().optional()
-});
-var runScheduleResponseSchema = z15.object({
-  batchIds: z15.array(z15.string()),
-  runIds: z15.array(z15.string()),
-  blocked: z15.enum(["insufficient_credits", "needs_provider_key"]).optional(),
-  notReady: z15.array(
-    z15.object({
-      repoUrl: z15.string(),
-      status: z15.enum(["building", "failed", "none"])
-    })
-  ).optional()
-});
+import { z as z21 } from "zod";
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z16 } from "zod";
-var tagSchema = z16.object({
-  id: z16.string(),
-  name: z16.string(),
+import { z as z18 } from "zod";
+var tagSchema = z18.object({
+  id: z18.string(),
+  name: z18.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z16.string()
+  color: z18.string()
 });
-var createTagBodySchema = z16.object({
-  name: z16.string().min(1),
-  color: z16.string().optional()
+var createTagBodySchema = z18.object({
+  name: z18.string().min(1),
+  color: z18.string().optional()
 });
-var updateTagBodySchema = z16.object({
-  name: z16.string().min(1).optional(),
-  color: z16.string().optional()
+var updateTagBodySchema = z18.object({
+  name: z18.string().min(1).optional(),
+  color: z18.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z17 } from "zod";
-var topicSchema = z17.object({
-  id: z17.string(),
-  name: z17.string()
+import { z as z19 } from "zod";
+var topicSchema = z19.object({
+  id: z19.string(),
+  name: z19.string()
 });
-var createTopicBodySchema = z17.object({
-  name: z17.string().min(1, "name is required")
+var createTopicBodySchema = z19.object({
+  name: z19.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
@@ -1224,31 +1437,31 @@ __export(web_fixtures_exports, {
   MAX_WEB_FIXTURE_BYTES: () => MAX_WEB_FIXTURE_BYTES,
   webFixtureSchema: () => webFixtureSchema
 });
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 var MAX_WEB_FIXTURE_BYTES = 1e6;
 function withoutFragment(raw) {
   const fragment = raw.indexOf("#");
   return fragment === -1 ? raw : raw.slice(0, fragment);
 }
-var searchResultSchema = z18.object({
-  title: z18.string().min(1),
-  url: z18.url().transform(withoutFragment),
-  snippet: z18.string()
-});
-var searchFixtureSchema = z18.object({
-  query: z18.string().trim().min(1),
-  results: z18.array(searchResultSchema)
-});
-var pageFixtureSchema = z18.object({
-  url: z18.url().transform(withoutFragment),
-  status: z18.int().min(100).max(599).default(200),
-  contentType: z18.string().trim().min(1).default("text/html"),
-  body: z18.string()
-});
-var webFixtureSchema = z18.object({
-  version: z18.literal(1),
-  searches: z18.array(searchFixtureSchema).default([]),
-  pages: z18.array(pageFixtureSchema).default([])
+var searchResultSchema = z20.object({
+  title: z20.string().min(1),
+  url: z20.url().transform(withoutFragment),
+  snippet: z20.string()
+});
+var searchFixtureSchema = z20.object({
+  query: z20.string().trim().min(1),
+  results: z20.array(searchResultSchema)
+});
+var pageFixtureSchema = z20.object({
+  url: z20.url().transform(withoutFragment),
+  status: z20.int().min(100).max(599).default(200),
+  contentType: z20.string().trim().min(1).default("text/html"),
+  body: z20.string()
+});
+var webFixtureSchema = z20.object({
+  version: z20.literal(1),
+  searches: z20.array(searchFixtureSchema).default([]),
+  pages: z20.array(pageFixtureSchema).default([])
 }).superRefine((fixture, ctx) => {
   const queries = /* @__PURE__ */ new Set();
   fixture.searches.forEach((entry, index) => {
@@ -1282,118 +1495,124 @@ var webFixtureSchema = z18.object({
 });
 
 // ../packages/api-schemas/src/prompts.ts
-var promptSummarySchema = z19.object({
-  id: z19.string(),
-  text: z19.string(),
-  isBranded: z19.boolean(),
+var promptSummarySchema = z21.object({
+  id: z21.string(),
+  text: z21.string(),
+  isBranded: z21.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z19.string().nullable(),
+  externalKey: z21.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z19.array(tagSchema),
-  scheduleCount: z19.number().int(),
-  createdAt: z19.string()
+  tags: z21.array(tagSchema),
+  scheduleCount: z21.number().int(),
+  createdAt: z21.string()
 });
-var promptScheduleRefSchema = z19.object({
-  id: z19.string(),
-  name: z19.string(),
+var promptScheduleRefSchema = z21.object({
+  id: z21.string(),
+  name: z21.string(),
   cadence: cadenceSchema,
-  daysPerWeek: z19.number().int().nullable(),
-  enabled: z19.boolean()
+  daysPerWeek: z21.number().int().nullable(),
+  enabled: z21.boolean()
 });
 var promptDetailSchema = promptSummarySchema.extend({
-  schedules: z19.array(promptScheduleRefSchema)
+  schedules: z21.array(promptScheduleRefSchema)
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z19.string().min(1).optional(),
-  tag: z19.string().min(1).optional(),
-  q: z19.string().min(1).optional()
-});
-var createPromptBodySchema = z19.object({
-  text: z19.string().min(1, "text is required"),
-  isBranded: z19.boolean().default(false),
-  topic: z19.string().min(1).optional(),
-  tags: z19.array(z19.string().min(1)).default([])
-});
-var updatePromptBodySchema = z19.object({
-  text: z19.string().min(1).optional(),
-  isBranded: z19.boolean().optional(),
-  topicId: z19.string().min(1).nullish(),
-  tags: z19.array(z19.string().min(1)).optional()
-});
-var runPromptBodySchema = z19.object({
+  topic: z21.string().min(1).optional(),
+  tag: z21.string().min(1).optional(),
+  q: z21.string().min(1).optional()
+});
+var createPromptBodySchema = z21.object({
+  text: z21.string().min(1, "text is required"),
+  isBranded: z21.boolean().default(false),
+  topic: z21.string().min(1).optional(),
+  tags: z21.array(z21.string().min(1)).default([])
+});
+var updatePromptBodySchema = z21.object({
+  text: z21.string().min(1).optional(),
+  isBranded: z21.boolean().optional(),
+  topicId: z21.string().min(1).nullish(),
+  tags: z21.array(z21.string().min(1)).optional()
+});
+var runPromptBodySchema = z21.object({
   /** Preferred paired representation; each agent may pin its own model tiers. */
-  agentConfigs: z19.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  agentConfigs: z21.array(scheduleAgentConfigInputSchema).min(1).optional(),
   /** Legacy agent set (no per-agent pins), kept during the API transition. */
-  agents: z19.array(agentSchema).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
-  repoUrl: z19.string().min(1).nullish(),
-  repoRef: z19.string().min(1).nullish(),
-  samplesPerCycle: z19.number().int().min(1).max(10).default(1),
-  webFixture: webFixtureSchema.optional()
-});
-var runPromptResponseSchema = z19.object({
-  batchIds: z19.array(z19.string()),
-  runIds: z19.array(z19.string()),
-  blocked: z19.enum(["insufficient_credits", "needs_provider_key"]).optional()
+  agents: z21.array(agentSchema).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z21.string().min(1).nullish(),
+  repoRef: z21.string().min(1).nullish(),
+  samplesPerCycle: z21.number().int().min(1).max(10).default(1),
+  webFixture: webFixtureSchema.optional(),
+  /** Ordered `name@label` skill references (ALG-311 §6.7) — the SAME schema the
+   *  battery spec uses, so the bare-name refusal and the comma rule are shared,
+   *  not restated. One ordered set per launch (never a matrix dimension);
+   *  resolution against the org's pushed versions happens in `runPrompt`, where
+   *  an unresolvable reference is a 400 at launch. Empty/omitted = no skills. */
+  skills: batterySkillsSchema.optional()
+});
+var runPromptResponseSchema = z21.object({
+  batchIds: z21.array(z21.string()),
+  runIds: z21.array(z21.string()),
+  blocked: z21.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z20.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z20.object({
-  url: z20.string(),
-  name: z20.string(),
-  isSystem: z20.boolean(),
-  languages: z20.array(z20.string()),
-  frameworks: z20.array(z20.string()),
+var repoSizeBucketSchema = z22.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z22.object({
+  url: z22.string(),
+  name: z22.string(),
+  isSystem: z22.boolean(),
+  languages: z22.array(z22.string()),
+  frameworks: z22.array(z22.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z20.array(z20.string()),
-  primaryLanguage: z20.string(),
-  sizeKb: z20.number(),
+  tags: z22.array(z22.string()),
+  primaryLanguage: z22.string(),
+  sizeKb: z22.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z20.number()
+  stars: z22.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z20.object({
-  url: z20.string().min(1, "url is required"),
+var addRepoBodySchema = z22.object({
+  url: z22.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: z20.string().min(1).optional(),
+  ref: z22.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z20.string().min(1).optional(),
+  name: z22.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z20.array(z20.string()).optional(),
-  tags: z20.array(z20.string()).optional()
+  frameworks: z22.array(z22.string()).optional(),
+  tags: z22.array(z22.string()).optional()
 });
-var updateRepoBodySchema = z20.object({
-  url: z20.string().min(1, "url is required"),
-  name: z20.string().min(1).optional(),
-  frameworks: z20.array(z20.string()).optional(),
-  tags: z20.array(z20.string()).optional()
+var updateRepoBodySchema = z22.object({
+  url: z22.string().min(1, "url is required"),
+  name: z22.string().min(1).optional(),
+  frameworks: z22.array(z22.string()).optional(),
+  tags: z22.array(z22.string()).optional()
 });
-var resyncRepoBodySchema = z20.object({
-  url: z20.string().min(1, "url is required")
+var resyncRepoBodySchema = z22.object({
+  url: z22.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z20.object({
-  url: z20.string().min(1, "url is required")
+var deleteRepoQuerySchema = z22.object({
+  url: z22.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z20.object({
+var repoSyncResultSchema = z22.object({
   repo: repoSchema,
-  synced: z20.boolean()
+  synced: z22.boolean()
 });
 
 // ../packages/api-schemas/src/runs.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 var RUN_STATUSES = [
   "QUEUED",
   "CLAIMED",
@@ -1404,104 +1623,115 @@ var RUN_STATUSES = [
   "TIMED_OUT",
   "CANCELED"
 ];
-var runStatusSchema = z21.enum(RUN_STATUSES);
+var runStatusSchema = z23.enum(RUN_STATUSES);
 var AGENTS2 = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema2 = z21.enum(AGENTS2);
-var runStatusFilterSchema = z21.string().transform(
+var agentSchema2 = z23.enum(AGENTS2);
+var runStatusFilterSchema = z23.string().transform(
   (raw) => raw.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean)
-).pipe(z21.array(runStatusSchema).min(1));
+).pipe(z23.array(runStatusSchema).min(1));
 var runListQuerySchema = listQuerySchema.extend({
   status: runStatusFilterSchema.optional(),
-  batch: z21.string().optional(),
-  prompt: z21.string().optional(),
-  experiment: z21.string().optional(),
-  since: z21.string().optional()
+  batch: z23.string().optional(),
+  prompt: z23.string().optional(),
+  experiment: z23.string().optional(),
+  since: z23.string().optional()
 });
-var runListItemSchema = z21.object({
-  id: z21.string(),
+var runListItemSchema = z23.object({
+  id: z23.string(),
   status: runStatusSchema,
   agent: agentSchema2,
-  model: z21.string(),
-  promptId: z21.string(),
+  model: z23.string(),
+  promptId: z23.string(),
   /** First ~80 chars of the batch's prompt snapshot, whitespace-collapsed. */
-  promptSnippet: z21.string(),
-  batchId: z21.string(),
-  experiment: z21.string().nullable(),
-  turns: z21.number().int().nullable(),
-  usdCost: z21.number().nullable(),
-  durationMs: z21.number().int().nullable(),
-  exitReason: z21.string().nullable(),
-  createdAt: z21.string(),
-  startedAt: z21.string().nullable(),
-  finishedAt: z21.string().nullable(),
+  promptSnippet: z23.string(),
+  batchId: z23.string(),
+  experiment: z23.string().nullable(),
+  turns: z23.number().int().nullable(),
+  usdCost: z23.number().nullable(),
+  durationMs: z23.number().int().nullable(),
+  exitReason: z23.string().nullable(),
+  createdAt: z23.string(),
+  startedAt: z23.string().nullable(),
+  finishedAt: z23.string().nullable(),
   /** Fork lineage (fork-simulations WS1): the source run this was forked from,
    *  or null for an organic run. Forks are excluded from aggregate analytics but
    *  kept visible; consumers badge on these fields. */
-  parentRunId: z21.string().nullable(),
+  parentRunId: z23.string().nullable(),
   /** Set when this run is a fetch-fork simulation variant (injected web
    *  content); null otherwise. Distinguishes a "Simulation" badge from a plain
    *  conversation fork. */
-  fetchForkPlanId: z21.string().nullable()
+  fetchForkPlanId: z23.string().nullable()
 });
 var runListResponseSchema = listResponseSchema(runListItemSchema);
 var runDetailSchema = runListItemSchema.omit({ promptSnippet: true }).extend({
-  promptText: z21.string(),
-  attempt: z21.number().int(),
-  cancelRequested: z21.boolean(),
-  failureReason: z21.string().nullable(),
-  repoUrl: z21.string().nullable(),
-  repoRef: z21.string().nullable(),
-  scenario: z21.string(),
-  funding: z21.string(),
+  promptText: z23.string(),
+  attempt: z23.number().int(),
+  cancelRequested: z23.boolean(),
+  failureReason: z23.string().nullable(),
+  repoUrl: z23.string().nullable(),
+  repoRef: z23.string().nullable(),
+  scenario: z23.string(),
+  funding: z23.string(),
   /** Raw harness usage write-back (token counts etc.); shape may evolve. */
-  usage: z21.unknown().nullable(),
+  usage: z23.unknown().nullable(),
   /** Artifact pointer: a working-tree diff exists at GET /runs/{id}/diff. */
-  hasDiff: z21.boolean(),
-  claimedAt: z21.string().nullable()
+  hasDiff: z23.boolean(),
+  claimedAt: z23.string().nullable(),
+  /** Judged criteria verdicts for eval-set runs (empty otherwise). `name`
+   *  is the judge-time snapshot; `criterionId` is null once the criterion
+   *  was deleted from its set. */
+  criterionResults: z23.array(
+    z23.object({
+      criterionId: z23.string().nullable(),
+      name: z23.string(),
+      passed: z23.boolean(),
+      reasoning: z23.string().nullable()
+    })
+  )
 });
-var cancelRunResponseSchema = z21.object({
-  id: z21.string(),
+var cancelRunResponseSchema = z23.object({
+  id: z23.string(),
   status: runStatusSchema,
-  cancelRequested: z21.boolean(),
-  note: z21.string().optional()
+  cancelRequested: z23.boolean(),
+  note: z23.string().optional()
 });
-var forkRunBodySchema = z21.object({
-  prompt: z21.string().trim().min(1).max(2e4),
-  turn: z21.number().int().min(0).optional(),
+var forkRunBodySchema = z23.object({
+  prompt: z23.string().trim().min(1).max(2e4),
+  turn: z23.number().int().min(0).optional(),
   webFixture: webFixtureSchema.optional()
 });
-var forkRunResponseSchema = z21.object({
-  runId: z21.string(),
-  batchId: z21.string(),
-  parentRunId: z21.string(),
-  checkpointId: z21.string(),
-  turn: z21.number().int().min(0)
+var forkRunResponseSchema = z23.object({
+  runId: z23.string(),
+  batchId: z23.string(),
+  parentRunId: z23.string(),
+  checkpointId: z23.string(),
+  turn: z23.number().int().min(0)
 });
-var fetchForkAtFetchBodySchema = z21.object({
-  boundarySeq: z21.string().min(1),
-  injectedContent: z21.string(),
-  prompts: z21.array(z21.string()).min(1)
+var fetchForkAtFetchBodySchema = z23.object({
+  boundarySeq: z23.string().min(1),
+  injectedContent: z23.string(),
+  prompts: z23.array(z23.string()).min(1)
 });
-var fetchForkAtFetchResponseSchema = z21.object({
-  planId: z21.string()
+var fetchForkAtFetchResponseSchema = z23.object({
+  planId: z23.string()
 });
-var fetchForkPlanStatusSchema = z21.enum([
+var fetchForkPlanStatusSchema = z23.enum([
   "DRAFT",
   "SURGERY_RUNNING",
   "SURGERY_READY",
   "FORKED",
   "FAILED"
 ]);
-var fetchForkPlanResponseSchema = z21.object({
-  id: z21.string(),
+var fetchForkPlanResponseSchema = z23.object({
+  id: z23.string(),
   status: fetchForkPlanStatusSchema,
-  boundaryUrl: z21.string(),
-  boundaryTurn: z21.number().int(),
-  prompts: z21.array(z21.string()),
-  surgicalCheckpointId: z21.string().nullable(),
-  forkBatchId: z21.string().nullable(),
-  errorText: z21.string().nullable(),
-  forkedRunIds: z21.array(z21.string())
+  boundaryUrl: z23.string(),
+  boundaryTurn: z23.number().int(),
+  prompts: z23.array(z23.string()),
+  surgicalCheckpointId: z23.string().nullable(),
+  forkBatchId: z23.string().nullable(),
+  errorText: z23.string().nullable(),
+  forkedRunIds: z23.array(z23.string())
 });
 var RUN_INSIGHT_STATUSES = [
   "PENDING",
@@ -1510,72 +1740,212 @@ var RUN_INSIGHT_STATUSES = [
   "FAILED",
   "SKIPPED"
 ];
-var runInsightStatusSchema = z21.enum(RUN_INSIGHT_STATUSES);
-var insightPassSchema = z21.object({
+var runInsightStatusSchema = z23.enum(RUN_INSIGHT_STATUSES);
+var insightPassSchema = z23.object({
   status: runInsightStatusSchema,
-  model: z21.string().nullable(),
-  inputTokens: z21.number().int().nullable(),
-  outputTokens: z21.number().int().nullable(),
-  usdCost: z21.number().nullable(),
-  error: z21.string().nullable()
-});
-var runDecisionSchema = z21.object({
-  index: z21.number().int(),
-  category: z21.string(),
-  categoryRaw: z21.string().nullable(),
-  chosenName: z21.string(),
-  chosenEcosystem: z21.string().nullable(),
-  chosenPackage: z21.string().nullable(),
-  reversed: z21.boolean(),
-  detail: z21.unknown()
-});
-var runImplementationSchema = z21.object({
-  brandName: z21.string(),
-  ecosystem: z21.string().nullable(),
-  package: z21.string().nullable(),
-  verdict: z21.string(),
-  docConsulted: z21.boolean(),
-  detail: z21.unknown()
-});
-var runInsightResponseSchema = z21.object({
-  runId: z21.string(),
+  model: z23.string().nullable(),
+  inputTokens: z23.number().int().nullable(),
+  outputTokens: z23.number().int().nullable(),
+  usdCost: z23.number().nullable(),
+  error: z23.string().nullable()
+});
+var runDecisionSchema = z23.object({
+  index: z23.number().int(),
+  category: z23.string(),
+  categoryRaw: z23.string().nullable(),
+  chosenName: z23.string(),
+  chosenEcosystem: z23.string().nullable(),
+  chosenPackage: z23.string().nullable(),
+  reversed: z23.boolean(),
+  detail: z23.unknown()
+});
+var runImplementationSchema = z23.object({
+  brandName: z23.string(),
+  ecosystem: z23.string().nullable(),
+  package: z23.string().nullable(),
+  verdict: z23.string(),
+  docConsulted: z23.boolean(),
+  detail: z23.unknown()
+});
+var RUN_INSIGHT_PASS_KINDS = [
+  "INSTALL",
+  "DECISION",
+  "EVAL",
+  "INTEGRATION",
+  "EXPERIMENT_DELTA",
+  "VISIBILITY"
+];
+var runInsightPassKindSchema = z23.enum(RUN_INSIGHT_PASS_KINDS);
+var insightPipelinePassSchema = insightPassSchema.extend({
+  kind: runInsightPassKindSchema
+});
+var runInsightResponseSchema = z23.object({
+  runId: z23.string(),
   decision: insightPassSchema,
   implementation: insightPassSchema,
-  decisions: z21.array(runDecisionSchema),
-  implementations: z21.array(runImplementationSchema)
+  passes: z23.array(insightPipelinePassSchema),
+  decisions: z23.array(runDecisionSchema),
+  implementations: z23.array(runImplementationSchema),
+  experimentDelta: z23.unknown().nullable(),
+  /** The VISIBILITY pass's output (winners/picks) — loose server JSON, null
+   *  for non-visibility runs or before the pass completes. */
+  visibilityVerdict: z23.unknown().nullable()
+});
+var runEventSchema = z23.looseObject({
+  run_id: z23.string(),
+  seq: z23.number(),
+  turn: z23.number(),
+  ts: z23.string(),
+  type: z23.string()
 });
-var runEventSchema = z21.looseObject({
-  run_id: z21.string(),
-  seq: z21.number(),
-  turn: z21.number(),
-  ts: z21.string(),
-  type: z21.string()
+
+// ../packages/api-schemas/src/skills.ts
+import { z as z24 } from "zod";
+var sha256Hex = sha256DigestSchema;
+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: z24.string().min(1),
+  contentDigest: sha256Hex,
+  blobDigest: sha256Hex,
+  /** `cas/v2/<scope>/skills/sha256/<ab>/<blobDigest>.tar.zst`. */
+  blobKey: z24.string().min(1),
+  /** Raw canonical-tar size. Bounds the decompression allocation when present. */
+  rawBytes: z24.number().int().positive().optional(),
+  /** Stored compressed size, verified against the object when present. */
+  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: z24.record(z24.string(), z24.unknown()).optional()
 });
+var MAX_SKILL_SET_ENTRIES = 32;
+var skillSetSchema = z24.array(skillSetEntrySchema).max(
+  MAX_SKILL_SET_ENTRIES,
+  `a run may stage at most ${MAX_SKILL_SET_ENTRIES} skills`
+);
 
 // ../packages/api-schemas/src/tokens.ts
-import { z as z22 } from "zod";
-var apiTokenSchema = z22.object({
-  id: z22.string(),
-  name: z22.string(),
+import { z as z25 } from "zod";
+var apiTokenSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z22.string(),
-  expiresAt: z22.iso.datetime().nullable(),
-  lastUsedAt: z22.iso.datetime().nullable(),
-  createdAt: z22.iso.datetime(),
-  revokedAt: z22.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z22.object({
-  name: z22.string().min(1).max(100),
+  last4: z25.string(),
+  expiresAt: z25.iso.datetime().nullable(),
+  lastUsedAt: z25.iso.datetime().nullable(),
+  createdAt: z25.iso.datetime(),
+  revokedAt: z25.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z25.object({
+  name: z25.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z22.iso.datetime({ offset: true }).optional()
+  expiresAt: z25.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z22.string()
+  token: z25.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
+// ../packages/api-schemas/src/visibility.ts
+import { z as z26 } from "zod";
+var VISIBILITY_PROMPT_KINDS = ["HEAD_TO_HEAD", "RECOMMEND"];
+var visibilityPromptKindSchema = z26.enum(VISIBILITY_PROMPT_KINDS);
+var visibilityPromptSchema = z26.object({
+  id: z26.string(),
+  kind: visibilityPromptKindSchema,
+  promptText: z26.string(),
+  /** HEAD_TO_HEAD is always branded; RECOMMEND may be either. */
+  branded: z26.boolean(),
+  brandA: z26.string().nullable(),
+  brandB: z26.string().nullable(),
+  /** null = the greenfield scaffold. */
+  repoUrl: z26.string().nullable(),
+  repoRef: z26.string().nullable(),
+  market: z26.object({ id: z26.string(), slug: z26.string(), name: z26.string() }).nullable(),
+  position: z26.number().int(),
+  enabled: z26.boolean(),
+  createdAt: z26.string(),
+  cycle: cycleSchema,
+  /** User tag names on the hidden backing prompt (Surface:* excluded). */
+  tags: z26.array(z26.string()),
+  runCount: z26.number().int(),
+  lastRunAt: z26.string().nullable()
+});
+var listVisibilityPromptsResponseSchema = z26.object({
+  items: z26.array(visibilityPromptSchema)
+});
+var createVisibilityPromptBodySchema = z26.object({
+  promptText: z26.string().min(1),
+  kind: visibilityPromptKindSchema,
+  branded: z26.boolean().optional(),
+  /** Required pair for HEAD_TO_HEAD (order-independent). */
+  brandA: z26.string().nullish(),
+  brandB: z26.string().nullish(),
+  repoUrl: z26.string().nullish(),
+  repoRef: z26.string().nullish(),
+  /** Measured market id from the org's tracked set. */
+  marketId: z26.string().nullish(),
+  enabled: z26.boolean().optional(),
+  tags: z26.array(z26.string()).optional()
+});
+var updateVisibilityPromptBodySchema = z26.object({
+  promptText: z26.string().min(1).optional(),
+  branded: z26.boolean().optional(),
+  brandA: z26.string().nullish(),
+  brandB: z26.string().nullish(),
+  repoUrl: z26.string().nullish(),
+  repoRef: z26.string().nullish(),
+  marketId: z26.string().nullish(),
+  enabled: z26.boolean().optional(),
+  tags: z26.array(z26.string()).optional()
+});
+var runVisibilityPromptResponseSchema = z26.object({
+  batchIds: z26.array(z26.string()),
+  runIds: z26.array(z26.string())
+});
+var visibilityPromptRunSchema = z26.object({
+  id: z26.string(),
+  status: z26.string(),
+  agent: agentSchema,
+  model: z26.string().nullable(),
+  resolvedModel: z26.string().nullable(),
+  createdAt: z26.string(),
+  startedAt: z26.string().nullable(),
+  finishedAt: z26.string().nullable(),
+  failureReason: z26.string().nullable(),
+  verdict: z26.object({
+    status: z26.string(),
+    error: z26.string().nullable(),
+    payload: z26.unknown().nullable()
+  }).nullable()
+});
+var listVisibilityPromptRunsResponseSchema = z26.object({
+  items: z26.array(visibilityPromptRunSchema)
+});
+var orgMarketSchema = z26.object({
+  marketId: z26.string(),
+  slug: z26.string(),
+  name: z26.string(),
+  /** The one line saying what the market measures. */
+  capability: z26.string(),
+  /** SUGGESTED (the matcher) | USER (a human picked it). */
+  source: z26.string()
+});
+var addableMarketSchema = orgMarketSchema.omit({ source: true });
+var listMarketsResponseSchema = z26.object({
+  tracked: z26.array(orgMarketSchema),
+  /** Published markets the org does not track yet (closed set — no free-text
+   *  market creation). */
+  addable: z26.array(addableMarketSchema)
+});
+var addMarketBodySchema = z26.object({ marketId: z26.string().min(1) });
+
 // src/commands/apply.ts
-import { z as z23 } from "zod";
+import { z as z27 } from "zod";
 
 // src/version.ts
 import { createRequire } from "module";
@@ -2023,7 +2393,7 @@ function register(program2) {
   ).option("-f, --file <path>", "battery spec JSON file").option("--dry-run", "print the plan without applying").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(z23.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z27.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -2110,6 +2480,7 @@ function printIdentity(me) {
   const su = me.user.isSuperuser ? " (superuser)" : "";
   console.log(`Logged in as ${me.user.email ?? me.user.id}${su}`);
   console.log(`Orgs: ${orgs}`);
+  console.log(`API URL: ${resolveBaseUrl()}`);
 }
 function openBrowser(url) {
   const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
@@ -2408,7 +2779,7 @@ function parseExpiresIn(raw) {
 async function whoami(output) {
   const me = await fetchMe(createClient());
   if (output === "json") {
-    printJson(me);
+    printJson({ apiUrl: resolveBaseUrl(), ...me });
     return;
   }
   printIdentity(me);
@@ -2475,7 +2846,12 @@ function register2(program2) {
       throw e;
     }
     if (output === "json") {
-      printJson({ authenticated: true, source, ...me });
+      printJson({
+        authenticated: true,
+        source,
+        apiUrl: resolveBaseUrl(),
+        ...me
+      });
       return;
     }
     printIdentity(me);
@@ -2828,252 +3204,11 @@ function register6(program2) {
   });
 }
 
-// src/commands/keys.ts
-var keys_exports2 = {};
-__export(keys_exports2, {
-  register: () => register7
+// src/commands/cycles.ts
+var cycles_exports2 = {};
+__export(cycles_exports2, {
+  register: () => register8
 });
-function keysPath(org) {
-  return `/api/v1/orgs/${encodeURIComponent(org)}/provider-keys`;
-}
-function providerArg(raw) {
-  const provider = raw.toLowerCase();
-  if (!keys_exports.PROVIDER_TYPES.includes(provider)) {
-    throw new CliError(
-      "usage",
-      `Unknown provider "${raw}" (expected ${keys_exports.PROVIDER_TYPES.join("|")})`
-    );
-  }
-  return provider;
-}
-async function readKeyInput(opts) {
-  if (opts.key !== void 0) {
-    process.stderr.write(
-      "warning: --key exposes the secret to shell history and process listings; prefer piping it to stdin or setting GAUGE_PROVIDER_KEY.\n"
-    );
-    const key2 = opts.key.trim();
-    if (key2) return key2;
-    throw new CliError("usage", "Empty --key value");
-  }
-  if (!opts.stdin) {
-    const env = process.env.GAUGE_PROVIDER_KEY?.trim();
-    if (env) return env;
-  }
-  if (process.stdin.isTTY) {
-    process.stderr.write("Paste the API key, press Enter, then Ctrl-D:\n");
-  }
-  process.stdin.setEncoding("utf8");
-  let data = "";
-  for await (const chunk of process.stdin) data += chunk;
-  const key = data.trim();
-  if (!key) {
-    throw new CliError(
-      "usage",
-      "No key provided. Pipe it to stdin (e.g. `gauge keys set anthropic < key.txt`) or set GAUGE_PROVIDER_KEY."
-    );
-  }
-  return key;
-}
-function register7(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"
-  ).option("--stdin", "read the key from stdin (ignores GAUGE_PROVIDER_KEY)").option(
-    "--key <key>",
-    "pass the key inline (discouraged \u2014 lands in shell history)"
-  ).action(
-    async (provider, opts, cmd) => {
-      const type = providerArg(provider);
-      const org = resolveOrg(cmd);
-      const key = await readKeyInput(opts);
-      const res = await createClient().put(
-        `${keysPath(org)}/${type}`,
-        { key }
-      );
-      if (resolveOutput(cmd) === "json") printJson(res);
-      else console.log(`Saved ${res.providerType} key (\u2026${res.last4})`);
-    }
-  );
-  group.command("list").description("List configured provider keys").action(async (_opts, cmd) => {
-    const org = resolveOrg(cmd);
-    const res = await createClient().get(
-      keysPath(org)
-    );
-    if (resolveOutput(cmd) === "json") printJson(res.items);
-    else
-      printItems(
-        res.items.map((k) => ({
-          providerType: k.providerType,
-          last4: `\u2026${k.last4}`,
-          createdAt: k.createdAt,
-          updatedAt: k.updatedAt
-        })),
-        "table"
-      );
-  });
-  group.command("rm <provider>").description("Remove a provider key").action(async (provider, _opts, cmd) => {
-    const type = providerArg(provider);
-    const org = resolveOrg(cmd);
-    await createClient().delete(`${keysPath(org)}/${type}`);
-    if (resolveOutput(cmd) !== "json") console.log(`Removed ${type} key`);
-  });
-}
-
-// src/commands/onboard.ts
-var onboard_exports = {};
-__export(onboard_exports, {
-  register: () => register8
-});
-function orgNameFromEmail(email) {
-  const domain = email?.split("@")[1] ?? "";
-  const base = domain.split(".")[0] ?? "";
-  if (!base) return "My Workspace";
-  return base.charAt(0).toUpperCase() + base.slice(1);
-}
-function register8(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 (logo source)").option("--new", "create a new workspace even if you already belong to one").action(
-    async (opts, command) => {
-      const output = resolveOutput(command);
-      let client;
-      let me;
-      if (resolveToken()) {
-        client = new ApiClient();
-        me = await client.get("/api/v1/me");
-        if (output !== "json") {
-          console.log(`Already signed in as ${me.user.email ?? me.user.id}.`);
-        }
-      } else {
-        const login = await deviceLogin({ email: opts.email });
-        saveToken(login.token);
-        me = login.me;
-        client = new ApiClient({ token: login.token });
-        if (output !== "json") {
-          console.log(
-            `
-Signed in as ${me.user.email ?? me.user.id} \u2014 token saved to ${credentialsPath()}.`
-          );
-        }
-      }
-      const wantNewOrg = opts.new === true || opts.orgName !== void 0 || me.orgs.length === 0;
-      let orgSlug;
-      let createdOrg = null;
-      if (wantNewOrg) {
-        const name = opts.orgName?.trim() || orgNameFromEmail(me.user.email);
-        createdOrg = await client.post("/api/v1/orgs", {
-          name,
-          website: opts.website
-        });
-        orgSlug = createdOrg.slug;
-      } else {
-        orgSlug = readConfig().defaultOrg ?? me.orgs[0]?.slug ?? "";
-        if (!orgSlug) {
-          throw new CliError(
-            "internal",
-            "No workspace available; re-run with --org-name to create one."
-          );
-        }
-      }
-      updateConfig({ defaultOrg: orgSlug });
-      if (output === "json") {
-        printJson({
-          user: me.user,
-          org: createdOrg ?? { slug: orgSlug },
-          defaultOrg: orgSlug
-        });
-        return;
-      }
-      console.log(
-        createdOrg ? `
-Created workspace ${createdOrg.name} (${orgSlug}).` : `
-Using workspace ${orgSlug}.`
-      );
-      console.log(`Default org set to ${orgSlug}. You're ready:`);
-      console.log(
-        "  gauge apply --example > battery.json   # scaffold a run"
-      );
-      console.log("  gauge apply -f battery.json            # launch it");
-      console.log("  gauge runs list                        # watch results");
-    }
-  );
-}
-
-// src/commands/orgs.ts
-var orgs_exports2 = {};
-__export(orgs_exports2, {
-  register: () => register9
-});
-function isDefault(org, defaultOrg) {
-  return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
-}
-function register9(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);
-    const me = await createClient().get("/api/v1/me");
-    const { defaultOrg } = readConfig();
-    if (output === "json") {
-      printJson(
-        me.orgs.map((org) => ({
-          ...org,
-          isDefault: isDefault(org, defaultOrg)
-        }))
-      );
-      return;
-    }
-    printItems(
-      me.orgs.map((org) => ({
-        slug: org.slug,
-        name: org.name,
-        publicId: org.publicId ?? "",
-        default: isDefault(org, defaultOrg) ? "*" : ""
-      })),
-      "table"
-    );
-  });
-  orgs.command("create <name>").description("Create a new LOCAL workspace and set it as the default org").option("--website <url>", "company site (used as the logo source)").option("--no-use", "don't set the new org as the default").action(
-    async (name, opts, command) => {
-      const created = await createClient().post(
-        "/api/v1/orgs",
-        { name, website: opts.website }
-      );
-      if (opts.use !== false) updateConfig({ defaultOrg: created.slug });
-      if (resolveOutput(command) === "json") {
-        printJson(created);
-        return;
-      }
-      console.log(`Created workspace ${created.name} (${created.slug})`);
-      if (opts.use !== false) {
-        console.log(`Default org set to ${created.slug}`);
-      }
-    }
-  );
-  orgs.command("use <org>").description("Set the default org (slug or public id) in local config").action(async (org, _opts, command) => {
-    const me = await createClient().get("/api/v1/me");
-    const match = me.orgs.find((o) => o.slug === org || o.publicId === org);
-    if (!match && !me.user.isSuperuser) {
-      throw new CliError(
-        "not_found",
-        `You are not a member of "${org}". Run \`gauge orgs list\`.`
-      );
-    }
-    const value = match ? match.slug : org;
-    updateConfig({ defaultOrg: value });
-    if (resolveOutput(command) === "json") {
-      printJson({ defaultOrg: value });
-      return;
-    }
-    console.log(
-      `Default org set to ${value}${match ? ` (${match.name})` : ""}`
-    );
-    if (!match) {
-      console.error(
-        "warning: not in your memberships \u2014 accepted because you are a superuser."
-      );
-    }
-  });
-}
 
 // src/commands/prompts.ts
 var prompts_exports2 = {};
@@ -3083,7 +3218,7 @@ __export(prompts_exports2, {
   promptsPath: () => promptsPath,
   readPromptText: () => readPromptText,
   readWebFixture: () => readWebFixture,
-  register: () => register10,
+  register: () => register7,
   resolveOrCreateTopicId: () => resolveOrCreateTopicId
 });
 import { readFileSync as readFileSync4 } from "fs";
@@ -3203,7 +3338,7 @@ function parseSamples(raw, max) {
     );
   return n;
 }
-function register10(program2) {
+function register7(program2) {
   const group = program2.command("prompts").description("Manage prompts");
   group.command("list").description("List prompts").option("--topic <topic>", "filter by topic (id or name)").option("--tag <tag>", "filter by tag (id or name)").option("-q, --query <text>", "text search").action(
     async (opts, cmd) => {
@@ -3312,74 +3447,1053 @@ function register10(program2) {
       if (resolveOutput(cmd) === "json") printJson(prompt);
       else console.log(`Updated prompt ${prompt.id}`);
     }
-  );
-  group.command("delete <id>").description("Delete a prompt (cascades to its schedules and runs)").action(async (id, _opts, cmd) => {
-    const org = resolveOrg(cmd);
-    await createClient().delete(
-      `${promptsPath(org)}/${encodeURIComponent(id)}`
+  );
+  group.command("delete <id>").description("Delete a prompt (cascades to its schedules and runs)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().delete(
+      `${promptsPath(org)}/${encodeURIComponent(id)}`
+    );
+    if (resolveOutput(cmd) !== "json") console.log(`Deleted prompt ${id}`);
+  });
+  group.command("run <id>").description(
+    "Run a prompt now \u2014 an ad-hoc agents x repo x samples spec (ORG funding, credit-gated)"
+  ).option(
+    "--agent <agents>",
+    "comma-separated agents, e.g. claude-code,codex (default: claude-code,codex)"
+  ).option("--repo <url>", "base repo to run against (default: the scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--samples <n>", "samples per agent, 1-10 (default: 1)").option(
+    "--web-fixture <path>",
+    "web fixture JSON; pages are injected transparently into native WebFetch (misses pass through live)"
+  ).action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
+      if (opts.repo === void 0)
+        console.error(
+          "note: no --repo \u2014 this run targets the default Gauge scaffold, NOT your repository. Pass --repo <url> to measure your repo."
+        );
+      const body = {
+        agents: opts.agent !== void 0 ? parseAgents(opts.agent) : DEFAULT_RUN_AGENTS,
+        samplesPerCycle: opts.samples !== void 0 ? parseSamples(opts.samples, 10) : 1
+      };
+      if (opts.repo !== void 0) body.repoUrl = opts.repo;
+      if (opts.ref !== void 0) body.repoRef = opts.ref;
+      if (opts.webFixture !== void 0) {
+        body.webFixture = readWebFixture(opts.webFixture);
+      }
+      const result = await createClient().post(
+        `${promptsPath(org)}/${encodeURIComponent(id)}/run`,
+        body
+      );
+      if (resolveOutput(cmd) === "json") {
+        printJson(result);
+        return;
+      }
+      if (result.runIds.length === 0) {
+        console.log("No runs enqueued");
+        return;
+      }
+      console.log(
+        `Enqueued ${result.runIds.length} run(s) in ${result.batchIds.length} batch(es)`
+      );
+      for (const runId of result.runIds) console.log(runId);
+      console.error("Tip: `gauge runs watch <id>` streams a run live");
+    }
+  );
+}
+
+// src/commands/cycles.ts
+var CADENCE_CHOICES = ["none", "daily", "weekly", "monthly"];
+function parseCadence(raw) {
+  const upper = raw.trim().toUpperCase().replace(/-/g, "_");
+  if (!["NONE", "DAILY", "WEEKLY", "MONTHLY"].includes(upper))
+    throw new CliError(
+      "usage",
+      `invalid --cadence "${raw}" (expected: ${CADENCE_CHOICES.join(" | ")})`
+    );
+  return upper;
+}
+function cyclesPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/cycles`;
+}
+function toRow3(c) {
+  return {
+    id: c.id,
+    name: c.name,
+    cadence: c.cadence,
+    samples: c.samplesPerCycle,
+    agents: c.agents.map(
+      (a) => a.models.length ? `${a.agent}(${a.models.join(",")})` : a.agent
+    ).join(", "),
+    evals: c.evalSetCount,
+    visibility: c.visibilityPromptCount,
+    enabled: c.enabled ? "yes" : "no"
+  };
+}
+function register8(program2) {
+  const group = program2.command("cycles").description("View and edit the org's execution cycles (new world)");
+  group.command("list").description("List cycles with cadence, agents, and membership counts").action(async (_opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      cyclesPath(org)
+    );
+    if (resolveOutput(cmd) === "json") printJson(res.items);
+    else printItems(res.items.map(toRow3), "table");
+  });
+  group.command("edit <id>").description(
+    "Set a cycle's cadence and agent roster (visibility cycles only)"
+  ).requiredOption("--cadence <cadence>", CADENCE_CHOICES.join(" | ")).requiredOption(
+    "--agent <agents>",
+    "comma-separated agents, e.g. claude-code,codex"
+  ).action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const body = {
+        cadence: parseCadence(opts.cadence),
+        agents: parseAgents(opts.agent)
+      };
+      const updated = await createClient().patch(
+        `${cyclesPath(org)}/${encodeURIComponent(id)}`,
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(updated);
+      else console.log(`Updated cycle ${updated.id}`);
+    }
+  );
+}
+
+// src/commands/evals.ts
+var evals_exports2 = {};
+__export(evals_exports2, {
+  evalSetsPath: () => evalSetsPath,
+  parseCriterion: () => parseCriterion,
+  register: () => register9
+});
+import { readFileSync as readFileSync5 } from "fs";
+function evalSetsPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/eval-sets`;
+}
+function collect3(value, previous) {
+  return [...previous, value];
+}
+function parseCriterion(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0 || !raw.slice(idx + 1).trim()) {
+    throw new CliError(
+      "usage",
+      `invalid --criterion "${raw}" (expected "Name: rubric text")`
+    );
+  }
+  return { name: raw.slice(0, idx).trim(), rubric: raw.slice(idx + 1).trim() };
+}
+function readCriteriaFile(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(path === "-" ? 0 : path, "utf8"));
+  } catch (e) {
+    throw new CliError(
+      "usage",
+      `could not read --criteria-file: ${e instanceof Error ? e.message : e}`
+    );
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0)
+    throw new CliError(
+      "usage",
+      "--criteria-file must be a non-empty JSON array of {id?, name, rubric}"
+    );
+  return parsed;
+}
+function criteriaFromOpts(opts) {
+  if (opts.criterion.length > 0 && opts.criteriaFile !== void 0)
+    throw new CliError("usage", "--criterion and --criteria-file conflict");
+  if (opts.criteriaFile !== void 0)
+    return readCriteriaFile(opts.criteriaFile);
+  if (opts.criterion.length > 0) return opts.criterion.map(parseCriterion);
+  return void 0;
+}
+function repoLabel2(e) {
+  if (!e.repoUrl) return "(default scaffold)";
+  return e.repoRef ? `${e.repoUrl}@${e.repoRef}` : e.repoUrl;
+}
+function passRateLabel(stats) {
+  if (stats.judgedRuns === 0) return "-";
+  return `${Math.round(stats.passedRuns / stats.judgedRuns * 100)}% (${stats.passedRuns}/${stats.judgedRuns})`;
+}
+function toRow4(e) {
+  return {
+    id: e.id,
+    name: e.name,
+    repo: repoLabel2(e),
+    criteria: e.criteria.length,
+    tags: e.tags.join(", "),
+    enabled: e.enabled ? "yes" : "no",
+    "pass rate": passRateLabel(e.stats),
+    runs: e.stats.runCount
+  };
+}
+function printDetail(e) {
+  console.log(`id:       ${e.id}`);
+  console.log(`name:     ${e.name}`);
+  console.log(`repo:     ${repoLabel2(e)}`);
+  console.log(`persona:  ${e.profile ? e.profile.name : "(default judge)"}`);
+  console.log(`enabled:  ${e.enabled ? "yes" : "no"}`);
+  console.log(`tags:     ${e.tags.join(", ") || "(none)"}`);
+  console.log(
+    `cycle:    ${e.cycle.name} \u2014 ${e.cycle.cadence.toLowerCase()}, agents: ${e.cycle.agents.map((a) => a.agent).join(", ")}`
+  );
+  console.log(`prompt:   ${e.promptText}`);
+  console.log("criteria:");
+  for (const c of e.criteria) console.log(`  [${c.id}] ${c.name}: ${c.rubric}`);
+}
+function register9(program2) {
+  const group = program2.command("evals").description("Manage eval sets (judged agent-experience measurements)");
+  group.command("list").description("List the org's eval sets with pass-rate stats").option(
+    "--agents <agents>",
+    "filter stats to these agents, e.g. claude-code,codex"
+  ).option("--models <models>", "filter stats to these model slugs (csv)").option("--since <date>", "only count runs since this ISO date").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const res = await createClient().get(
+        evalSetsPath(org),
+        {
+          agents: opts.agents === void 0 ? void 0 : parseAgents(opts.agents).join(","),
+          models: opts.models,
+          since: opts.since
+        }
+      );
+      if (resolveOutput(cmd) === "json") printJson(res.items);
+      else printItems(res.items.map(toRow4), "table");
+    }
+  );
+  group.command("get <id>").description("Show one eval set: config, criteria, cycle").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const evalSet = await createClient().get(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}`
+    );
+    if (resolveOutput(cmd) === "json") printJson(evalSet);
+    else printDetail(evalSet);
+  });
+  group.command("create").description("Create an eval set (criteria are judged per run)").requiredOption("--name <name>", "eval set name").option("--text <text>", "prompt text inline").option("--file <path>", 'prompt text from a file ("-" for stdin)').option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option(
+    "--persona <profileId>",
+    "persona profile id (default judge if omitted)"
+  ).option(
+    "--criterion <spec>",
+    'judged criterion as "Name: rubric text" (repeatable)',
+    collect3,
+    []
+  ).option(
+    "--criteria-file <path>",
+    'JSON array of {name, rubric} ("-" for stdin)'
+  ).option(
+    "--tag <name>",
+    "user tag name, create-on-type (repeatable)",
+    collect3,
+    []
+  ).option("--disabled", "create the eval set paused").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
+      const criteria = criteriaFromOpts(opts);
+      if (!criteria)
+        throw new CliError(
+          "usage",
+          "at least one --criterion (or --criteria-file) is required"
+        );
+      const body = {
+        name: opts.name,
+        promptText: readPromptText(opts),
+        repoUrl: opts.repo ?? null,
+        repoRef: opts.ref ?? null,
+        profileId: opts.persona ?? null,
+        criteria,
+        enabled: !opts.disabled,
+        tags: opts.tag.length > 0 ? opts.tag : void 0
+      };
+      if (opts.repo === void 0)
+        console.error(
+          "note: no --repo \u2014 this eval set will run against the default Gauge scaffold, NOT your repository. Use `gauge evals edit <id> --repo <url>` to retarget."
+        );
+      const created = await createClient().post(
+        evalSetsPath(org),
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(created);
+      else console.log(`Created eval set ${created.id}`);
+    }
+  );
+  group.command("edit <id>").description(
+    "Update an eval set. A provided criteria list REPLACES the whole set (use --criteria-file with ids to edit criteria in place)."
+  ).option("--name <name>", "rename the eval set").option("--text <text>", "replace the prompt text inline").option("--file <path>", 'replace the prompt text from a file ("-" stdin)').option(
+    "--repo <url>",
+    "set the repository URL (keeps an existing ref pin)"
+  ).option("--ref <ref>", "set the branch, tag, or commit pin").option("--clear-ref", "drop the ref pin (use the default branch)").option("--clear-repo", "reset to the default scaffold").option("--persona <profileId>", "set the persona profile id").option("--clear-persona", "use the default judge").option(
+    "--criterion <spec>",
+    'criterion as "Name: rubric" \u2014 replaces the whole set (repeatable)',
+    collect3,
+    []
+  ).option(
+    "--criteria-file <path>",
+    "JSON array of {id?, name, rubric}; entries with id update in place"
+  ).option(
+    "--tag <name>",
+    "replace the user tag set (repeatable)",
+    collect3,
+    []
+  ).option("--clear-tags", "remove all user tags").action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const body = {};
+      if (opts.name !== void 0) body.name = opts.name;
+      if (opts.text !== void 0 || opts.file !== void 0)
+        body.promptText = readPromptText(opts);
+      if ((opts.repo !== void 0 || opts.ref !== void 0) && opts.clearRepo)
+        throw new CliError("usage", "--repo/--ref and --clear-repo conflict");
+      if (opts.ref !== void 0 && opts.clearRef)
+        throw new CliError("usage", "--ref and --clear-ref conflict");
+      if (opts.clearRepo) {
+        body.repoUrl = null;
+        body.repoRef = null;
+      } else {
+        if (opts.repo !== void 0) body.repoUrl = opts.repo;
+        if (opts.clearRef) body.repoRef = null;
+        else if (opts.ref !== void 0) body.repoRef = opts.ref;
+      }
+      if (opts.persona !== void 0 && opts.clearPersona)
+        throw new CliError("usage", "--persona and --clear-persona conflict");
+      if (opts.clearPersona) body.profileId = null;
+      else if (opts.persona !== void 0) body.profileId = opts.persona;
+      const criteria = criteriaFromOpts(opts);
+      if (criteria) body.criteria = criteria;
+      if (opts.tag.length > 0 && opts.clearTags)
+        throw new CliError("usage", "--tag and --clear-tags conflict");
+      if (opts.clearTags) body.tags = [];
+      else if (opts.tag.length > 0) body.tags = opts.tag;
+      if (Object.keys(body).length === 0)
+        throw new CliError("usage", "nothing to change");
+      const updated = await createClient().patch(
+        `${evalSetsPath(org)}/${encodeURIComponent(id)}`,
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(updated);
+      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(
+    "Run an eval set now \u2014 one run per cycle agent (ORG funding, credit-gated)"
+  ).action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const result = await createClient().post(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}/run`,
+      {}
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(result);
+      return;
+    }
+    console.log(
+      `Enqueued ${result.runIds.length} run(s) in batch ${result.batchId}`
+    );
+    for (const runId of result.runIds) console.log(runId);
+    console.error("Tip: `gauge runs watch <id>` streams a run live");
+  });
+  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("pause <id>").description("Pause an eval set (skipped by cycle expansion)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().patch(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}`,
+      { enabled: false }
+    );
+    if (resolveOutput(cmd) !== "json") console.log(`Paused eval set ${id}`);
+  });
+  group.command("resume <id>").description("Resume a paused eval set").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().patch(
+      `${evalSetsPath(org)}/${encodeURIComponent(id)}`,
+      { enabled: true }
+    );
+    if (resolveOutput(cmd) !== "json") console.log(`Resumed eval set ${id}`);
+  });
+  group.command("tag <id>").description("Replace an eval set's user tags (Surface:* is preserved)").option(
+    "--tag <name>",
+    "tag name, create-on-type (repeatable)",
+    collect3,
+    []
+  ).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: () => register10
+});
+import { readFileSync as readFileSync6 } from "fs";
+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(path) {
+  return readFileSync6(path === "-" ? 0 : path, "utf8");
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toRow5(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 printDetail2(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 register10(program2) {
+  const group = program2.command("experiments").description("Author, launch, and read Fixer content experiments");
+  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(toRow5), "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 Fixer plan round"
+  ).requiredOption("--run <runId>", "source run id").requiredOption(
+    "--boundary <seq>",
+    "opaque boundarySeq from `experiments boundaries`"
+  ).option("--problem <text>", "problem statement (derived if omitted)").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const body = {
+        runId: opts.run,
+        boundarySeq: opts.boundary,
+        ...opts.problem !== void 0 ? { problemText: opts.problem } : {}
+      };
+      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.error(
+        `Tip: \`gauge experiments watch ${result.experimentId}\` follows the 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 printDetail2(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(
+    "--edits-file <path>",
+    'JSON array of {find, replace} ops ("-" for stdin)'
+  ).action(
+    async (id, variantId, opts, cmd) => {
+      if (opts.file === void 0 === (opts.editsFile === void 0))
+        throw new CliError(
+          "usage",
+          "pass exactly one of --file or --edits-file"
+        );
+      const org = resolveOrg(cmd);
+      const body = {};
+      if (opts.file !== void 0) body.content = readText(opts.file);
+      else {
+        let parsed;
+        try {
+          parsed = JSON.parse(readText(opts.editsFile));
+        } catch (e) {
+          throw new CliError(
+            "usage",
+            `could not read --edits-file: ${e instanceof Error ? e.message : e}`
+          );
+        }
+        if (!Array.isArray(parsed) || parsed.length === 0)
+          throw new CliError(
+            "usage",
+            "--edits-file must be a non-empty JSON array of {find, replace}"
+          );
+        body.edits = parsed;
+      }
+      const result = await createClient().put(
+        `${itemPath(org, id)}/variants/${encodeURIComponent(variantId)}/content`,
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(result);
+      else {
+        console.log(`Wrote ${result.chars} chars`);
+        if (body.edits)
+          console.log(
+            `Edits: ${result.applied} applied, ${result.skipped} skipped`
+          );
+        if (result.truncated) console.error("warning: content was truncated");
+      }
+    }
+  );
+  group.command("replan <id>").description("Discard the directions and have the Fixer 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("Have the Fixer write rewrites for directions that lack one").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const result = await createClient().post(
+      `${itemPath(org, id)}/write`,
+      {}
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(result);
+      return;
+    }
+    if (result.queued > 0) console.log(`Queued ${result.queued} rewrite(s)`);
+    else if (result.reason === "round_in_flight")
+      console.log("A round is already running");
+    else console.log("Nothing pending \u2014 every direction has a rewrite");
+  });
+  group.command("launch <id>").description("Claim the draft for launch (spends credits; async fan-out)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const result = await createClient().post(
+      `${itemPath(org, id)}/launch`,
+      {}
+    );
+    if (resolveOutput(cmd) === "json") printJson(result);
+    else
+      console.log(
+        `Launching ${result.experimentId} \u2014 \`gauge experiments watch ${result.experimentId}\` follows it`
+      );
+  });
+  group.command("watch <id>").description(
+    "Follow the running round or launch; prints the recommendation on settle"
+  ).option("--interval <seconds>", "poll interval (default 10)").action(async (id, opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const client = createClient();
+    const intervalMs = Math.max(Number(opts.interval ?? 10) * 1e3, 2e3);
+    const GRACE_POLLS = 3;
+    let sawActive = false;
+    let draftPolls = 0;
+    let last = "";
+    for (; ; ) {
+      const status = await client.get(
+        `${itemPath(org, id)}/status`
+      );
+      if (status.status !== last) {
+        last = status.status;
+        console.error(`status: ${status.status}`);
+        if (status.launchError)
+          console.error(`launch error: ${status.launchError}`);
+      }
+      if (TERMINAL.has(status.status)) break;
+      if (status.status === "DRAFT") {
+        if (status.launchError) {
+          process.exitCode = 1;
+          return;
+        }
+        if (sawActive) {
+          console.error(
+            `Round finished \u2014 \`gauge experiments get ${id}\` shows the directions and rewrites.`
+          );
+          return;
+        }
+        draftPolls += 1;
+        if (draftPolls >= GRACE_POLLS) {
+          console.error(
+            `Nothing is running \u2014 \`gauge experiments get ${id}\` shows the draft.`
+          );
+          return;
+        }
+      } else {
+        sawActive = true;
+      }
+      await sleep2(intervalMs);
+    }
+    const rec = await client.get(
+      `${itemPath(org, id)}/recommendation`
+    );
+    printJson(rec);
+  });
+  group.command("export <id>").description("Print the settled recommendation (JSON)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const rec = await createClient().get(
+      `${itemPath(org, id)}/recommendation`
+    );
+    printJson(rec);
+  });
+  group.command("ship <id> <variantId>").description("Mark a variant as shipped to your live docs").action(
+    async (id, variantId, _o, cmd) => {
+      const org = resolveOrg(cmd);
+      await createClient().post(`${itemPath(org, id)}/ship`, { variantId });
+      if (resolveOutput(cmd) !== "json") console.log("Marked shipped");
+    }
+  );
+  group.command("unship <id>").description("Clear the shipped mark").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().delete(`${itemPath(org, id)}/ship`);
+    if (resolveOutput(cmd) !== "json") console.log("Cleared");
+  });
+  group.command("cancel <id>").description("Cancel a draft/generating/launching experiment").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().post(`${itemPath(org, id)}/cancel`, {});
+    if (resolveOutput(cmd) !== "json") console.log(`Canceled ${id}`);
+  });
+}
+
+// src/commands/keys.ts
+var keys_exports2 = {};
+__export(keys_exports2, {
+  register: () => register11
+});
+function keysPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/provider-keys`;
+}
+function providerArg(raw) {
+  const provider = raw.toLowerCase();
+  if (!keys_exports.PROVIDER_TYPES.includes(provider)) {
+    throw new CliError(
+      "usage",
+      `Unknown provider "${raw}" (expected ${keys_exports.PROVIDER_TYPES.join("|")})`
+    );
+  }
+  return provider;
+}
+async function readKeyInput(opts) {
+  if (opts.key !== void 0) {
+    process.stderr.write(
+      "warning: --key exposes the secret to shell history and process listings; prefer piping it to stdin or setting GAUGE_PROVIDER_KEY.\n"
+    );
+    const key2 = opts.key.trim();
+    if (key2) return key2;
+    throw new CliError("usage", "Empty --key value");
+  }
+  if (!opts.stdin) {
+    const env = process.env.GAUGE_PROVIDER_KEY?.trim();
+    if (env) return env;
+  }
+  if (process.stdin.isTTY) {
+    process.stderr.write("Paste the API key, press Enter, then Ctrl-D:\n");
+  }
+  process.stdin.setEncoding("utf8");
+  let data = "";
+  for await (const chunk of process.stdin) data += chunk;
+  const key = data.trim();
+  if (!key) {
+    throw new CliError(
+      "usage",
+      "No key provided. Pipe it to stdin (e.g. `gauge keys set anthropic < key.txt`) or set GAUGE_PROVIDER_KEY."
+    );
+  }
+  return key;
+}
+function register11(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"
+  ).option("--stdin", "read the key from stdin (ignores GAUGE_PROVIDER_KEY)").option(
+    "--key <key>",
+    "pass the key inline (discouraged \u2014 lands in shell history)"
+  ).action(
+    async (provider, opts, cmd) => {
+      const type = providerArg(provider);
+      const org = resolveOrg(cmd);
+      const key = await readKeyInput(opts);
+      const res = await createClient().put(
+        `${keysPath(org)}/${type}`,
+        { key }
+      );
+      if (resolveOutput(cmd) === "json") printJson(res);
+      else console.log(`Saved ${res.providerType} key (\u2026${res.last4})`);
+    }
+  );
+  group.command("list").description("List configured provider keys").action(async (_opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      keysPath(org)
+    );
+    if (resolveOutput(cmd) === "json") printJson(res.items);
+    else
+      printItems(
+        res.items.map((k) => ({
+          providerType: k.providerType,
+          last4: `\u2026${k.last4}`,
+          createdAt: k.createdAt,
+          updatedAt: k.updatedAt
+        })),
+        "table"
+      );
+  });
+  group.command("rm <provider>").description("Remove a provider key").action(async (provider, _opts, cmd) => {
+    const type = providerArg(provider);
+    const org = resolveOrg(cmd);
+    await createClient().delete(`${keysPath(org)}/${type}`);
+    if (resolveOutput(cmd) !== "json") console.log(`Removed ${type} key`);
+  });
+}
+
+// src/commands/onboard.ts
+var onboard_exports = {};
+__export(onboard_exports, {
+  register: () => register12
+});
+function orgNameFromEmail(email) {
+  const domain = email?.split("@")[1] ?? "";
+  const base = domain.split(".")[0] ?? "";
+  if (!base) return "My Workspace";
+  return base.charAt(0).toUpperCase() + base.slice(1);
+}
+function register12(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 (logo source)").option("--new", "create a new workspace even if you already belong to one").action(
+    async (opts, command) => {
+      const output = resolveOutput(command);
+      let client;
+      let me;
+      if (resolveToken()) {
+        client = new ApiClient();
+        me = await client.get("/api/v1/me");
+        if (output !== "json") {
+          console.log(`Already signed in as ${me.user.email ?? me.user.id}.`);
+        }
+      } else {
+        const login = await deviceLogin({ email: opts.email });
+        saveToken(login.token);
+        me = login.me;
+        client = new ApiClient({ token: login.token });
+        if (output !== "json") {
+          console.log(
+            `
+Signed in as ${me.user.email ?? me.user.id} \u2014 token saved to ${credentialsPath()}.`
+          );
+        }
+      }
+      const wantNewOrg = opts.new === true || opts.orgName !== void 0 || me.orgs.length === 0;
+      let orgSlug;
+      let createdOrg = null;
+      if (wantNewOrg) {
+        const name = opts.orgName?.trim() || orgNameFromEmail(me.user.email);
+        createdOrg = await client.post("/api/v1/orgs", {
+          name,
+          website: opts.website
+        });
+        orgSlug = createdOrg.slug;
+      } else {
+        orgSlug = readConfig().defaultOrg ?? me.orgs[0]?.slug ?? "";
+        if (!orgSlug) {
+          throw new CliError(
+            "internal",
+            "No workspace available; re-run with --org-name to create one."
+          );
+        }
+      }
+      updateConfig({ defaultOrg: orgSlug });
+      if (output === "json") {
+        printJson({
+          user: me.user,
+          org: createdOrg ?? { slug: orgSlug },
+          defaultOrg: orgSlug
+        });
+        return;
+      }
+      console.log(
+        createdOrg ? `
+Created workspace ${createdOrg.name} (${orgSlug}).` : `
+Using workspace ${orgSlug}.`
+      );
+      console.log(`Default org set to ${orgSlug}. You're ready:`);
+      console.log(
+        "  gauge apply --example > battery.json   # scaffold a run"
+      );
+      console.log("  gauge apply -f battery.json            # launch it");
+      console.log("  gauge runs list                        # watch results");
+    }
+  );
+}
+
+// src/commands/orgs.ts
+var orgs_exports2 = {};
+__export(orgs_exports2, {
+  register: () => register13
+});
+function isDefault(org, defaultOrg) {
+  return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
+}
+function register13(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);
+    const me = await createClient().get("/api/v1/me");
+    const { defaultOrg } = readConfig();
+    if (output === "json") {
+      printJson(
+        me.orgs.map((org) => ({
+          ...org,
+          isDefault: isDefault(org, defaultOrg)
+        }))
+      );
+      return;
+    }
+    printItems(
+      me.orgs.map((org) => ({
+        slug: org.slug,
+        name: org.name,
+        publicId: org.publicId ?? "",
+        default: isDefault(org, defaultOrg) ? "*" : ""
+      })),
+      "table"
     );
-    if (resolveOutput(cmd) !== "json") console.log(`Deleted prompt ${id}`);
   });
-  group.command("run <id>").description(
-    "Run a prompt now \u2014 an ad-hoc agents x repo x samples spec (ORG funding, credit-gated)"
-  ).option(
-    "--agent <agents>",
-    "comma-separated agents, e.g. claude-code,codex (default: claude-code,codex)"
-  ).option("--repo <url>", "base repo to run against (default: the scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--samples <n>", "samples per agent, 1-10 (default: 1)").option(
-    "--web-fixture <path>",
-    "web fixture JSON; pages are injected transparently into native WebFetch (misses pass through live)"
-  ).action(
-    async (id, opts, cmd) => {
-      const org = resolveOrg(cmd);
-      if (opts.ref !== void 0 && opts.repo === void 0)
-        throw new CliError("usage", "--ref requires --repo");
-      const body = {
-        agents: opts.agent !== void 0 ? parseAgents(opts.agent) : DEFAULT_RUN_AGENTS,
-        samplesPerCycle: opts.samples !== void 0 ? parseSamples(opts.samples, 10) : 1
-      };
-      if (opts.repo !== void 0) body.repoUrl = opts.repo;
-      if (opts.ref !== void 0) body.repoRef = opts.ref;
-      if (opts.webFixture !== void 0) {
-        body.webFixture = readWebFixture(opts.webFixture);
-      }
-      const result = await createClient().post(
-        `${promptsPath(org)}/${encodeURIComponent(id)}/run`,
-        body
+  orgs.command("create <name>").description("Create a new LOCAL workspace and set it as the default org").option("--website <url>", "company site (used as the logo source)").option("--no-use", "don't set the new org as the default").action(
+    async (name, opts, command) => {
+      const created = await createClient().post(
+        "/api/v1/orgs",
+        { name, website: opts.website }
       );
-      if (resolveOutput(cmd) === "json") {
-        printJson(result);
+      if (opts.use !== false) updateConfig({ defaultOrg: created.slug });
+      if (resolveOutput(command) === "json") {
+        printJson(created);
         return;
       }
-      if (result.runIds.length === 0) {
-        console.log("No runs enqueued");
-        return;
+      console.log(`Created workspace ${created.name} (${created.slug})`);
+      if (opts.use !== false) {
+        console.log(`Default org set to ${created.slug}`);
       }
-      console.log(
-        `Enqueued ${result.runIds.length} run(s) in ${result.batchIds.length} batch(es)`
-      );
-      for (const runId of result.runIds) console.log(runId);
-      console.error("Tip: `gauge runs watch <id>` streams a run live");
     }
   );
+  orgs.command("use <org>").description("Set the default org (slug or public id) in local config").action(async (org, _opts, command) => {
+    const me = await createClient().get("/api/v1/me");
+    const match = me.orgs.find((o) => o.slug === org || o.publicId === org);
+    if (!match && !me.user.isSuperuser) {
+      throw new CliError(
+        "not_found",
+        `You are not a member of "${org}". Run \`gauge orgs list\`.`
+      );
+    }
+    const value = match ? match.slug : org;
+    updateConfig({ defaultOrg: value });
+    if (resolveOutput(command) === "json") {
+      printJson({ defaultOrg: value });
+      return;
+    }
+    console.log(
+      `Default org set to ${value}${match ? ` (${match.name})` : ""}`
+    );
+    if (!match) {
+      console.error(
+        "warning: not in your memberships \u2014 accepted because you are a superuser."
+      );
+    }
+  });
 }
 
 // src/commands/query.ts
 var query_exports2 = {};
 __export(query_exports2, {
-  register: () => register11
+  register: () => register14
 });
-var collect3 = (value, prev = []) => [
+var collect4 = (value, prev = []) => [
   ...prev,
   value
 ];
-var csv = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
+var csv2 = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
 function parseWhere(expr) {
   const inMatch = expr.match(/^\s*(\w+)\s+(in|contains)\s+(.*)$/i);
   if (inMatch) {
     const [, dimension2, opRaw, rest2] = inMatch;
     const op = opRaw.toLowerCase();
     if (op === "in") {
-      return { dimension: dimension2, op: "in", value: csv(rest2) };
+      return { dimension: dimension2, op: "in", value: csv2(rest2) };
     }
     return { dimension: dimension2, op: "contains", value: rest2.trim() };
   }
@@ -3424,8 +4538,8 @@ async function buildSpec(opts) {
     }
   }
   if (opts.dataset) spec.dataset = opts.dataset;
-  if (opts.dimensions !== void 0) spec.dimensions = csv(opts.dimensions);
-  if (opts.metrics !== void 0) spec.metrics = csv(opts.metrics);
+  if (opts.dimensions !== void 0) spec.dimensions = csv2(opts.dimensions);
+  if (opts.metrics !== void 0) spec.metrics = csv2(opts.metrics);
   if (opts.where?.length) spec.where = opts.where.map(parseWhere);
   if (opts.orderBy?.length) spec.orderBy = opts.orderBy.map(parseOrderBy);
   if (opts.limit !== void 0) spec.limit = Number(opts.limit);
@@ -3451,16 +4565,16 @@ async function buildSpec(opts) {
     ...spec.filters ?? {}
   };
   if (opts.prompt) filters.prompt = opts.prompt;
-  if (opts.topic) filters.topic = csv(opts.topic);
-  if (opts.tag) filters.tag = csv(opts.tag);
-  if (opts.repo) filters.repo = csv(opts.repo);
-  if (opts.language) filters.language = csv(opts.language);
-  if (opts.framework) filters.framework = csv(opts.framework);
-  if (opts.size) filters.size = csv(opts.size);
-  if (opts.agent) filters.agent = csv(opts.agent);
-  if (opts.model) filters.model = csv(opts.model);
-  if (opts.scenario) filters.scenario = csv(opts.scenario);
-  if (opts.experiment) filters.experiment = csv(opts.experiment);
+  if (opts.topic) filters.topic = csv2(opts.topic);
+  if (opts.tag) filters.tag = csv2(opts.tag);
+  if (opts.repo) filters.repo = csv2(opts.repo);
+  if (opts.language) filters.language = csv2(opts.language);
+  if (opts.framework) filters.framework = csv2(opts.framework);
+  if (opts.size) filters.size = csv2(opts.size);
+  if (opts.agent) filters.agent = csv2(opts.agent);
+  if (opts.model) filters.model = csv2(opts.model);
+  if (opts.scenario) filters.scenario = csv2(opts.scenario);
+  if (opts.experiment) filters.experiment = csv2(opts.experiment);
   if (opts.branded) filters.branded = true;
   if (opts.unbranded) filters.branded = false;
   if (Object.keys(filters).length) spec.filters = filters;
@@ -3559,7 +4673,7 @@ async function showMetadata(command, mode, dataset) {
   console.error(`dataset: ${ds.name} \u2014 ${ds.grain}`);
   printItems(rows, "table");
 }
-function register11(program2) {
+function register14(program2) {
   const group = program2.command("query").description(
     "Flexible reports over your event warehouse (run a report, or discover the catalog)"
   );
@@ -3572,11 +4686,11 @@ function register11(program2) {
   ).option("-d, --dimensions <names>", "comma-separated GROUP BY dimensions").option("-m, --metrics <names>", "comma-separated metrics (at least one)").option(
     "--where <expr>",
     'predicate, e.g. "action=install" (repeatable)',
-    collect3
+    collect4
   ).option("--since <val>", "date range start \u2014 ISO date or window (30d, 24h)").option("--until <val>", "date range end \u2014 ISO date or window").option("--last-days <n>", "shorthand for --since <n> days ago").option(
     "--order-by <key:dir>",
     "sort by a selected key, e.g. installs:desc (repeatable)",
-    collect3
+    collect4
   ).option("--limit <n>", "max rows (default 50, max 1000)").option(
     "--granularity <g>",
     "date bucket: day | week | month (default day)"
@@ -3595,7 +4709,7 @@ function register11(program2) {
 // src/commands/repos.ts
 var repos_exports2 = {};
 __export(repos_exports2, {
-  register: () => register12
+  register: () => register15
 });
 function reposPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/repos`;
@@ -3603,7 +4717,7 @@ function reposPath(org) {
 async function fetchAllRepos(client, org) {
   return fetchAllPages(client, reposPath(org));
 }
-function toRow3(repo) {
+function toRow6(repo) {
   return {
     name: repo.name,
     url: repo.url,
@@ -3618,7 +4732,7 @@ function toRow3(repo) {
 function syncWarning(repo) {
   return `warning: GitHub metadata sync failed; retry with \`gauge repos resync ${repo.url}\``;
 }
-function register12(program2) {
+function register15(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);
@@ -3628,7 +4742,7 @@ function register12(program2) {
       printJson(items);
       return;
     }
-    printItems(items.map(toRow3), "table");
+    printItems(items.map(toRow6), "table");
   });
   repos.command("add <url>").description("Add a repository (pulls languages/size/stars from GitHub)").option(
     "--ref <ref>",
@@ -3682,7 +4796,7 @@ function register12(program2) {
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register13
+  register: () => register16
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -3703,7 +4817,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 toRow4(run) {
+function toRow7(run) {
   return {
     id: run.id,
     status: run.status,
@@ -3765,9 +4879,22 @@ function decisionVia(detail) {
   }
   return types.join(", ");
 }
+var PASS_LABELS = {
+  INSTALL: "Install pass",
+  DECISION: "Decision pass",
+  EVAL: "Criteria pass",
+  INTEGRATION: "Implementation pass",
+  EXPERIMENT_DELTA: "Experiment delta"
+};
 function printInsight(insight) {
-  console.log(passLine("Decision pass", insight.decision));
-  console.log(passLine("Implementation pass", insight.implementation));
+  if (insight.passes.length > 0) {
+    for (const pass of insight.passes) {
+      console.log(passLine(PASS_LABELS[pass.kind] ?? pass.kind, pass));
+    }
+  } else {
+    console.log(passLine("Decision pass", insight.decision));
+    console.log(passLine("Implementation pass", insight.implementation));
+  }
   console.log(`
 Decisions (${insight.decisions.length})`);
   if (insight.decisions.length === 0) {
@@ -3801,6 +4928,17 @@ Implementation quality (${insight.implementations.length})`);
       "table"
     );
   }
+  const delta2 = insight.experimentDelta;
+  if (delta2 && typeof delta2 === "object") {
+    console.log("\nExperiment delta");
+    console.log(
+      [
+        delta2.changed == null ? "" : delta2.changed ? "changed" : "no change",
+        delta2.hypothesisSupported ?? ""
+      ].filter(Boolean).join("  ")
+    );
+    if (delta2.summary) console.log(compact(delta2.summary, 300));
+  }
   if (insight.decisions.length > 0 || insight.implementations.length > 0) {
     console.error("\n(full detail: rerun with -o json)");
   }
@@ -3920,7 +5058,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register13(program2) {
+function register16(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("--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) => {
@@ -3942,7 +5080,7 @@ function register13(program2) {
         printJson(page);
         return;
       }
-      printItems(page.items.map(toRow4), "table");
+      printItems(page.items.map(toRow7), "table");
       if (page.nextCursor) {
         console.error(
           `(more results \u2014 rerun with --cursor ${page.nextCursor})`
@@ -4012,6 +5150,20 @@ function register13(program2) {
     );
     console.error(`Watch it with: gauge runs watch ${result.runId}`);
   });
+  runs.command("fork-boundaries <id>").description(
+    "The run's forkable fetch boundaries + checkpoint availability"
+  ).action(async (id) => {
+    const result = await createClient().get(
+      `${runPath(id)}/fork-boundaries`
+    );
+    printJson(result);
+  });
+  runs.command("fork-plan <planId>").description("Inspect a fetch-fork plan (status, forked run ids)").action(async (planId) => {
+    const result = await createClient().get(
+      `/api/v1/fork-plans/${encodeURIComponent(planId)}`
+    );
+    printJson(result);
+  });
   runs.command("cancel <id>").description("Request cancellation of a run").action(async (id, _opts, command) => {
     const result = await createClient().post(
       `${runPath(id)}/cancel`
@@ -4030,21 +5182,21 @@ function register13(program2) {
 // src/commands/schedules.ts
 var schedules_exports2 = {};
 __export(schedules_exports2, {
-  register: () => register14
+  register: () => register17
 });
-var CADENCE_CHOICES = [
+var CADENCE_CHOICES2 = [
   "none",
   "daily",
   "weekly",
   "monthly",
   "days-per-week"
 ];
-function parseCadence(raw) {
+function parseCadence2(raw) {
   const upper = raw.trim().toUpperCase().replace(/-/g, "_");
   if (!["NONE", "DAILY", "WEEKLY", "MONTHLY", "DAYS_PER_WEEK"].includes(upper)) {
     throw new CliError(
       "usage",
-      `invalid --cadence "${raw}" (expected: ${CADENCE_CHOICES.join(" | ")})`
+      `invalid --cadence "${raw}" (expected: ${CADENCE_CHOICES2.join(" | ")})`
     );
   }
   return upper;
@@ -4055,7 +5207,7 @@ function parseDays(raw) {
     throw new CliError("usage", "--days-per-week must be an integer 1-7");
   return n;
 }
-function collect4(value, previous) {
+function collect5(value, previous) {
   return [...previous, value];
 }
 function reposLabel(repos) {
@@ -4070,7 +5222,7 @@ function reposLabel(repos) {
 function reposFromOpts(repo, ref) {
   return [{ repoUrl: repo, repoRef: ref ?? null }];
 }
-function toRow5(s) {
+function toRow8(s) {
   return {
     id: s.id,
     name: s.name,
@@ -4096,7 +5248,7 @@ var RUN_BLOCK_WARNINGS = {
   insufficient_credits: "warning: some targets were skipped or truncated: out of credits",
   needs_provider_key: "warning: some targets were skipped: no provider key for the selected agents"
 };
-function register14(program2) {
+function register17(program2) {
   const group = program2.command("schedules").description("Manage org schedules (named prompt sets on a cadence)");
   group.command("list").description(
     "List schedules for the org, or (with --prompt) the schedules a prompt is in"
@@ -4116,7 +5268,7 @@ function register14(program2) {
       `/api/v1/orgs/${encodeURIComponent(org)}/schedules`
     );
     if (json) printJson(res.items);
-    else printItems(res.items.map(toRow5), "table");
+    else printItems(res.items.map(toRow8), "table");
   });
   group.command("create").description(
     "Create an org schedule: a named tag set + agents + cadence + repo"
@@ -4126,9 +5278,9 @@ function register14(program2) {
   ).option(
     "--tag <id>",
     "membership tag id \u2014 the schedule runs the union of its tags (repeatable)",
-    collect4,
+    collect5,
     []
-  ).option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--cadence <cadence>", CADENCE_CHOICES.join(" | "), "none").option("--days-per-week <n>", "1-7 (with --cadence days-per-week)").option("--samples <n>", "samples per cycle (default: 1)").option("--model <id>", "pin a model id (default: the agent's default)").option("--disabled", "create the schedule disabled").action(
+  ).option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--cadence <cadence>", CADENCE_CHOICES2.join(" | "), "none").option("--days-per-week <n>", "1-7 (with --cadence days-per-week)").option("--samples <n>", "samples per cycle (default: 1)").option("--model <id>", "pin a model id (default: the agent's default)").option("--disabled", "create the schedule disabled").action(
     async (opts, cmd) => {
       const org = resolveOrg(cmd);
       if (opts.ref !== void 0 && opts.repo === void 0)
@@ -4136,7 +5288,7 @@ function register14(program2) {
       const body = {
         name: opts.name,
         agents: parseAgents(opts.agent),
-        cadence: parseCadence(opts.cadence),
+        cadence: parseCadence2(opts.cadence),
         samplesPerCycle: opts.samples !== void 0 ? parseSamples(opts.samples) : 1,
         repos: opts.repo !== void 0 ? reposFromOpts(opts.repo, opts.ref) : [],
         tagIds: opts.tag,
@@ -4156,15 +5308,15 @@ function register14(program2) {
   group.command("edit <id>").description("Update a schedule (repos and tags are full replacements)").option("--name <name>", "rename the schedule").option("--agent <agents>", "comma-separated agents").option(
     "--tag <id>",
     "membership tag id \u2014 replaces the whole set (repeatable)",
-    collect4,
+    collect5,
     []
-  ).option("--clear-tags", "remove all membership tags").option("--repo <url>", "set a single repo target").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--clear-repos", "reset to the default scaffold (no repos)").option("--cadence <cadence>", CADENCE_CHOICES.join(" | ")).option("--days-per-week <n>", "1-7 (with cadence days-per-week)").option("--samples <n>", "samples per cycle").option("--model <id>", "pin a model id").option("--clear-model", "use the agent's default model").option("--enable", "enable the schedule").option("--disable", "disable the schedule").action(
+  ).option("--clear-tags", "remove all membership tags").option("--repo <url>", "set a single repo target").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--clear-repos", "reset to the default scaffold (no repos)").option("--cadence <cadence>", CADENCE_CHOICES2.join(" | ")).option("--days-per-week <n>", "1-7 (with cadence days-per-week)").option("--samples <n>", "samples per cycle").option("--model <id>", "pin a model id").option("--clear-model", "use the agent's default model").option("--enable", "enable the schedule").option("--disable", "disable the schedule").action(
     async (id, opts, cmd) => {
       const body = {};
       if (opts.name !== void 0) body.name = opts.name;
       if (opts.agent !== void 0) body.agents = parseAgents(opts.agent);
       if (opts.cadence !== void 0)
-        body.cadence = parseCadence(opts.cadence);
+        body.cadence = parseCadence2(opts.cadence);
       if (opts.daysPerWeek !== void 0)
         body.daysPerWeek = parseDays(opts.daysPerWeek);
       if (opts.samples !== void 0)
@@ -4237,7 +5389,7 @@ function register14(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register15
+  register: () => register18
 });
 function addFilterOptions(cmd) {
   return cmd.option("--prompt <id>", "filter to a single prompt").option("--topic <ids>", "comma-separated topic ids").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)");
@@ -4271,7 +5423,7 @@ function noteFreshness2(f) {
     );
   }
 }
-async function runStats(command, resource, opts, toRow6) {
+async function runStats(command, resource, opts, toRow10) {
   const org = resolveOrg(command);
   const output = resolveOutput(command);
   const res = await createClient().get(
@@ -4282,7 +5434,7 @@ async function runStats(command, resource, opts, toRow6) {
     printJson(res);
     return;
   }
-  printItems(res.items.map(toRow6), "table");
+  printItems(res.items.map(toRow10), "table");
   noteFreshness2(res.freshness);
 }
 var rankingRow = (r) => ({
@@ -4321,7 +5473,7 @@ var domainRow = (r) => ({
   rate: pct2(r.rate),
   requests: r.requests
 });
-function register15(program2) {
+function register18(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -4353,12 +5505,12 @@ function register15(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register16
+  register: () => register19
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register16(program2) {
+function register19(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -4401,12 +5553,12 @@ function register16(program2) {
 // src/commands/topics.ts
 var topics_exports2 = {};
 __export(topics_exports2, {
-  register: () => register17
+  register: () => register20
 });
 function topicsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/topics`;
 }
-function register17(program2) {
+function register20(program2) {
   const group = program2.command("topics").description("Manage org topics");
   group.command("list").description("List topics").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -4427,9 +5579,9 @@ function register17(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register18
+  register: () => register21
 });
-function register18(program2) {
+function register21(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);
@@ -4473,6 +5625,295 @@ function register18(program2) {
   );
 }
 
+// src/commands/visibility.ts
+var visibility_exports2 = {};
+__export(visibility_exports2, {
+  register: () => register22,
+  visibilityPath: () => visibilityPath
+});
+function visibilityPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/visibility-prompts`;
+}
+function collect6(value, previous) {
+  return [...previous, value];
+}
+var KIND_CHOICES = ["head-to-head", "recommend"];
+function parseKind(raw) {
+  const upper = raw.trim().toUpperCase().replace(/-/g, "_");
+  if (upper !== "HEAD_TO_HEAD" && upper !== "RECOMMEND")
+    throw new CliError(
+      "usage",
+      `invalid --kind "${raw}" (expected: ${KIND_CHOICES.join(" | ")})`
+    );
+  return upper;
+}
+function brandsLabel(v) {
+  if (v.kind === "HEAD_TO_HEAD") return `${v.brandA} vs ${v.brandB}`;
+  return v.branded ? v.brandA ?? "branded" : "organic";
+}
+function toRow9(v) {
+  return {
+    id: v.id,
+    kind: v.kind,
+    brands: brandsLabel(v),
+    market: v.market?.slug ?? "",
+    tags: v.tags.join(", "),
+    enabled: v.enabled ? "yes" : "no",
+    runs: v.runCount,
+    "last run": v.lastRunAt ?? "-"
+  };
+}
+function printDetail3(v) {
+  console.log(`id:      ${v.id}`);
+  console.log(`kind:    ${v.kind}`);
+  console.log(`brands:  ${brandsLabel(v)}`);
+  console.log(
+    `market:  ${v.market ? `${v.market.name} (${v.market.slug})` : "(none)"}`
+  );
+  console.log(
+    `repo:    ${v.repoUrl ? v.repoRef ? `${v.repoUrl}@${v.repoRef}` : v.repoUrl : "(default scaffold)"}`
+  );
+  console.log(`enabled: ${v.enabled ? "yes" : "no"}`);
+  console.log(`tags:    ${v.tags.join(", ") || "(none)"}`);
+  console.log(
+    `cycle:   ${v.cycle.name} \u2014 ${v.cycle.cadence.toLowerCase()}, agents: ${v.cycle.agents.map((a) => a.agent).join(", ")}`
+  );
+  console.log(`runs:    ${v.runCount} (last: ${v.lastRunAt ?? "never"})`);
+  console.log(`prompt:  ${v.promptText}`);
+}
+function register22(program2) {
+  const group = program2.command("visibility").description("Manage visibility prompts (brand-visibility measurements)");
+  group.command("list").description("List the org's visibility prompts").action(async (_opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      visibilityPath(org)
+    );
+    if (resolveOutput(cmd) === "json") printJson(res.items);
+    else printItems(res.items.map(toRow9), "table");
+  });
+  group.command("get <id>").description("Show one visibility prompt").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const vp = await createClient().get(
+      `${visibilityPath(org)}/${encodeURIComponent(id)}`
+    );
+    if (resolveOutput(cmd) === "json") printJson(vp);
+    else printDetail3(vp);
+  });
+  group.command("create").description(
+    "Create a visibility prompt (kind is immutable after creation)"
+  ).requiredOption("--kind <kind>", KIND_CHOICES.join(" | ")).option("--text <text>", "prompt text inline").option("--file <path>", 'prompt text from a file ("-" for stdin)').option("--brand-a <name>", "first brand (required for head-to-head)").option("--brand-b <name>", "second brand (required for head-to-head)").option("--branded", "a branded RECOMMEND measurement").option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option(
+    "--market <marketId>",
+    "tracked market id (see `visibility markets`)"
+  ).option(
+    "--tag <name>",
+    "user tag name, create-on-type (repeatable)",
+    collect6,
+    []
+  ).option("--disabled", "create the prompt paused").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
+      const body = {
+        promptText: readPromptText(opts),
+        kind: parseKind(opts.kind),
+        branded: opts.branded,
+        brandA: opts.brandA ?? null,
+        brandB: opts.brandB ?? null,
+        repoUrl: opts.repo ?? null,
+        repoRef: opts.ref ?? null,
+        marketId: opts.market ?? null,
+        enabled: !opts.disabled,
+        tags: opts.tag.length > 0 ? opts.tag : void 0
+      };
+      if (opts.repo === void 0)
+        console.error(
+          "note: no --repo \u2014 this prompt will run against the default Gauge scaffold, NOT your repository. Use `gauge visibility edit <id> --repo <url>` to retarget."
+        );
+      const created = await createClient().post(
+        visibilityPath(org),
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(created);
+      else console.log(`Created visibility prompt ${created.id}`);
+    }
+  );
+  group.command("edit <id>").description("Update a visibility prompt (kind can't change)").option("--text <text>", "replace the prompt text inline").option("--file <path>", 'replace the prompt text from a file ("-" stdin)').option("--brand-a <name>", "first brand").option("--brand-b <name>", "second brand").option("--branded", "mark branded (RECOMMEND only)").option("--organic", "mark organic (RECOMMEND only)").option(
+    "--repo <url>",
+    "set the repository URL (keeps an existing ref pin)"
+  ).option("--ref <ref>", "set the branch, tag, or commit pin").option("--clear-ref", "drop the ref pin (use the default branch)").option("--clear-repo", "reset to the default scaffold").option("--market <marketId>", "set the measured market").option("--clear-market", "unscope from any market").option(
+    "--tag <name>",
+    "replace the user tag set (repeatable)",
+    collect6,
+    []
+  ).option("--clear-tags", "remove all user tags").action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const body = {};
+      if (opts.text !== void 0 || opts.file !== void 0)
+        body.promptText = readPromptText(opts);
+      if (opts.brandA !== void 0) body.brandA = opts.brandA;
+      if (opts.brandB !== void 0) body.brandB = opts.brandB;
+      if (opts.branded && opts.organic)
+        throw new CliError("usage", "--branded and --organic conflict");
+      if (opts.branded) body.branded = true;
+      else if (opts.organic) body.branded = false;
+      if ((opts.repo !== void 0 || opts.ref !== void 0) && opts.clearRepo)
+        throw new CliError("usage", "--repo/--ref and --clear-repo conflict");
+      if (opts.ref !== void 0 && opts.clearRef)
+        throw new CliError("usage", "--ref and --clear-ref conflict");
+      if (opts.clearRepo) {
+        body.repoUrl = null;
+        body.repoRef = null;
+      } else {
+        if (opts.repo !== void 0) body.repoUrl = opts.repo;
+        if (opts.clearRef) body.repoRef = null;
+        else if (opts.ref !== void 0) body.repoRef = opts.ref;
+      }
+      if (opts.market !== void 0 && opts.clearMarket)
+        throw new CliError("usage", "--market and --clear-market conflict");
+      if (opts.clearMarket) body.marketId = null;
+      else if (opts.market !== void 0) body.marketId = opts.market;
+      if (opts.tag.length > 0 && opts.clearTags)
+        throw new CliError("usage", "--tag and --clear-tags conflict");
+      if (opts.clearTags) body.tags = [];
+      else if (opts.tag.length > 0) body.tags = opts.tag;
+      if (Object.keys(body).length === 0)
+        throw new CliError("usage", "nothing to change");
+      const updated = await createClient().patch(
+        `${visibilityPath(org)}/${encodeURIComponent(id)}`,
+        body
+      );
+      if (resolveOutput(cmd) === "json") printJson(updated);
+      else console.log(`Updated visibility prompt ${updated.id}`);
+    }
+  );
+  group.command("rm <id>").description("Delete a visibility prompt (its run history survives)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().delete(
+      `${visibilityPath(org)}/${encodeURIComponent(id)}`
+    );
+    if (resolveOutput(cmd) !== "json")
+      console.log(`Deleted visibility prompt ${id}`);
+  });
+  group.command("run <id>").description(
+    "Run a visibility prompt now \u2014 one run per cycle agent (ORG funding)"
+  ).action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const result = await createClient().post(
+      `${visibilityPath(org)}/${encodeURIComponent(id)}/run`,
+      {}
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(result);
+      return;
+    }
+    console.log(`Enqueued ${result.runIds.length} run(s)`);
+    for (const runId of result.runIds) console.log(runId);
+    console.error("Tip: `gauge runs watch <id>` streams a run live");
+  });
+  group.command("runs <id>").description("The prompt's run log with visibility verdicts").option("--limit <n>", "max runs (default 100)").action(async (id, opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      `${visibilityPath(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,
+        verdict: r.verdict?.status ?? "-"
+      })),
+      "table"
+    );
+  });
+  group.command("pause <id>").description("Pause a visibility prompt (skipped by cycle expansion)").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().patch(
+      `${visibilityPath(org)}/${encodeURIComponent(id)}`,
+      { enabled: false }
+    );
+    if (resolveOutput(cmd) !== "json")
+      console.log(`Paused visibility prompt ${id}`);
+  });
+  group.command("resume <id>").description("Resume a paused visibility prompt").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    await createClient().patch(
+      `${visibilityPath(org)}/${encodeURIComponent(id)}`,
+      { enabled: true }
+    );
+    if (resolveOutput(cmd) !== "json")
+      console.log(`Resumed visibility prompt ${id}`);
+  });
+  group.command("tag <id>").description("Replace a visibility prompt's user tags").option(
+    "--tag <name>",
+    "tag name, create-on-type (repeatable)",
+    collect6,
+    []
+  ).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(
+        `${visibilityPath(org)}/${encodeURIComponent(id)}`,
+        { tags: opts.clear ? [] : opts.tag }
+      );
+      if (resolveOutput(cmd) === "json") printJson(updated);
+      else console.log(`Tags: ${updated.tags.join(", ") || "(none)"}`);
+    }
+  );
+  group.command("markets").description("List tracked + addable markets, or track one more with --add").option("--add <marketId>", "track a published market").action(async (opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const client = createClient();
+    const base = `/api/v1/orgs/${encodeURIComponent(org)}/markets`;
+    if (opts.add !== void 0) {
+      const market = await client.post(base, {
+        marketId: opts.add
+      });
+      if (resolveOutput(cmd) === "json") printJson(market);
+      else console.log(`Tracking market ${market.name} (${market.slug})`);
+      return;
+    }
+    const res = await client.get(base);
+    if (resolveOutput(cmd) === "json") {
+      printJson(res);
+      return;
+    }
+    printItems(
+      [
+        ...res.tracked.map((m) => ({
+          id: m.marketId,
+          slug: m.slug,
+          name: m.name,
+          tracked: "yes",
+          source: m.source
+        })),
+        ...res.addable.map((m) => ({
+          id: m.marketId,
+          slug: m.slug,
+          name: m.name,
+          tracked: "no",
+          source: ""
+        }))
+      ],
+      "table"
+    );
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("gauge").description(
@@ -4487,10 +5928,14 @@ for (const group of [
   auth_exports,
   onboard_exports,
   orgs_exports2,
+  evals_exports2,
+  visibility_exports2,
+  cycles_exports2,
   prompts_exports2,
   schedules_exports2,
   repos_exports2,
   runs_exports2,
+  experiments_exports2,
   apply_exports,
   batches_exports,
   brands_exports2,
@@ -4514,6 +5959,9 @@ try {
   }
   if (error instanceof CliError) {
     let message2 = error.message;
+    if (error.code === "upgrade_required" && !/npm install/i.test(message2)) {
+      message2 += "\nRun: npm install -g @withgauge/cli";
+    }
     if (error.code === "not_found" && /organization/i.test(message2) && !program.opts().org) {
       message2 += "\nThat is your configured default organization. Run `gauge orgs list` to see yours, then `gauge orgs use <org>` to update it.";
     }