@withgauge/cli 0.7.0 → 0.8.0

package/dist/index.js

@@ -57,6 +57,26 @@ var updateActionBodySchema = z.object({
   note: z.string().max(2e3).optional()
 });
 
+// ../packages/api-schemas/src/aiTraffic.ts
+import { z as z2 } from "zod";
+var drainPlatformSchema = z2.enum(["cloudflare", "custom", "vercel"]);
+var createDrainRequestSchema = z2.object({
+  platform: drainPlatformSchema.default("custom")
+});
+var drainSchema = z2.object({
+  id: z2.number().int().positive(),
+  tenantId: z2.string().uuid(),
+  platform: drainPlatformSchema,
+  drainUrl: z2.string().url(),
+  firstEventReceivedAt: z2.string().nullable(),
+  revokedAt: z2.string().nullable(),
+  /** One-time credential, present only on create/rotation. */
+  secret: z2.string().nullable().optional()
+});
+var listDrainsResponseSchema = z2.object({
+  items: z2.array(drainSchema.omit({ secret: true }))
+});
+
 // ../packages/api-schemas/src/batteries.ts
 var batteries_exports = {};
 __export(batteries_exports, {
@@ -83,10 +103,10 @@ __export(batteries_exports, {
   batterySkillsSchema: () => batterySkillsSchema,
   batterySpecSchema: () => batterySpecSchema
 });
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../packages/api-schemas/src/common.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var ERROR_CODES = [
   "unauthorized",
   "forbidden",
@@ -102,26 +122,41 @@ var ERROR_CODES = [
   // pre-0.6 clients drop the message on any code outside their enum.
   "upgrade_required"
 ];
-var errorCodeSchema = z2.enum(ERROR_CODES);
-var errorEnvelopeSchema = z2.object({
-  error: z2.object({
+var errorCodeSchema = z3.enum(ERROR_CODES);
+var upgradeOfferSchema = z3.object({
+  skuId: z3.string(),
+  tierLabel: z3.string(),
+  monthlyAmountCents: z3.number().int(),
+  monthlyCredits: z3.number().int(),
+  /** Browser URL of the organization's billing page. */
+  billingUrl: z3.string()
+});
+var errorEnvelopeSchema = z3.object({
+  error: z3.object({
     code: errorCodeSchema,
-    message: z2.string()
+    message: z3.string(),
+    upgrade: upgradeOfferSchema.optional()
   })
 });
-var listQuerySchema = z2.object({
-  limit: z2.coerce.number().int().min(1).max(200).default(50),
-  cursor: z2.string().optional()
+var listQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(200).default(50),
+  cursor: z3.string().optional()
 });
 function listResponseSchema(item) {
-  return z2.object({
-    items: z2.array(item),
-    nextCursor: z2.string().optional()
+  return z3.object({
+    items: z3.array(item),
+    nextCursor: z3.string().optional()
   });
 }
 
 // ../packages/api-schemas/src/batteries.ts
-var BATTERY_AGENTS = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
+var BATTERY_AGENTS = [
+  "CLAUDE_CODE",
+  "CODEX_CLI",
+  "CURSOR",
+  "PI",
+  "OPENCODE"
+];
 var BATTERY_CADENCES = [
   "NONE",
   "DAILY",
@@ -129,111 +164,111 @@ var BATTERY_CADENCES = [
   "MONTHLY",
   "DAYS_PER_WEEK"
 ];
-var batteryAgentSchema = z3.enum(BATTERY_AGENTS);
+var batteryAgentSchema = z4.enum(BATTERY_AGENTS);
 var BATTERY_MAX_LIMITS = {
   maxTurns: 30,
   wallClockS: 1800,
   maxUsd: 10
 };
 var MAX_SAMPLES_PER_CYCLE = 50;
-var batteryLimitsSchema = z3.object({
-  maxTurns: z3.number().positive().max(BATTERY_MAX_LIMITS.maxTurns).optional(),
-  wallClockS: z3.number().positive().max(BATTERY_MAX_LIMITS.wallClockS).optional(),
-  maxUsd: z3.number().positive().max(BATTERY_MAX_LIMITS.maxUsd).optional()
+var batteryLimitsSchema = z4.object({
+  maxTurns: z4.number().positive().max(BATTERY_MAX_LIMITS.maxTurns).optional(),
+  wallClockS: z4.number().positive().max(BATTERY_MAX_LIMITS.wallClockS).optional(),
+  maxUsd: z4.number().positive().max(BATTERY_MAX_LIMITS.maxUsd).optional()
 });
-var batterySkillRefSchema = z3.string().regex(
+var batterySkillRefSchema = z4.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 = z3.array(batterySkillRefSchema);
-var batteryScheduleSpecSchema = z3.object({
-  repoUrl: z3.string().nullish(),
-  repoRef: z3.string().nullish(),
+var batterySkillsSchema = z4.array(batterySkillRefSchema);
+var batteryScheduleSpecSchema = z4.object({
+  repoUrl: z4.string().nullish(),
+  repoRef: z4.string().nullish(),
   /** Pinned model id; `null` explicitly clears to the agent default (vs.
    *  omitted, which inherits `defaults.model`). */
-  model: z3.string().nullable().optional(),
-  agents: z3.array(batteryAgentSchema).optional(),
-  samplesPerCycle: z3.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),
-  cadence: z3.enum(BATTERY_CADENCES).optional(),
-  daysPerWeek: z3.number().int().min(1).max(7).optional(),
-  experiment: z3.string().optional(),
+  model: z4.string().nullable().optional(),
+  agents: z4.array(batteryAgentSchema).optional(),
+  samplesPerCycle: z4.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),
+  cadence: z4.enum(BATTERY_CADENCES).optional(),
+  daysPerWeek: z4.number().int().min(1).max(7).optional(),
+  experiment: z4.string().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 = z3.object({
-  isBranded: z3.boolean().optional(),
-  topic: z3.string().optional(),
-  tags: z3.array(z3.string()).optional(),
-  model: z3.string().nullable().optional(),
-  agents: z3.array(batteryAgentSchema).optional(),
-  samplesPerCycle: z3.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),
-  cadence: z3.enum(BATTERY_CADENCES).optional(),
+var batteryDefaultsSchema = z4.object({
+  isBranded: z4.boolean().optional(),
+  topic: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  model: z4.string().nullable().optional(),
+  agents: z4.array(batteryAgentSchema).optional(),
+  samplesPerCycle: z4.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),
+  cadence: z4.enum(BATTERY_CADENCES).optional(),
   limits: batteryLimitsSchema.optional(),
   /** ALG-217 — the skill set every target inherits unless it names its own. */
   skills: batterySkillsSchema.optional()
 });
-var batteryPromptSpecSchema = z3.object({
+var batteryPromptSpecSchema = z4.object({
   /** Idempotency key, unique per org (→ Prompt.externalKey). */
-  key: z3.string().min(1),
-  text: z3.string().min(1),
-  isBranded: z3.boolean().optional(),
-  topic: z3.string().optional(),
-  tags: z3.array(z3.string()).optional(),
-  experiment: z3.string().optional(),
+  key: z4.string().min(1),
+  text: z4.string().min(1),
+  isBranded: z4.boolean().optional(),
+  topic: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  experiment: z4.string().optional(),
   /** Omitted ⇒ one greenfield schedule from `defaults`. */
-  schedules: z3.array(batteryScheduleSpecSchema).optional()
+  schedules: z4.array(batteryScheduleSpecSchema).optional()
 });
-var batterySpecSchema = z3.object({
-  version: z3.literal(1),
-  org: z3.string().optional(),
-  experiment: z3.string().optional(),
+var batterySpecSchema = z4.object({
+  version: z4.literal(1),
+  org: z4.string().optional(),
+  experiment: z4.string().optional(),
   /** Expand + enqueue runs now (credit-gated on the API path). */
-  expand: z3.boolean().optional(),
+  expand: z4.boolean().optional(),
   defaults: batteryDefaultsSchema.optional(),
-  prompts: z3.array(batteryPromptSpecSchema).min(1)
+  prompts: z4.array(batteryPromptSpecSchema).min(1)
 });
-var batteryPlanScheduleSchema = z3.object({
-  action: z3.enum(["create", "update", "none"]),
-  repoUrl: z3.string().nullable(),
-  repoRef: z3.string().nullable(),
+var batteryPlanScheduleSchema = z4.object({
+  action: z4.enum(["create", "update", "none"]),
+  repoUrl: z4.string().nullable(),
+  repoRef: z4.string().nullable(),
   /** Runs this target would enqueue (agents × samples; 0 unless `expand`). */
-  runs: z3.number().int()
-});
-var batteryPlanPromptSchema = z3.object({
-  key: z3.string(),
-  action: z3.enum(["create", "update"]),
-  schedules: z3.array(batteryPlanScheduleSchema)
-});
-var batteryPlanSchema = z3.object({
-  dryRun: z3.literal(true),
-  org: z3.string(),
-  experiment: z3.string().nullable(),
-  expand: z3.boolean(),
-  prompts: z3.array(batteryPlanPromptSchema),
-  summary: z3.object({
-    promptsToCreate: z3.number().int(),
-    promptsToUpdate: z3.number().int(),
-    schedulesToCreate: z3.number().int(),
-    schedulesToUpdate: z3.number().int(),
-    runsToEnqueue: z3.number().int(),
+  runs: z4.number().int()
+});
+var batteryPlanPromptSchema = z4.object({
+  key: z4.string(),
+  action: z4.enum(["create", "update"]),
+  schedules: z4.array(batteryPlanScheduleSchema)
+});
+var batteryPlanSchema = z4.object({
+  dryRun: z4.literal(true),
+  org: z4.string(),
+  experiment: z4.string().nullable(),
+  expand: z4.boolean(),
+  prompts: z4.array(batteryPlanPromptSchema),
+  summary: z4.object({
+    promptsToCreate: z4.number().int(),
+    promptsToUpdate: z4.number().int(),
+    schedulesToCreate: z4.number().int(),
+    schedulesToUpdate: z4.number().int(),
+    runsToEnqueue: z4.number().int(),
     /** Run count keyed by agent (only populated when `expand`). */
-    runsByAgent: z3.record(z3.string(), z3.number().int()),
+    runsByAgent: z4.record(z4.string(), z4.number().int()),
     /** Flat estimate (runs × credits-per-run) for ORG-funded applies; the real
      *  gate (key gate, balance truncation, overage) runs at apply time. */
-    estimatedCredits: z3.number().int()
+    estimatedCredits: z4.number().int()
   })
 });
-var batteryApplyResponseSchema = z3.object({
-  batchIds: z3.array(z3.string()),
-  runIds: z3.array(z3.string()),
-  experiment: z3.string().nullable(),
+var batteryApplyResponseSchema = z4.object({
+  batchIds: z4.array(z4.string()),
+  runIds: z4.array(z4.string()),
+  experiment: z4.string().nullable(),
   /** Present when part of the expansion hit a billing gate but at least one
    *  run was enqueued (an all-blocked apply is a 402 error instead). */
-  blocked: z3.enum(["insufficient_credits", "needs_provider_key"]).optional()
+  blocked: z4.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
-var batchRunStatusSchema = z3.enum([
+var batchRunStatusSchema = z4.enum([
   "QUEUED",
   "CLAIMED",
   "PROVISIONING",
@@ -244,73 +279,118 @@ var batchRunStatusSchema = z3.enum([
   "CANCELED"
 ]);
 var batchListQuerySchema = listQuerySchema.extend({
-  promptId: z3.string().optional(),
-  experiment: z3.string().optional()
+  promptId: z4.string().optional(),
+  experiment: z4.string().optional()
 });
-var batchSummarySchema = z3.object({
-  id: z3.string(),
-  promptId: z3.string(),
+var batchSummarySchema = z4.object({
+  id: z4.string(),
+  promptId: z4.string(),
   /** Whitespace-collapsed prompt text, truncated (~80 chars) for list views;
    *  the full text is on GET /batches/{id}. */
-  promptText: z3.string(),
-  experiment: z3.string().nullable(),
-  createdAt: z3.string(),
+  promptText: z4.string(),
+  experiment: z4.string().nullable(),
+  createdAt: z4.string(),
   // ISO 8601
   /** Run count keyed by RunStatus (absent statuses omitted). */
-  runCounts: z3.record(z3.string(), z3.number().int())
+  runCounts: z4.record(z4.string(), z4.number().int())
 });
 var batchListResponseSchema = listResponseSchema(batchSummarySchema);
-var batchRunSummarySchema = z3.object({
-  id: z3.string(),
-  agent: z3.string(),
-  model: z3.string(),
+var batchRunSummarySchema = z4.object({
+  id: z4.string(),
+  agent: z4.string(),
+  model: z4.string(),
   status: batchRunStatusSchema,
-  createdAt: z3.string(),
-  startedAt: z3.string().nullable(),
-  finishedAt: z3.string().nullable()
-});
-var batchDetailSchema = z3.object({
-  id: z3.string(),
-  promptId: z3.string(),
-  scheduleId: z3.string().nullable(),
+  createdAt: z4.string(),
+  startedAt: z4.string().nullable(),
+  finishedAt: z4.string().nullable()
+});
+var batchDetailSchema = z4.object({
+  id: z4.string(),
+  promptId: z4.string(),
+  scheduleId: z4.string().nullable(),
   /** The preset this batch expanded from (specs/run-presets.md §4); null on
    *  pre-preset batches. `runPresetName` is a display snapshot frozen at
    *  expansion, so it survives preset renames and deletes. */
-  runPresetId: z3.string().nullable().optional(),
-  runPresetName: z3.string().nullable().optional(),
-  promptText: z3.string(),
-  scenario: z3.string(),
-  repoUrl: z3.string().nullable(),
-  repoRef: z3.string().nullable(),
-  experiment: z3.string().nullable(),
-  funding: z3.string(),
-  createdAt: z3.string(),
-  runCounts: z3.record(z3.string(), z3.number().int()),
-  runs: z3.array(batchRunSummarySchema)
+  runPresetId: z4.string().nullable().optional(),
+  runPresetName: z4.string().nullable().optional(),
+  promptText: z4.string(),
+  scenario: z4.string(),
+  repoUrl: z4.string().nullable(),
+  repoRef: z4.string().nullable(),
+  experiment: z4.string().nullable(),
+  funding: z4.string(),
+  createdAt: z4.string(),
+  runCounts: z4.record(z4.string(), z4.number().int()),
+  runs: z4.array(batchRunSummarySchema)
 });
 
 // ../packages/api-schemas/src/billing.ts
-import { z as z4 } from "zod";
-var billingStatusSchema = z4.object({
+import { z as z5 } from "zod";
+var billingTierSchema = z5.object({
+  skuId: z5.string(),
+  tierLabel: z5.string(),
+  position: z5.number().int(),
+  monthlyAmountCents: z5.number().int(),
+  /** The real, spendable allowance — base plus bonus. */
+  monthlyCredits: z5.number().int(),
+  /** What the price buys at list rate; the remainder is the volume discount,
+   *  handed back as bonus credits rather than a lower unit price. */
+  baseCredits: z5.number().int(),
+  bonusCredits: z5.number().int(),
+  dollarsPerThousandCredits: z5.number()
+});
+var billingCatalogSchema = z5.object({
+  catalogKey: z5.string(),
+  catalogLabel: z5.string(),
+  visibility: z5.enum(["PUBLIC", "PRIVATE"]),
+  tiers: z5.array(billingTierSchema)
+});
+var workloadCreditStateSchema = (value) => z5.object({
+  eval: value,
+  visibility: value,
+  generic: value
+});
+var billingStatusSchema = z5.object({
   /** When false, billing is disabled: unlimited runs. */
-  enforced: z4.boolean(),
-  balance: z4.number(),
-  /** Renewal allowance per cycle; null = free plan. */
-  allowance: z4.number().nullable(),
-  plan: z4.string().nullable(),
-  subscriptionStatus: z4.string().nullable(),
-  currentPeriodStart: z4.string().nullable(),
-  currentPeriodEnd: z4.string().nullable(),
-  overageEnabled: z4.boolean(),
-  overageCapCredits: z4.number().nullable(),
-  creditsUsedThisPeriod: z4.number(),
-  runsThisPeriod: z4.number(),
-  overageThisPeriod: z4.number(),
-  /** Can the org fund at least one more run right now. */
-  canRun: z4.boolean()
+  enforced: z5.boolean(),
+  balance: z5.number(),
+  /** The current tier's monthly allowance; null = no paid subscription. */
+  allowance: z5.number().nullable(),
+  /** What the organization pays for today. */
+  currentSku: billingTierSchema.nullable(),
+  /** The ladder it is allowed to buy from. */
+  offeredCatalog: billingCatalogSchema.nullable(),
+  /** The tier an upgrade resolves to; null = no self-service upgrade. */
+  nextTier: billingTierSchema.nullable(),
+  subscriptionStatus: z5.string().nullable(),
+  currentPeriodStart: z5.string().nullable(),
+  currentPeriodEnd: z5.string().nullable(),
+  cancelAtPeriodEnd: z5.boolean(),
+  creditsUsedThisPeriod: z5.number(),
+  runsThisPeriod: z5.number(),
+  /** @deprecated Generic-run compatibility value. Use `holdsPerRun`. */
+  holdPerRun: z5.number(),
+  /** @deprecated Generic-run compatibility value. Use `canRunByWorkload`. */
+  canRun: z5.boolean(),
+  /** Credits held to start one run, keyed by workload provenance. */
+  holdsPerRun: workloadCreditStateSchema(z5.number()),
+  /** Can the org fund at least one more run of each workload right now. */
+  canRunByWorkload: workloadCreditStateSchema(z5.boolean()),
+  // --- Deprecated. Retained for v1 compatibility; removal needs an API-version
+  // decision. Overage is retired, so these are always inert.
+  /** @deprecated Use `currentSku.tierLabel`. */
+  plan: z5.string().nullable(),
+  /** @deprecated Overage is retired; always false. */
+  overageEnabled: z5.boolean(),
+  /** @deprecated Overage is retired; always null. */
+  overageCapCredits: z5.number().nullable(),
+  /** @deprecated Overage is retired; always 0. */
+  overageThisPeriod: z5.number()
 });
 var LEDGER_KINDS = [
   "SIGNUP_GRANT",
+  "SUBSCRIPTION_GRANT",
+  "UPGRADE_GRANT",
   "RENEWAL_GRANT",
   "RUN_DEBIT",
   "RUN_REFUND",
@@ -318,18 +398,18 @@ var LEDGER_KINDS = [
   "ADMIN_ADJUST",
   "EXPIRY"
 ];
-var ledgerKindSchema = z4.enum(LEDGER_KINDS);
-var usageEntrySchema = z4.object({
-  id: z4.string(),
+var ledgerKindSchema = z5.enum(LEDGER_KINDS);
+var usageEntrySchema = z5.object({
+  id: z5.string(),
   kind: ledgerKindSchema,
-  delta: z4.number().int(),
-  runId: z4.string().nullable(),
-  batchId: z4.string().nullable(),
-  createdAt: z4.string()
+  delta: z5.number().int(),
+  runId: z5.string().nullable(),
+  batchId: z5.string().nullable(),
+  createdAt: z5.string()
 });
 var usageQuerySchema = listQuerySchema.extend({
   /** Relative window ("30d", "24h", "15m", "2w") or an ISO-8601 date/datetime. */
-  since: z4.string().optional()
+  since: z5.string().optional()
 });
 var usageListResponseSchema = listResponseSchema(usageEntrySchema);
 
@@ -348,9 +428,9 @@ __export(brands_exports, {
   listBrandsQuerySchema: () => listBrandsQuerySchema,
   updateBrandBodySchema: () => updateBrandBodySchema
 });
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var BRAND_KINDS = ["OWNED", "COMPETITOR", "OTHER"];
-var brandKindSchema = z5.enum(BRAND_KINDS);
+var brandKindSchema = z6.enum(BRAND_KINDS);
 var BRAND_PACKAGE_ECOSYSTEMS = [
   "npm",
   "pypi",
@@ -359,42 +439,42 @@ var BRAND_PACKAGE_ECOSYSTEMS = [
   "rubygems",
   "other"
 ];
-var brandPackageEcosystemSchema = z5.enum(BRAND_PACKAGE_ECOSYSTEMS);
-var brandPackageSchema = z5.object({
-  name: z5.string(),
-  ecosystem: z5.string().nullable()
-});
-var brandSchema = z5.object({
-  id: z5.string(),
-  name: z5.string(),
+var brandPackageEcosystemSchema = z6.enum(BRAND_PACKAGE_ECOSYSTEMS);
+var brandPackageSchema = z6.object({
+  name: z6.string(),
+  ecosystem: z6.string().nullable()
+});
+var brandSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
   kind: brandKindSchema,
   /** Provenance: MANUAL | BOOTSTRAP | OBSERVED (additive server-side). */
-  source: z5.string(),
-  aliases: z5.array(z5.string()),
-  websites: z5.array(z5.string()),
-  category: z5.string().nullable(),
-  packages: z5.array(brandPackageSchema),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
-});
-var brandPackageInputSchema = z5.object({
-  name: z5.string().min(1),
+  source: z6.string(),
+  aliases: z6.array(z6.string()),
+  websites: z6.array(z6.string()),
+  category: z6.string().nullable(),
+  packages: z6.array(brandPackageSchema),
+  createdAt: z6.string(),
+  updatedAt: z6.string()
+});
+var brandPackageInputSchema = z6.object({
+  name: z6.string().min(1),
   /** Omitted/null = "not a package-manager entry". */
   ecosystem: brandPackageEcosystemSchema.nullable().optional()
 });
-var createBrandBodySchema = z5.object({
-  name: z5.string().min(1),
+var createBrandBodySchema = z6.object({
+  name: z6.string().min(1),
   kind: brandKindSchema,
-  aliases: z5.array(z5.string().min(1)).default([]),
-  websites: z5.array(z5.string().min(1)).default([]),
-  packages: z5.array(brandPackageInputSchema).default([])
+  aliases: z6.array(z6.string().min(1)).default([]),
+  websites: z6.array(z6.string().min(1)).default([]),
+  packages: z6.array(brandPackageInputSchema).default([])
 });
-var updateBrandBodySchema = z5.object({
-  name: z5.string().min(1).optional(),
+var updateBrandBodySchema = z6.object({
+  name: z6.string().min(1).optional(),
   kind: brandKindSchema.optional(),
-  aliases: z5.array(z5.string().min(1)).optional(),
-  websites: z5.array(z5.string().min(1)).optional(),
-  packages: z5.array(brandPackageInputSchema).optional()
+  aliases: z6.array(z6.string().min(1)).optional(),
+  websites: z6.array(z6.string().min(1)).optional(),
+  packages: z6.array(brandPackageInputSchema).optional()
 });
 var listBrandsQuerySchema = listQuerySchema.extend({
   kind: brandKindSchema.optional()
@@ -402,27 +482,27 @@ var listBrandsQuerySchema = listQuerySchema.extend({
 var brandListResponseSchema = listResponseSchema(brandSchema);
 
 // ../packages/api-schemas/src/checkpoints.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var CHECKPOINT_STORE_VERSION = 2;
 var ALIGNED_CHECKPOINT_SUPERVISOR_ARTIFACT = "0.0.76-byok-ha-26071639";
 var ALIGNED_RUNSC_VERSION = "release-20260112.0";
 var ALIGNED_RUNSC_PLATFORM = "systrap";
 var SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
 var CHECKPOINT_ARTIFACT_PATTERN = /^alg-checkpoint:v2:sha256:[0-9a-f]{64}$/;
-var sha256DigestSchema = z6.custom(
+var sha256DigestSchema = z7.custom(
   (value) => typeof value === "string" && SHA256_PATTERN.test(value),
   "expected a sha256:<64 lowercase hex> digest"
 );
-var checkpointArtifactRefSchema = z6.custom(
+var checkpointArtifactRefSchema = z7.custom(
   (value) => typeof value === "string" && CHECKPOINT_ARTIFACT_PATTERN.test(value),
   "expected an alg-checkpoint:v2 artifact reference"
 );
-var publicArtifactScopeSchema = z6.object({ kind: z6.literal("public") });
-var orgArtifactScopeSchema = z6.object({
-  kind: z6.literal("org"),
-  organizationId: z6.string().min(1)
+var publicArtifactScopeSchema = z7.object({ kind: z7.literal("public") });
+var orgArtifactScopeSchema = z7.object({
+  kind: z7.literal("org"),
+  organizationId: z7.string().min(1)
 });
-var artifactScopeSchema = z6.discriminatedUnion("kind", [
+var artifactScopeSchema = z7.discriminatedUnion("kind", [
   publicArtifactScopeSchema,
   orgArtifactScopeSchema
 ]);
@@ -438,27 +518,27 @@ function manifestScopeReferenceViolation(manifestScope, referenced) {
   }
   return "a manifest must not reference another organization's object";
 }
-var checkpointStorePrincipalSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("system") }),
-  z6.object({
-    kind: z6.literal("organization"),
-    organizationId: z6.string().min(1)
+var checkpointStorePrincipalSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("system") }),
+  z7.object({
+    kind: z7.literal("organization"),
+    organizationId: z7.string().min(1)
   })
 ]);
-var checkpointChunkSchema = z6.object({
-  ordinal: z6.number().int().nonnegative(),
+var checkpointChunkSchema = z7.object({
+  ordinal: z7.number().int().nonnegative(),
   digest: sha256DigestSchema,
   rawDigest: sha256DigestSchema,
-  rawBytes: z6.number().int().positive(),
-  storedBytes: z6.number().int().positive()
+  rawBytes: z7.number().int().positive(),
+  storedBytes: z7.number().int().positive()
 });
-var chunkedPayloadSchema = z6.object({
-  format: z6.enum([
+var chunkedPayloadSchema = z7.object({
+  format: z7.enum([
     "canonical-workspace-chunked-zstd-v1",
     "runsc-checkpoint-chunked-zstd-v1",
     "overlay-upper-chunked-zstd-v1"
   ]),
-  chunks: z6.array(checkpointChunkSchema).min(1).superRefine((chunks, context) => {
+  chunks: z7.array(checkpointChunkSchema).min(1).superRefine((chunks, context) => {
     for (const [index, chunk] of chunks.entries()) {
       if (chunk.ordinal !== index) {
         context.addIssue({
@@ -471,10 +551,10 @@ var chunkedPayloadSchema = z6.object({
   })
 });
 var canonicalBaselinePayloadSchema = chunkedPayloadSchema.extend({
-  format: z6.literal("canonical-workspace-chunked-zstd-v1")
+  format: z7.literal("canonical-workspace-chunked-zstd-v1")
 });
-var nydusBaselineBlobSchema = z6.object({
-  nydusBlobId: z6.string().regex(/^[0-9a-f]{64}$/),
+var nydusBaselineBlobSchema = z7.object({
+  nydusBlobId: z7.string().regex(/^[0-9a-f]{64}$/),
   object: checkpointChunkSchema,
   /**
    * CAS scope this blob's object actually lives in, when it is NOT the manifest's own
@@ -492,34 +572,34 @@ var nydusBaselineBlobSchema = z6.object({
    */
   scope: artifactScopeSchema.optional()
 });
-var nydusBaselinePayloadSchema = z6.object({
-  format: z6.literal("nydus-rafs-v6"),
-  fsVersion: z6.literal(6),
+var nydusBaselinePayloadSchema = z7.object({
+  format: z7.literal("nydus-rafs-v6"),
+  fsVersion: z7.literal(6),
   /** Always the manifest's own scope: a build always produces its own bootstrap, so
    *  only inherited BLOBS can be foreign. Confining the override to where a foreign
    *  scope is possible is what keeps the invariant checkable. */
   bootstrap: checkpointChunkSchema,
-  blobs: z6.array(nydusBaselineBlobSchema)
+  blobs: z7.array(nydusBaselineBlobSchema)
 });
-var workspaceBaselinePayloadSchema = z6.discriminatedUnion("format", [
+var workspaceBaselinePayloadSchema = z7.discriminatedUnion("format", [
   canonicalBaselinePayloadSchema,
   nydusBaselinePayloadSchema
 ]);
-var workspaceBaselineManifestV2Schema = z6.object({
-  schemaVersion: z6.literal(CHECKPOINT_STORE_VERSION),
-  kind: z6.literal("workspace-baseline"),
+var workspaceBaselineManifestV2Schema = z7.object({
+  schemaVersion: z7.literal(CHECKPOINT_STORE_VERSION),
+  kind: z7.literal("workspace-baseline"),
   scope: artifactScopeSchema,
   workspaceRoot: sha256DigestSchema,
   payload: workspaceBaselinePayloadSchema,
-  repo: z6.object({
-    canonicalUrl: z6.string().url(),
-    requestedRef: z6.string().min(1),
-    resolvedCommit: z6.string().regex(/^[0-9a-f]{40,64}$/)
+  repo: z7.object({
+    canonicalUrl: z7.string().url(),
+    requestedRef: z7.string().min(1),
+    resolvedCommit: z7.string().regex(/^[0-9a-f]{40,64}$/)
   }),
-  recipe: z6.object({
+  recipe: z7.object({
     digest: sha256DigestSchema,
     sandboxImageDigest: sha256DigestSchema,
-    architecture: z6.string().min(1)
+    architecture: z7.string().min(1)
   })
 }).superRefine((manifest, context) => {
   if (manifest.payload.format !== "nydus-rafs-v6") return;
@@ -537,93 +617,111 @@ var workspaceBaselineManifestV2Schema = z6.object({
     }
   }
 });
-var checkpointBoundaryV2Schema = z6.object({
-  kind: z6.enum(["tool_call", "assistant_message", "user_message"]),
-  turn: z6.number().int().nonnegative(),
-  ordinal: z6.number().int().nonnegative(),
-  toolName: z6.string().optional(),
-  url: z6.string().url().optional()
+var checkpointBoundaryV2Schema = z7.object({
+  kind: z7.enum(["tool_call", "assistant_message", "user_message"]),
+  turn: z7.number().int().nonnegative(),
+  ordinal: z7.number().int().nonnegative(),
+  toolName: z7.string().optional(),
+  url: z7.string().url().optional()
 });
-var memoryDiskManifestV2Schema = z6.object({
-  schemaVersion: z6.literal(CHECKPOINT_STORE_VERSION),
-  kind: z6.literal("runsc-memory-disk"),
+var memoryDiskManifestV2Schema = z7.object({
+  schemaVersion: z7.literal(CHECKPOINT_STORE_VERSION),
+  kind: z7.literal("runsc-memory-disk"),
   scope: orgArtifactScopeSchema,
   boundary: checkpointBoundaryV2Schema,
   memory: chunkedPayloadSchema.extend({
-    format: z6.literal("runsc-checkpoint-chunked-zstd-v1")
+    format: z7.literal("runsc-checkpoint-chunked-zstd-v1")
   }),
-  disk: z6.object({
+  disk: z7.object({
     baselineArtifact: checkpointArtifactRefSchema,
     baselineScope: artifactScopeSchema,
     baselineWorkspaceRoot: sha256DigestSchema,
     delta: chunkedPayloadSchema.extend({
-      format: z6.literal("overlay-upper-chunked-zstd-v1")
+      format: z7.literal("overlay-upper-chunked-zstd-v1")
     })
   }),
-  runtime: z6.object({
-    runscVersion: z6.string().min(1),
-    platform: z6.string().min(1),
+  runtime: z7.object({
+    runscVersion: z7.string().min(1),
+    platform: z7.string().min(1),
     configDigest: sha256DigestSchema,
-    supervisorArtifact: z6.string().min(1),
-    architecture: z6.string().min(1)
+    supervisorArtifact: z7.string().min(1),
+    architecture: z7.string().min(1)
   }),
-  memorySharing: z6.literal("none")
+  memorySharing: z7.literal("none")
 });
-var workspaceSourceSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("nvme-baseline"),
+var workspaceSourceSchema = z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("nvme-baseline"),
     artifact: checkpointArtifactRefSchema,
     workspaceRoot: sha256DigestSchema,
     scope: artifactScopeSchema
   }),
-  z6.object({
-    kind: z6.literal("memory-disk"),
+  z7.object({
+    kind: z7.literal("memory-disk"),
     artifact: checkpointArtifactRefSchema,
     boundary: checkpointBoundaryV2Schema
   }),
-  z6.object({
-    kind: z6.literal("legacy-ebs"),
-    volumeSnapshot: z6.string().min(1),
-    resumeSessionId: z6.string().min(1).optional()
+  z7.object({
+    kind: z7.literal("legacy-ebs"),
+    volumeSnapshot: z7.string().min(1),
+    resumeSessionId: z7.string().min(1).optional()
   })
 ]);
-var baselinePayloadFormatSchema = z6.enum([
+var baselinePayloadFormatSchema = z7.enum([
   "canonical-workspace-chunked-zstd-v1",
   "runsc-checkpoint-chunked-zstd-v1",
   "overlay-upper-chunked-zstd-v1",
   "nydus-rafs-v6"
 ]);
-var checkpointStoreCapabilitiesSchema = z6.object({
-  storeVersion: z6.literal(CHECKPOINT_STORE_VERSION),
-  manifestSchemas: z6.array(z6.literal(CHECKPOINT_STORE_VERSION)).min(1),
-  payloadFormats: z6.array(baselinePayloadFormatSchema),
-  runtime: z6.object({
-    runscVersion: z6.literal(ALIGNED_RUNSC_VERSION),
-    platform: z6.literal(ALIGNED_RUNSC_PLATFORM),
-    supervisorArtifact: z6.literal(ALIGNED_CHECKPOINT_SUPERVISOR_ARTIFACT)
+var checkpointStoreCapabilitiesSchema = z7.object({
+  storeVersion: z7.literal(CHECKPOINT_STORE_VERSION),
+  manifestSchemas: z7.array(z7.literal(CHECKPOINT_STORE_VERSION)).min(1),
+  payloadFormats: z7.array(baselinePayloadFormatSchema),
+  runtime: z7.object({
+    runscVersion: z7.literal(ALIGNED_RUNSC_VERSION),
+    platform: z7.literal(ALIGNED_RUNSC_PLATFORM),
+    supervisorArtifact: z7.literal(ALIGNED_CHECKPOINT_SUPERVISOR_ARTIFACT)
   })
 });
 
 // ../packages/api-schemas/src/cli-auth.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var PKCE_VERIFIER_PATTERN = /^[A-Za-z0-9._~-]{43,128}$/;
-var cliAuthorizationTokenRequestSchema = z7.object({
-  code: z7.string().min(1).max(512),
-  codeVerifier: z7.string().regex(PKCE_VERIFIER_PATTERN)
+var cliAuthorizationTokenRequestSchema = z8.object({
+  code: z8.string().min(1).max(512),
+  codeVerifier: z8.string().regex(PKCE_VERIFIER_PATTERN)
 });
-var cliAuthorizationTokenResponseSchema = z7.object({
-  accessToken: z7.string(),
-  tokenType: z7.literal("bearer"),
-  expiresAt: z7.string().nullable()
+var cliAuthorizationTokenResponseSchema = z8.object({
+  accessToken: z8.string(),
+  tokenType: z8.literal("bearer"),
+  expiresAt: z8.string().nullable()
 });
 
-// ../packages/api-schemas/src/cycles.ts
+// ../packages/api-schemas/src/connections.ts
 import { z as z9 } from "zod";
+var MAX_CONNECTION_SET_ENTRIES = 32;
+var connectionSetEntrySchema = z9.object({
+  connectionId: z9.string().min(1),
+  handle: z9.string().min(1),
+  profileId: z9.string().min(1),
+  profileSlug: z9.string().min(1),
+  providerName: z9.string().min(1),
+  credentialKey: z9.string().min(1),
+  headerName: z9.string().min(1),
+  headerValuePrefix: z9.string()
+});
+var connectionSetSchema = z9.array(connectionSetEntrySchema).max(
+  MAX_CONNECTION_SET_ENTRIES,
+  `a run may attach at most ${MAX_CONNECTION_SET_ENTRIES} connections`
+);
+
+// ../packages/api-schemas/src/cycles.ts
+import { z as z11 } from "zod";
 
 // ../packages/api-schemas/src/schedules.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var AGENTS = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema = z8.enum(AGENTS);
+var agentSchema = z10.enum(AGENTS);
 var CADENCES = [
   "NONE",
   "DAILY",
@@ -631,89 +729,89 @@ var CADENCES = [
   "MONTHLY",
   "DAYS_PER_WEEK"
 ];
-var cadenceSchema = z8.enum(CADENCES);
-var daysPerWeekSchema = z8.number().int().min(1).max(7);
-var scheduleRepoSchema = z8.object({
-  repoUrl: z8.string().nullable(),
+var cadenceSchema = z10.enum(CADENCES);
+var daysPerWeekSchema = z10.number().int().min(1).max(7);
+var scheduleRepoSchema = z10.object({
+  repoUrl: z10.string().nullable(),
   /** Branch/ref; null = the repo's default branch (always null for greenfield). */
-  repoRef: z8.string().nullable()
+  repoRef: z10.string().nullable()
 });
-var scheduleAgentConfigSchema = z8.object({
+var scheduleAgentConfigSchema = z10.object({
   agent: agentSchema,
-  models: z8.array(z8.string().min(1)).default([])
+  models: z10.array(z10.string().min(1)).default([])
 });
-var scheduleAgentConfigInputSchema = z8.object({
+var scheduleAgentConfigInputSchema = z10.object({
   agent: agentSchema,
-  models: z8.array(z8.string().min(1)).optional(),
-  model: z8.string().min(1).nullish()
+  models: z10.array(z10.string().min(1)).optional(),
+  model: z10.string().min(1).nullish()
 }).transform(({ agent, models, model }) => ({
   agent,
   models: models ?? (model ? [model] : [])
 }));
-var scheduleSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
+var scheduleSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
   cadence: cadenceSchema,
   /** Only set when cadence is DAYS_PER_WEEK (1–7). */
-  daysPerWeek: z8.number().int().nullable(),
-  samplesPerCycle: z8.number().int(),
+  daysPerWeek: z10.number().int().nullable(),
+  samplesPerCycle: z10.number().int(),
   /** Authoritative per-agent configuration. */
-  agentConfigs: z8.array(scheduleAgentConfigSchema),
+  agentConfigs: z10.array(scheduleAgentConfigSchema),
   /** Deprecated compatibility projection of agentConfigs. */
-  agents: z8.array(agentSchema),
+  agents: z10.array(agentSchema),
   /** Deprecated: null for schedules with per-agent pins. */
-  model: z8.string().nullable(),
+  model: z10.string().nullable(),
   /** Repo targets in stable expansion order; empty = the default scaffold. A
    *  null-repoUrl entry is greenfield alongside named repos. */
-  repos: z8.array(scheduleRepoSchema),
+  repos: z10.array(scheduleRepoSchema),
   /** Cohort label for experiment analysis; null outside labeled experiments. */
-  experiment: z8.string().nullable(),
-  enabled: z8.boolean(),
-  lastExpandedAt: z8.string().nullable(),
+  experiment: z10.string().nullable(),
+  enabled: z10.boolean(),
+  lastExpandedAt: z10.string().nullable(),
   /** Membership tag ids — the schedule runs the live union of these tags'
    *  prompts (resolved at dispatch, not stored). */
-  tagIds: z8.array(z8.string()),
-  tagCount: z8.number().int(),
+  tagIds: z10.array(z10.string()),
+  tagCount: z10.number().int(),
   /** Persona matrix (ALG-155): member UserProfile ids, in stable expansion
    *  order. Empty = the default, unconfigured HaikuJudge (no persona). */
-  profileIds: z8.array(z8.string()),
+  profileIds: z10.array(z10.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: z8.boolean(),
-  createdAt: z8.string(),
-  updatedAt: z8.string()
+  includeDefaultPersona: z10.boolean(),
+  createdAt: z10.string(),
+  updatedAt: z10.string()
 });
 var scheduleListResponseSchema = listResponseSchema(scheduleSchema);
-var scheduleRepoInputSchema = z8.object({
+var scheduleRepoInputSchema = z10.object({
   /** null/omitted = the greenfield scaffold as an explicit target. */
-  repoUrl: z8.string().min(1).nullish(),
-  repoRef: z8.string().min(1).nullish()
+  repoUrl: z10.string().min(1).nullish(),
+  repoRef: z10.string().min(1).nullish()
 });
-var createScheduleBodyObject = z8.object({
-  name: z8.string().min(1, "name is required"),
+var createScheduleBodyObject = z10.object({
+  name: z10.string().min(1, "name is required"),
   cadence: cadenceSchema.default("NONE"),
   daysPerWeek: daysPerWeekSchema.optional(),
-  samplesPerCycle: z8.number().int().min(1).default(1),
+  samplesPerCycle: z10.number().int().min(1).default(1),
   /** Preferred paired representation (per-agent model tiers). */
-  agentConfigs: z8.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  agentConfigs: z10.array(scheduleAgentConfigInputSchema).min(1).optional(),
   /** Legacy shared-model input, accepted during the API transition. */
-  agents: z8.array(agentSchema).min(1, "Select at least one agent").optional(),
-  model: z8.string().min(1).nullish(),
+  agents: z10.array(agentSchema).min(1, "Select at least one agent").optional(),
+  model: z10.string().min(1).nullish(),
   /** Repo targets; empty = the default scaffold (greenfield). Add a
    *  null-repoUrl entry to run greenfield alongside named repos. */
-  repos: z8.array(scheduleRepoInputSchema).default([]),
+  repos: z10.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: z8.array(z8.string().min(1)).default([]),
+  tagIds: z10.array(z10.string().min(1)).default([]),
   /** Persona matrix (ALG-155): member UserProfile ids. Empty/omitted = the
    *  default, unconfigured HaikuJudge (no persona). */
-  profileIds: z8.array(z8.string().min(1)).default([]),
+  profileIds: z10.array(z10.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: z8.boolean().default(false),
-  enabled: z8.boolean().default(true)
+  includeDefaultPersona: z10.boolean().default(false),
+  enabled: z10.boolean().default(true)
 });
 var createScheduleBodySchema = createScheduleBodyObject.refine(
   (body) => body.agentConfigs !== void 0 || body.agents !== void 0,
@@ -722,115 +820,115 @@ var createScheduleBodySchema = createScheduleBodyObject.refine(
     path: ["agentConfigs"]
   }
 );
-var updateScheduleBodySchema = z8.object({
-  name: z8.string().min(1).optional(),
+var updateScheduleBodySchema = z10.object({
+  name: z10.string().min(1).optional(),
   cadence: cadenceSchema.optional(),
   daysPerWeek: daysPerWeekSchema.optional(),
-  samplesPerCycle: z8.number().int().min(1).optional(),
+  samplesPerCycle: z10.number().int().min(1).optional(),
   /** Full replacement of the enabled agent/model set (per-agent model tiers). */
-  agentConfigs: z8.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  agentConfigs: z10.array(scheduleAgentConfigInputSchema).min(1).optional(),
   /** Legacy shared-model input, accepted during the API transition. */
-  agents: z8.array(agentSchema).min(1, "Select at least one agent").optional(),
-  model: z8.string().min(1).nullish(),
-  repos: z8.array(scheduleRepoInputSchema).optional(),
-  tagIds: z8.array(z8.string().min(1)).optional(),
-  profileIds: z8.array(z8.string().min(1)).optional(),
-  includeDefaultPersona: z8.boolean().optional(),
-  enabled: z8.boolean().optional()
-});
-var runScheduleResponseSchema = z8.object({
-  batchIds: z8.array(z8.string()),
-  runIds: z8.array(z8.string()),
-  blocked: z8.enum(["insufficient_credits", "needs_provider_key"]).optional(),
-  notReady: z8.array(
-    z8.object({
-      repoUrl: z8.string(),
-      status: z8.enum(["building", "failed", "none"])
+  agents: z10.array(agentSchema).min(1, "Select at least one agent").optional(),
+  model: z10.string().min(1).nullish(),
+  repos: z10.array(scheduleRepoInputSchema).optional(),
+  tagIds: z10.array(z10.string().min(1)).optional(),
+  profileIds: z10.array(z10.string().min(1)).optional(),
+  includeDefaultPersona: z10.boolean().optional(),
+  enabled: z10.boolean().optional()
+});
+var runScheduleResponseSchema = z10.object({
+  batchIds: z10.array(z10.string()),
+  runIds: z10.array(z10.string()),
+  blocked: z10.enum(["insufficient_credits", "needs_provider_key"]).optional(),
+  notReady: z10.array(
+    z10.object({
+      repoUrl: z10.string(),
+      status: z10.enum(["building", "failed", "none"])
     })
   ).optional()
 });
 
 // ../packages/api-schemas/src/cycles.ts
-var cycleSchema = z9.object({
-  id: z9.string(),
-  name: z9.string(),
+var cycleSchema = z11.object({
+  id: z11.string(),
+  name: z11.string(),
   cadence: cadenceSchema,
-  samplesPerCycle: z9.number().int(),
-  enabled: z9.boolean()
+  samplesPerCycle: z11.number().int(),
+  enabled: z11.boolean()
 });
 var cycleWithCountsSchema = cycleSchema.extend({
-  evalSetCount: z9.number().int(),
-  visibilityPromptCount: z9.number().int()
+  evalSetCount: z11.number().int(),
+  visibilityPromptCount: z11.number().int()
 });
-var listCyclesResponseSchema = z9.object({
-  items: z9.array(cycleWithCountsSchema)
+var listCyclesResponseSchema = z11.object({
+  items: z11.array(cycleWithCountsSchema)
 });
 var CYCLE_CADENCES = ["NONE", "DAILY", "WEEKLY", "MONTHLY"];
-var cycleCadenceSchema = z9.enum(CYCLE_CADENCES);
-var updateCycleBodySchema = z9.object({
+var cycleCadenceSchema = z11.enum(CYCLE_CADENCES);
+var updateCycleBodySchema = z11.object({
   cadence: cycleCadenceSchema
 });
 
 // ../packages/api-schemas/src/dashboards.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 
 // ../packages/api-schemas/src/query.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // ../packages/api-schemas/src/stats.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 var BRAND_KINDS2 = ["OWNED", "COMPETITOR", "OTHER"];
-var brandKindSchema2 = z10.enum(BRAND_KINDS2);
-var brandRankingSchema = z10.object({
-  rank: z10.number().int(),
-  brandId: z10.string(),
-  brandName: z10.string(),
+var brandKindSchema2 = z12.enum(BRAND_KINDS2);
+var brandRankingSchema = z12.object({
+  rank: z12.number().int(),
+  brandId: z12.string(),
+  brandName: z12.string(),
   kind: brandKindSchema2,
-  installs: z10.number().int(),
-  installRate: z10.number(),
-  mentionRate: z10.number(),
+  installs: z12.number().int(),
+  installRate: z12.number(),
+  mentionRate: z12.number(),
   /** Movement between the two most recent batch windows; null if not ranked in both. */
-  deltaRank: z10.number().int().nullable()
+  deltaRank: z12.number().int().nullable()
 });
-var packageRateSchema = z10.object({
-  ecosystem: z10.string(),
-  name: z10.string(),
-  brandName: z10.string().optional(),
+var packageRateSchema = z12.object({
+  ecosystem: z12.string(),
+  name: z12.string(),
+  brandName: z12.string().optional(),
   kind: brandKindSchema2.optional(),
-  installs: z10.number().int(),
-  rate: z10.number()
+  installs: z12.number().int(),
+  rate: z12.number()
 });
-var brandRateSchema = z10.object({
-  brandId: z10.string(),
-  brandName: z10.string(),
+var brandRateSchema = z12.object({
+  brandId: z12.string(),
+  brandName: z12.string(),
   kind: brandKindSchema2,
-  installs: z10.number().int(),
-  rate: z10.number()
+  installs: z12.number().int(),
+  rate: z12.number()
 });
-var brandFunnelRowSchema = z10.object({
-  brandId: z10.string(),
-  brandName: z10.string(),
+var brandFunnelRowSchema = z12.object({
+  brandId: z12.string(),
+  brandName: z12.string(),
   kind: brandKindSchema2,
-  mentionRate: z10.number(),
-  installRate: z10.number()
-});
-var domainRateSchema = z10.object({
-  domain: z10.string(),
-  runs: z10.number().int(),
-  rate: z10.number(),
-  requests: z10.number().int(),
-  brandName: z10.string().optional(),
-  owned: z10.boolean().optional()
-});
-var statsFreshnessSchema = z10.object({
+  mentionRate: z12.number(),
+  installRate: z12.number()
+});
+var domainRateSchema = z12.object({
+  domain: z12.string(),
+  runs: z12.number().int(),
+  rate: z12.number(),
+  requests: z12.number().int(),
+  brandName: z12.string().optional(),
+  owned: z12.boolean().optional()
+});
+var statsFreshnessSchema = z12.object({
   /** Newest run-ingest time across the org (ISO), or null if nothing ingested. */
-  watermark: z10.string().nullable(),
+  watermark: z12.string().nullable(),
   /** Runs that succeeded recently but haven't landed in the warehouse yet. */
-  pending: z10.number().int(),
+  pending: z12.number().int(),
   /** False when the freshness read itself failed (distinguish from genuine zero). */
-  available: z10.boolean()
+  available: z12.boolean()
 });
-var statsResponseSchema = (item) => z10.object({ items: z10.array(item), freshness: statsFreshnessSchema });
+var statsResponseSchema = (item) => z12.object({ items: z12.array(item), freshness: statsFreshnessSchema });
 var rankingsResponseSchema = statsResponseSchema(brandRankingSchema);
 var installsResponseSchema = statsResponseSchema(packageRateSchema);
 var brandsResponseSchema = statsResponseSchema(brandRateSchema);
@@ -849,7 +947,7 @@ var DATASETS = [
   "tokens",
   "brand_rollup"
 ];
-var datasetSchema = z11.enum(DATASETS);
+var datasetSchema = z13.enum(DATASETS);
 var WHERE_OPS = [
   "eq",
   "neq",
@@ -861,216 +959,216 @@ var WHERE_OPS = [
   "lt",
   "lte"
 ];
-var whereOpSchema = z11.enum(WHERE_OPS);
+var whereOpSchema = z13.enum(WHERE_OPS);
 var GRANULARITIES = ["day", "week", "month"];
-var granularitySchema = z11.enum(GRANULARITIES);
+var granularitySchema = z13.enum(GRANULARITIES);
 var DEFAULT_QUERY_LIMIT = 50;
 var MAX_QUERY_LIMIT = 1e3;
-var scalar = z11.union([z11.string(), z11.number(), z11.boolean()]);
-var whereClauseSchema = z11.object({
-  dimension: z11.string().min(1),
+var scalar = z13.union([z13.string(), z13.number(), z13.boolean()]);
+var whereClauseSchema = z13.object({
+  dimension: z13.string().min(1),
   op: whereOpSchema,
-  value: z11.union([scalar, z11.array(scalar)])
-});
-var queryFiltersSchema = z11.object({
-  prompt: z11.string(),
-  topic: z11.array(z11.string()),
-  tag: z11.array(z11.string()),
-  repo: z11.array(z11.string()),
-  language: z11.array(z11.string()),
-  framework: z11.array(z11.string()),
-  size: z11.array(z11.string()),
-  agent: z11.array(z11.string()),
+  value: z13.union([scalar, z13.array(scalar)])
+});
+var queryFiltersSchema = z13.object({
+  prompt: z13.string(),
+  topic: z13.array(z13.string()),
+  tag: z13.array(z13.string()),
+  repo: z13.array(z13.string()),
+  language: z13.array(z13.string()),
+  framework: z13.array(z13.string()),
+  size: z13.array(z13.string()),
+  agent: z13.array(z13.string()),
   /** Persona UserProfile ids; the NO_PERSONA sentinel = default judge. */
-  persona: z11.array(z11.string()),
-  model: z11.array(z11.string()),
-  scenario: z11.array(z11.string()),
-  experiment: z11.array(z11.string()),
-  branded: z11.boolean()
+  persona: z13.array(z13.string()),
+  model: z13.array(z13.string()),
+  scenario: z13.array(z13.string()),
+  experiment: z13.array(z13.string()),
+  branded: z13.boolean()
 }).partial();
-var dateRangeSchema = z11.object({
-  since: z11.string(),
-  until: z11.string(),
-  lastDays: z11.number().int().positive()
+var dateRangeSchema = z13.object({
+  since: z13.string(),
+  until: z13.string(),
+  lastDays: z13.number().int().positive()
 }).partial();
-var orderBySchema = z11.object({
+var orderBySchema = z13.object({
   /** A selected dimension or metric name. */
-  key: z11.string().min(1),
-  dir: z11.enum(["asc", "desc"]).default("desc")
+  key: z13.string().min(1),
+  dir: z13.enum(["asc", "desc"]).default("desc")
 });
-var querySpecSchema = z11.object({
+var querySpecSchema = z13.object({
   dataset: datasetSchema.default("runs"),
-  dimensions: z11.array(z11.string()).default([]),
-  metrics: z11.array(z11.string()).min(1, "at least one metric is required"),
+  dimensions: z13.array(z13.string()).default([]),
+  metrics: z13.array(z13.string()).min(1, "at least one metric is required"),
   filters: queryFiltersSchema.default({}),
-  where: z11.array(whereClauseSchema).default([]),
+  where: z13.array(whereClauseSchema).default([]),
   dateRange: dateRangeSchema.optional(),
-  orderBy: z11.array(orderBySchema).default([]),
-  limit: z11.number().int().min(1).max(MAX_QUERY_LIMIT).default(DEFAULT_QUERY_LIMIT),
+  orderBy: z13.array(orderBySchema).default([]),
+  limit: z13.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: z11.boolean().default(false)
+  explain: z13.boolean().default(false)
 });
-var columnKindSchema = z11.enum(["dimension", "metric"]);
-var queryColumnSchema = z11.object({
-  key: z11.string(),
+var columnKindSchema = z13.enum(["dimension", "metric"]);
+var queryColumnSchema = z13.object({
+  key: z13.string(),
   kind: columnKindSchema
 });
-var queryRowSchema = z11.record(
-  z11.string(),
-  z11.union([z11.string(), z11.number(), z11.boolean(), z11.null()])
+var queryRowSchema = z13.record(
+  z13.string(),
+  z13.union([z13.string(), z13.number(), z13.boolean(), z13.null()])
 );
-var queryResponseSchema = z11.object({
-  columns: z11.array(queryColumnSchema),
-  rows: z11.array(queryRowSchema),
+var queryResponseSchema = z13.object({
+  columns: z13.array(queryColumnSchema),
+  rows: z13.array(queryRowSchema),
   /** Present only when the request set explain=true. */
-  sql: z11.string().optional(),
+  sql: z13.string().optional(),
   freshness: statsFreshnessSchema
 });
-var fieldTypeSchema = z11.enum([
+var fieldTypeSchema = z13.enum([
   "string",
   "number",
   "rate",
   "date",
   "boolean"
 ]);
-var fieldSchema = z11.object({
-  name: z11.string(),
+var fieldSchema = z13.object({
+  name: z13.string(),
   type: fieldTypeSchema,
   /** One-line human/agent hint. */
-  description: z11.string().optional()
+  description: z13.string().optional()
 });
-var datasetMetaSchema = z11.object({
+var datasetMetaSchema = z13.object({
   name: datasetSchema,
-  grain: z11.string(),
-  dimensions: z11.array(fieldSchema),
-  metrics: z11.array(fieldSchema)
+  grain: z13.string(),
+  dimensions: z13.array(fieldSchema),
+  metrics: z13.array(fieldSchema)
 });
-var metadataResponseSchema = z11.object({
-  datasets: z11.array(datasetMetaSchema)
+var metadataResponseSchema = z13.object({
+  datasets: z13.array(datasetMetaSchema)
 });
 
 // ../packages/api-schemas/src/dashboards.ts
 var VIZ_TYPES = ["line", "bar", "table", "kpi"];
-var vizTypeSchema = z12.enum(VIZ_TYPES);
-var widgetEncodingSchema = z12.object({
-  x: z12.string(),
+var vizTypeSchema = z14.enum(VIZ_TYPES);
+var widgetEncodingSchema = z14.object({
+  x: z14.string(),
   // dimension key for the x axis (line)
-  series: z12.string(),
+  series: z14.string(),
   // dimension key split into one series per value (line)
-  y: z12.array(z12.string())
+  y: z14.array(z14.string())
   // metric keys for the value axis
 }).partial();
 var widgetFields = {
-  id: z12.string().min(1),
-  title: z12.string(),
+  id: z14.string().min(1),
+  title: z14.string(),
   viz: vizTypeSchema,
   spec: querySpecSchema,
   // 12-col grid placement.
-  x: z12.number().int().min(0).max(11),
-  y: z12.number().int().min(0),
-  w: z12.number().int().min(1).max(12),
-  h: z12.number().int().min(1),
+  x: z14.number().int().min(0).max(11),
+  y: z14.number().int().min(0),
+  w: z14.number().int().min(1).max(12),
+  h: z14.number().int().min(1),
   encoding: widgetEncodingSchema.optional()
 };
-var widgetSchema = z12.object(widgetFields).refine((w) => w.x + w.w <= 12, {
+var widgetSchema = z14.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 = z12.object(widgetFields).partial();
-var dashboardFiltersSchema = z12.object({
+var widgetPatchSchema = z14.object(widgetFields).partial();
+var dashboardFiltersSchema = z14.object({
   filters: queryFiltersSchema,
   dateRange: dateRangeSchema
 }).partial();
-var overlayPatchSchema = z12.object({
-  name: z12.string(),
+var overlayPatchSchema = z14.object({
+  name: z14.string(),
   defaultFilters: dashboardFiltersSchema,
-  widgets: z12.record(z12.string(), widgetPatchSchema.nullable()),
+  widgets: z14.record(z14.string(), widgetPatchSchema.nullable()),
   // Explicit widget-id ordering (for reordering and from-scratch widgets).
-  order: z12.array(z12.string())
+  order: z14.array(z14.string())
 }).partial();
-var resolvedDashboardSchema = z12.object({
-  key: z12.string(),
-  name: z12.string(),
-  widgets: z12.array(widgetSchema),
+var resolvedDashboardSchema = z14.object({
+  key: z14.string(),
+  name: z14.string(),
+  widgets: z14.array(widgetSchema),
   defaultFilters: dashboardFiltersSchema,
-  hasOrgOverlay: z12.boolean(),
-  hasUserOverlay: z12.boolean()
+  hasOrgOverlay: z14.boolean(),
+  hasUserOverlay: z14.boolean()
 });
-var dashboardTemplateSchema = z12.object({
-  key: z12.string().min(1),
-  name: z12.string(),
-  description: z12.string().optional(),
-  widgets: z12.array(widgetSchema),
+var dashboardTemplateSchema = z14.object({
+  key: z14.string().min(1),
+  name: z14.string(),
+  description: z14.string().optional(),
+  widgets: z14.array(widgetSchema),
   defaultFilters: dashboardFiltersSchema.optional()
 });
-var dashboardSummarySchema = z12.object({
-  key: z12.string(),
-  name: z12.string(),
-  source: z12.enum(["template", "org", "user"]),
-  isUserDefault: z12.boolean(),
-  isOrgDefault: z12.boolean()
+var dashboardSummarySchema = z14.object({
+  key: z14.string(),
+  name: z14.string(),
+  source: z14.enum(["template", "org", "user"]),
+  isUserDefault: z14.boolean(),
+  isOrgDefault: z14.boolean()
 });
-var listDashboardsResponseSchema = z12.object({
-  items: z12.array(dashboardSummarySchema)
+var listDashboardsResponseSchema = z14.object({
+  items: z14.array(dashboardSummarySchema)
 });
-var createDashboardBodySchema = z12.object({
-  name: z12.string().min(1).max(120),
-  widgets: z12.array(widgetSchema).optional()
+var createDashboardBodySchema = z14.object({
+  name: z14.string().min(1).max(120),
+  widgets: z14.array(widgetSchema).optional()
 });
-var updateDashboardBodySchema = z12.object({
-  name: z12.string().min(1).max(120)
+var updateDashboardBodySchema = z14.object({
+  name: z14.string().min(1).max(120)
 });
 
 // ../packages/api-schemas/src/device.ts
-import { z as z13 } from "zod";
-var deviceAuthorizeRequestSchema = z13.object({
+import { z as z15 } from "zod";
+var deviceAuthorizeRequestSchema = z15.object({
   /** Device label (the CLI's hostname) for display + token naming. */
-  deviceName: z13.string().trim().max(64).optional(),
+  deviceName: z15.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: z13.string().trim().email().max(320).optional()
+  email: z15.string().trim().email().max(320).optional()
 });
-var deviceAuthorizeResponseSchema = z13.object({
+var deviceAuthorizeResponseSchema = z15.object({
   /** The one-time secret the CLI polls with (never shown again). */
-  deviceCode: z13.string(),
+  deviceCode: z15.string(),
   /** Short human-typed code the user confirms in the browser (e.g. WXYZ-1234). */
-  userCode: z13.string(),
+  userCode: z15.string(),
   /** Where the user approves (e.g. https://…/cli/authorize). */
-  verificationUri: z13.string(),
+  verificationUri: z15.string(),
   /** verificationUri with the code pre-filled, for one-click / QR. */
-  verificationUriComplete: z13.string(),
+  verificationUriComplete: z15.string(),
   /** Minimum seconds between polls. */
-  interval: z13.number().int().positive(),
+  interval: z15.number().int().positive(),
   /** Seconds until the device code expires. */
-  expiresIn: z13.number().int().positive(),
+  expiresIn: z15.number().int().positive(),
   /** Whether a magic-link email was dispatched (best-effort). */
-  emailSent: z13.boolean()
+  emailSent: z15.boolean()
 });
-var deviceTokenRequestSchema = z13.object({
-  deviceCode: z13.string().min(1)
+var deviceTokenRequestSchema = z15.object({
+  deviceCode: z15.string().min(1)
 });
-var deviceTokenApprovedSchema = z13.object({
-  status: z13.literal("approved"),
+var deviceTokenApprovedSchema = z15.object({
+  status: z15.literal("approved"),
   /** The `gauge_…` bearer secret. Store it now — never returned again. */
-  accessToken: z13.string(),
-  tokenType: z13.literal("bearer"),
+  accessToken: z15.string(),
+  tokenType: z15.literal("bearer"),
   /** ISO-8601 expiry, or null for no expiry. */
-  expiresAt: z13.string().nullable()
+  expiresAt: z15.string().nullable()
 });
-var deviceTokenResultSchema = z13.discriminatedUnion("status", [
+var deviceTokenResultSchema = z15.discriminatedUnion("status", [
   // Not yet approved — keep polling at `interval`.
-  z13.object({ status: z13.literal("pending") }),
+  z15.object({ status: z15.literal("pending") }),
   // Polled faster than `interval` — back off by `interval` seconds.
-  z13.object({ status: z13.literal("slow_down"), interval: z13.number().int() }),
+  z15.object({ status: z15.literal("slow_down"), interval: z15.number().int() }),
   // The user explicitly denied the request. Stop.
-  z13.object({ status: z13.literal("denied") }),
+  z15.object({ status: z15.literal("denied") }),
   // The device code expired or is unknown/already-redeemed. Stop and restart.
-  z13.object({ status: z13.literal("expired") }),
+  z15.object({ status: z15.literal("expired") }),
   deviceTokenApprovedSchema
 ]);
 
 // ../packages/api-schemas/src/evals.ts
-import { z as z15 } from "zod";
+import { z as z19 } from "zod";
 
 // ../packages/api-schemas/src/runPresets.ts
 var runPresets_exports = {};
@@ -1101,18 +1199,308 @@ __export(runPresets_exports, {
   totalRunsPerCycle: () => totalRunsPerCycle,
   updateRunPresetBodySchema: () => updateRunPresetBodySchema
 });
-import { z as z14 } from "zod";
-var SCHEDULABLE_AGENTS = ["CLAUDE_CODE", "CODEX_CLI"];
-var schedulableAgentSchema = z14.enum(SCHEDULABLE_AGENTS);
-var presetAgentSchema = z14.object({
-  agent: agentSchema,
-  models: z14.array(z14.string().min(1))
+import { z as z18 } from "zod";
+
+// ../packages/api-schemas/src/runs.ts
+import { z as z17 } from "zod";
+
+// ../packages/api-schemas/src/web-fixtures.ts
+import { z as z16 } 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 = z16.object({
+  title: z16.string().min(1),
+  url: z16.url().transform(withoutFragment),
+  snippet: z16.string()
+});
+var searchFixtureSchema = z16.object({
+  query: z16.string().trim().min(1),
+  results: z16.array(searchResultSchema)
+});
+var pageFixtureSchema = z16.object({
+  url: z16.url().transform(withoutFragment),
+  status: z16.int().min(100).max(599).default(200),
+  contentType: z16.string().trim().min(1).default("text/html"),
+  body: z16.string()
+});
+var webFixtureSchema = z16.object({
+  version: z16.literal(1),
+  searches: z16.array(searchFixtureSchema).default([]),
+  pages: z16.array(pageFixtureSchema).default([])
+}).superRefine((fixture, ctx) => {
+  const queries = /* @__PURE__ */ new Set();
+  fixture.searches.forEach((entry, index) => {
+    if (queries.has(entry.query)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["searches", index, "query"],
+        message: `duplicate normalized query: ${entry.query}`
+      });
+    }
+    queries.add(entry.query);
+  });
+  const urls = /* @__PURE__ */ new Set();
+  fixture.pages.forEach((entry, index) => {
+    if (urls.has(entry.url)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["pages", index, "url"],
+        message: `duplicate normalized URL: ${entry.url}`
+      });
+    }
+    urls.add(entry.url);
+  });
+  const bytes = new TextEncoder().encode(JSON.stringify(fixture)).byteLength;
+  if (bytes > MAX_WEB_FIXTURE_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: `serialized fixture is ${bytes} bytes; maximum is ${MAX_WEB_FIXTURE_BYTES}`
+    });
+  }
 });
-var presetAgentInputSchema = z14.object({
+
+// ../packages/api-schemas/src/runs.ts
+var RUN_STATUSES = [
+  "QUEUED",
+  "CLAIMED",
+  "PROVISIONING",
+  "RUNNING",
+  "SUCCEEDED",
+  "FAILED",
+  "TIMED_OUT",
+  "CANCELED"
+];
+var runStatusSchema = z17.enum(RUN_STATUSES);
+var AGENTS2 = [
+  "CLAUDE_CODE",
+  "CODEX_CLI",
+  "CURSOR",
+  "PI",
+  "OPENCODE"
+];
+var agentSchema2 = z17.enum(AGENTS2);
+var OBSERVED_PROVIDER_SOURCES = [
+  "AGENT_STREAM",
+  "GATEWAY_RESPONSE",
+  "GATEWAY_AUDIT",
+  "CANARY"
+];
+var observedProviderSourceSchema = z17.enum(OBSERVED_PROVIDER_SOURCES);
+var selectedProviderSchema = z17.object({
+  slug: z17.string(),
+  displayName: z17.string()
+});
+var observedProviderSchema = z17.object({
+  slug: z17.string(),
+  source: observedProviderSourceSchema
+});
+var runStatusFilterSchema = z17.string().transform(
+  (raw) => raw.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean)
+).pipe(z17.array(runStatusSchema).min(1));
+var runListQuerySchema = listQuerySchema.extend({
+  status: runStatusFilterSchema.optional(),
+  batch: z17.string().optional(),
+  prompt: z17.string().optional(),
+  experiment: z17.string().optional(),
+  evalSet: z17.string().optional(),
+  since: z17.string().optional()
+});
+var runListItemSchema = z17.object({
+  id: z17.string(),
+  status: runStatusSchema,
+  agent: agentSchema2,
+  /** Requested logical-model pin. Empty means the platform default was used. */
+  model: z17.string(),
+  /** Model reported by the harness; null until observed or on legacy runs. */
+  resolvedModel: z17.string().nullable().optional(),
+  /** Catalog presentation label for the selected logical model. */
+  modelDisplayName: z17.string().nullable().optional(),
+  /** Catalog provider selected before execution; null on legacy runs. */
+  selectedProvider: selectedProviderSchema.nullable().optional(),
+  /** Trusted terminal upstream observation; may differ from the selected
+   * aggregator and is null when the runtime supplies no provenance. */
+  observedProvider: observedProviderSchema.nullable().optional(),
+  promptId: z17.string(),
+  /** First ~80 chars of the batch's prompt snapshot, whitespace-collapsed. */
+  promptSnippet: z17.string(),
+  batchId: z17.string(),
+  experiment: z17.string().nullable(),
+  /** The eval set whose expansion (or backfill) minted the batch; null for
+   *  schedule/visibility/ad-hoc runs. */
+  evalSetId: z17.string().nullable(),
+  turns: z17.number().int().nullable(),
+  usdCost: z17.number().nullable(),
+  durationMs: z17.number().int().nullable(),
+  exitReason: z17.string().nullable(),
+  createdAt: z17.string(),
+  startedAt: z17.string().nullable(),
+  finishedAt: z17.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: z17.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: z17.string().nullable()
+});
+var runListResponseSchema = listResponseSchema(runListItemSchema);
+var runDetailSchema = runListItemSchema.omit({ promptSnippet: true }).extend({
+  promptText: z17.string(),
+  attempt: z17.number().int(),
+  cancelRequested: z17.boolean(),
+  failureReason: z17.string().nullable(),
+  repoUrl: z17.string().nullable(),
+  repoRef: z17.string().nullable(),
+  scenario: z17.string(),
+  funding: z17.string(),
+  /** Raw harness usage write-back (token counts etc.); shape may evolve. */
+  usage: z17.unknown().nullable(),
+  /** Artifact pointer: a working-tree diff exists at GET /runs/{id}/diff. */
+  hasDiff: z17.boolean(),
+  claimedAt: z17.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: z17.array(
+    z17.object({
+      criterionId: z17.string().nullable(),
+      name: z17.string(),
+      passed: z17.boolean(),
+      reasoning: z17.string().nullable()
+    })
+  )
+});
+var cancelRunResponseSchema = z17.object({
+  id: z17.string(),
+  status: runStatusSchema,
+  cancelRequested: z17.boolean(),
+  note: z17.string().optional()
+});
+var forkRunBodySchema = z17.object({
+  prompt: z17.string().trim().min(1).max(2e4),
+  turn: z17.number().int().min(0).optional(),
+  webFixture: webFixtureSchema.optional()
+});
+var forkRunResponseSchema = z17.object({
+  runId: z17.string(),
+  batchId: z17.string(),
+  parentRunId: z17.string(),
+  checkpointId: z17.string(),
+  turn: z17.number().int().min(0)
+});
+var fetchForkAtFetchBodySchema = z17.object({
+  boundarySeq: z17.string().min(1),
+  injectedContent: z17.string(),
+  prompts: z17.array(z17.string()).min(1)
+});
+var fetchForkAtFetchResponseSchema = z17.object({
+  planId: z17.string()
+});
+var fetchForkPlanStatusSchema = z17.enum([
+  "DRAFT",
+  "SURGERY_RUNNING",
+  "SURGERY_READY",
+  "FORKED",
+  "FAILED"
+]);
+var fetchForkPlanResponseSchema = z17.object({
+  id: z17.string(),
+  status: fetchForkPlanStatusSchema,
+  boundaryUrl: z17.string(),
+  boundaryTurn: z17.number().int(),
+  prompts: z17.array(z17.string()),
+  surgicalCheckpointId: z17.string().nullable(),
+  forkBatchId: z17.string().nullable(),
+  errorText: z17.string().nullable(),
+  forkedRunIds: z17.array(z17.string())
+});
+var RUN_INSIGHT_STATUSES = [
+  "PENDING",
+  "RUNNING",
+  "COMPLETE",
+  "FAILED",
+  "SKIPPED"
+];
+var runInsightStatusSchema = z17.enum(RUN_INSIGHT_STATUSES);
+var insightPassSchema = z17.object({
+  status: runInsightStatusSchema,
+  model: z17.string().nullable(),
+  inputTokens: z17.number().int().nullable(),
+  outputTokens: z17.number().int().nullable(),
+  usdCost: z17.number().nullable(),
+  error: z17.string().nullable()
+});
+var runDecisionSchema = z17.object({
+  index: z17.number().int(),
+  category: z17.string(),
+  categoryRaw: z17.string().nullable(),
+  chosenName: z17.string(),
+  chosenEcosystem: z17.string().nullable(),
+  chosenPackage: z17.string().nullable(),
+  reversed: z17.boolean(),
+  detail: z17.unknown()
+});
+var runImplementationSchema = z17.object({
+  brandName: z17.string(),
+  ecosystem: z17.string().nullable(),
+  package: z17.string().nullable(),
+  verdict: z17.string(),
+  docConsulted: z17.boolean(),
+  detail: z17.unknown()
+});
+var RUN_INSIGHT_PASS_KINDS = [
+  "INSTALL",
+  "DECISION",
+  "EVAL",
+  "INTEGRATION",
+  "EXPERIMENT_DELTA",
+  "VISIBILITY"
+];
+var runInsightPassKindSchema = z17.enum(RUN_INSIGHT_PASS_KINDS);
+var insightPipelinePassSchema = insightPassSchema.extend({
+  kind: runInsightPassKindSchema
+});
+var runInsightResponseSchema = z17.object({
+  runId: z17.string(),
+  decision: insightPassSchema,
+  implementation: insightPassSchema,
+  passes: z17.array(insightPipelinePassSchema),
+  decisions: z17.array(runDecisionSchema),
+  implementations: z17.array(runImplementationSchema),
+  experimentDelta: z17.unknown().nullable(),
+  /** The VISIBILITY pass's output (winners/picks) — loose server JSON, null
+   *  for non-visibility runs or before the pass completes. */
+  visibilityVerdict: z17.unknown().nullable()
+});
+var runEventSchema = z17.looseObject({
+  run_id: z17.string(),
+  seq: z17.number(),
+  turn: z17.number(),
+  ts: z17.string(),
+  type: z17.string()
+});
+
+// ../packages/api-schemas/src/runPresets.ts
+var SCHEDULABLE_AGENTS = [
+  "CLAUDE_CODE",
+  "CODEX_CLI",
+  "PI",
+  "OPENCODE"
+];
+var schedulableAgentSchema = z18.enum(SCHEDULABLE_AGENTS);
+var presetAgentSchema = z18.object({
+  agent: agentSchema2,
+  models: z18.array(z18.string().min(1))
+});
+var presetAgentInputSchema = z18.object({
   agent: schedulableAgentSchema,
-  models: z14.array(z14.string().min(1)).default([])
+  models: z18.array(z18.string().min(1)).default([])
 });
-var assetRefSchema = z14.string().max(320).regex(
+var assetRefSchema = z18.string().max(320).regex(
   /^[A-Za-z0-9][A-Za-z0-9._-]*@[^\s,]+$/,
   'asset references must be "name@label"'
 );
@@ -1120,7 +1508,7 @@ function refAssetName(ref) {
   const at = ref.indexOf("@");
   return at < 0 ? ref : ref.slice(0, at);
 }
-var assetRefListSchema = z14.array(assetRefSchema).superRefine((refs, ctx) => {
+var assetRefListSchema = z18.array(assetRefSchema).superRefine((refs, ctx) => {
   const names = /* @__PURE__ */ new Set();
   for (const ref of refs) {
     const name = refAssetName(ref);
@@ -1133,111 +1521,121 @@ var assetRefListSchema = z14.array(assetRefSchema).superRefine((refs, ctx) => {
     names.add(name);
   }
 });
-var runPresetSummarySchema = z14.object({
-  id: z14.string(),
-  name: z14.string(),
+var runPresetSummarySchema = z18.object({
+  id: z18.string(),
+  name: z18.string(),
+  /** Lineage: true = this org's copy of a Gauge catalog preset. Editable
+   *  like any other row. Optional-defaulting-false for wire compat. */
+  fromGauge: z18.boolean().optional().default(false),
+  description: z18.string().nullish().default(null),
   /** false = anonymous — runnable and attachable, but not library furniture. */
-  saved: z14.boolean(),
+  saved: z18.boolean(),
   /** null = the greenfield scaffold. */
-  repoUrl: z14.string().nullable(),
-  repoRef: z14.string().nullable(),
-  profile: z14.object({ id: z14.string(), name: z14.string() }).nullable(),
-  agents: z14.array(presetAgentSchema),
-  skillRefs: z14.array(z14.string()),
-  mcpRefs: z14.array(z14.string())
+  repoUrl: z18.string().nullable(),
+  repoRef: z18.string().nullable(),
+  profile: z18.object({ id: z18.string(), name: z18.string() }).nullable(),
+  agents: z18.array(presetAgentSchema),
+  skillRefs: z18.array(z18.string()),
+  mcpRefs: z18.array(z18.string())
 });
 var runPresetSchema = runPresetSummarySchema.extend({
-  evalSets: z14.array(z14.object({ id: z14.string(), name: z14.string() })),
-  visibilityPrompts: z14.array(
-    z14.object({ id: z14.string(), promptText: z14.string() })
+  evalSets: z18.array(z18.object({ id: z18.string(), name: z18.string() })),
+  visibilityPrompts: z18.array(
+    z18.object({ id: z18.string(), promptText: z18.string() })
   ),
-  createdAt: z14.string(),
-  updatedAt: z14.string()
+  createdAt: z18.string(),
+  updatedAt: z18.string()
 });
-var listRunPresetsQuerySchema = z14.object({
-  all: z14.enum(["1", "true", "0", "false"]).optional().transform((v) => v === "1" || v === "true")
+var listRunPresetsQuerySchema = z18.object({
+  all: z18.enum(["1", "true", "0", "false"]).optional().transform((v) => v === "1" || v === "true")
 });
-var listRunPresetsResponseSchema = z14.object({
-  items: z14.array(runPresetSchema),
+var listRunPresetsResponseSchema = z18.object({
+  items: z18.array(runPresetSchema),
   /** D8 footnote: anonymous presets attached to at least one member. */
-  anonymousInUse: z14.number().int()
+  anonymousInUse: z18.number().int()
 });
 var presetConfigInput = {
   /** Omit/null = the greenfield scaffold. */
-  repoUrl: z14.string().nullish(),
-  repoRef: z14.string().nullish(),
+  repoUrl: z18.string().nullish(),
+  repoRef: z18.string().nullish(),
   /** Persona id; must belong to the org. null = the default judge. */
-  profileId: z14.string().nullish(),
-  agents: z14.array(presetAgentInputSchema).min(1, "Select at least one agent"),
+  profileId: z18.string().nullish(),
+  agents: z18.array(presetAgentInputSchema).min(1, "Select at least one agent"),
   skillRefs: assetRefListSchema.default([]),
   mcpRefs: assetRefListSchema.default([])
 };
-var createRunPresetBodySchema = z14.object({
-  name: z14.string().min(1).max(120).optional(),
-  saved: z14.boolean().default(true),
+var createRunPresetBodySchema = z18.object({
+  name: z18.string().min(1).max(120).optional(),
+  saved: z18.boolean().default(true),
   ...presetConfigInput
 }).refine((body) => !body.saved || body.name !== void 0, {
   message: "name is required for a saved preset",
   path: ["name"]
 });
-var updateRunPresetBodySchema = z14.object({
-  name: z14.string().min(1).max(120).optional(),
-  repoUrl: z14.string().nullish(),
-  repoRef: z14.string().nullish(),
-  profileId: z14.string().nullish(),
-  agents: z14.array(presetAgentInputSchema).min(1).optional(),
+var updateRunPresetBodySchema = z18.object({
+  name: z18.string().min(1).max(120).optional(),
+  repoUrl: z18.string().nullish(),
+  repoRef: z18.string().nullish(),
+  profileId: z18.string().nullish(),
+  agents: z18.array(presetAgentInputSchema).min(1).optional(),
   skillRefs: assetRefListSchema.optional(),
   mcpRefs: assetRefListSchema.optional()
 });
-var promoteRunPresetBodySchema = z14.object({
-  name: z14.string().min(1).max(120).optional()
+var promoteRunPresetBodySchema = z18.object({
+  name: z18.string().min(1).max(120).optional()
 });
-var promoteRunPresetResponseSchema = z14.object({
-  id: z14.string(),
-  name: z14.string(),
-  saved: z14.boolean()
+var promoteRunPresetResponseSchema = z18.object({
+  id: z18.string(),
+  name: z18.string(),
+  saved: z18.boolean()
 });
-var deleteRunPresetResponseSchema = z14.object({
-  detachedEvalSets: z14.number().int(),
-  detachedVisibilityPrompts: z14.number().int(),
-  referencedBatches: z14.number().int(),
-  referencedRuns: z14.number().int()
+var deleteRunPresetResponseSchema = z18.object({
+  detachedEvalSets: z18.number().int(),
+  detachedVisibilityPrompts: z18.number().int(),
+  referencedBatches: z18.number().int(),
+  referencedRuns: z18.number().int()
 });
-var runPresetRunSchema = z14.object({
-  runId: z14.string(),
-  agent: agentSchema,
-  turns: z14.number().int().nullable(),
-  durationMs: z14.number().int().nullable(),
-  costUsd: z14.number().nullable(),
-  finishedAt: z14.string().nullable(),
+var runPresetRunSchema = z18.object({
+  runId: z18.string(),
+  agent: agentSchema2,
+  turns: z18.number().int().nullable(),
+  durationMs: z18.number().int().nullable(),
+  costUsd: z18.number().nullable(),
+  finishedAt: z18.string().nullable(),
   /** The attached eval / preference prompt the batch ran, by name. */
-  sourceLabel: z14.string().nullable()
+  sourceLabel: z18.string().nullable()
 });
-var listRunPresetRunsResponseSchema = z14.object({
-  items: z14.array(runPresetRunSchema)
+var listRunPresetRunsResponseSchema = z18.object({
+  items: z18.array(runPresetRunSchema)
 });
-var inlinePresetSchema = z14.object({
+var inlinePresetSchema = z18.object({
   /** Omitted derives from the repo ("Default" for greenfield). */
-  presetName: z14.string().min(1).max(120).optional(),
+  presetName: z18.string().min(1).max(120).optional(),
   ...presetConfigInput
 });
-var attachPresetBodySchema = z14.object({
-  runPresetId: z14.string().min(1).optional(),
+var attachPresetBodySchema = z18.object({
+  runPresetId: z18.string().min(1).optional(),
   newPreset: inlinePresetSchema.optional()
 }).refine(
   (body) => body.runPresetId !== void 0 !== (body.newPreset !== void 0),
   { message: "pass exactly one of runPresetId or newPreset" }
 );
-var listMemberPresetsResponseSchema = z14.object({
-  items: z14.array(runPresetSummarySchema)
-});
-var runMemberBodySchema = z14.object({
-  runPresetIds: z14.array(z14.string().min(1)).optional(),
-  oneOff: z14.object({
-    repoUrl: z14.string().nullish(),
-    repoRef: z14.string().nullish(),
-    profileId: z14.string().nullish(),
-    agents: z14.array(presetAgentInputSchema).min(1, "Select at least one agent")
+var listMemberPresetsResponseSchema = z18.object({
+  items: z18.array(runPresetSummarySchema)
+});
+var runMemberBodySchema = z18.object({
+  runPresetIds: z18.array(z18.string().min(1)).optional(),
+  oneOff: z18.object({
+    repoUrl: z18.string().nullish(),
+    repoRef: z18.string().nullish(),
+    profileId: z18.string().nullish(),
+    agents: z18.array(presetAgentInputSchema).min(1, "Select at least one agent"),
+    skillRefs: assetRefListSchema.optional(),
+    mcpRefs: assetRefListSchema.optional(),
+    connectionIds: z18.array(z18.string().min(1)).max(32).optional(),
+    /** Filled = save the config as a library preset under this name
+     *  (still not attached). */
+    saveAsPresetName: z18.string().trim().max(120).optional()
   }).optional()
 }).refine(
   (body) => body.runPresetIds === void 0 || body.runPresetIds.length > 0 || body.oneOff !== void 0,
@@ -1262,127 +1660,186 @@ function totalRunsPerCycle(presets, samplesPerCycle) {
 }
 
 // ../packages/api-schemas/src/evals.ts
-var criterionSchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  rubric: z15.string(),
-  position: z15.number().int()
+var criterionSchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  rubric: z19.string(),
+  position: z19.number().int()
 });
-var criterionInputSchema = z15.object({
+var criterionInputSchema = z19.object({
   /** Present = update in place; absent = create. */
-  id: z15.string().optional(),
+  id: z19.string().optional(),
   /** Label only; omit and the server derives it from the rubric. */
-  name: z15.string().min(1).optional(),
-  rubric: z15.string().min(1)
+  name: z19.string().min(1).optional(),
+  rubric: z19.string().min(1)
 });
-var evalSetSchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  promptText: z15.string(),
+var evalSetSchema = z19.object({
+  id: z19.string(),
+  name: z19.string(),
+  promptText: z19.string(),
   /** null = the greenfield scaffold. */
-  repoUrl: z15.string().nullable(),
-  repoRef: z15.string().nullable(),
+  repoUrl: z19.string().nullable(),
+  repoRef: z19.string().nullable(),
   /** Persona judging the runs; null = the default judge. */
-  profile: z15.object({ id: z15.string(), name: z15.string() }).nullable(),
-  enabled: z15.boolean(),
-  createdAt: z15.string(),
+  profile: z19.object({ id: z19.string(), name: z19.string() }).nullable(),
+  enabled: z19.boolean(),
+  createdAt: z19.string(),
   cycle: cycleSchema,
-  criteria: z15.array(criterionSchema),
+  criteria: z19.array(criterionSchema),
   /** User tag names on the hidden backing prompt (Surface:* excluded). */
-  tags: z15.array(z15.string()),
+  tags: z19.array(z19.string()),
   /** ALL attached presets in expansion order — every one runs each cycle.
    *  The flattened repoUrl/repoRef/profile above mirror the primary
    *  (lowest-position) attachment only. */
-  runPresets: z15.array(runPresetSummarySchema)
+  runPresets: z19.array(runPresetSummarySchema)
 });
-var agentPassRateSchema = z15.object({
-  agent: agentSchema,
-  model: z15.string(),
-  runId: z15.string(),
-  finishedAt: z15.string().nullable(),
-  passed: z15.number().int(),
-  total: z15.number().int()
-});
-var evalSetStatSchema = z15.object({
-  passRates: z15.array(agentPassRateSchema),
-  runCount: z15.number().int(),
+var agentPassRateSchema = z19.object({
+  agent: agentSchema2,
+  model: z19.string(),
+  runId: z19.string(),
+  finishedAt: z19.string().nullable(),
+  passed: z19.number().int(),
+  total: z19.number().int()
+});
+var evalSetStatSchema = z19.object({
+  passRates: z19.array(agentPassRateSchema),
+  runCount: z19.number().int(),
   /** Run-level aggregate: a run passes only when every criterion passed. */
-  judgedRuns: z15.number().int(),
-  passedRuns: z15.number().int()
+  judgedRuns: z19.number().int(),
+  passedRuns: z19.number().int()
 });
-var csv2 = z15.string().transform(
+var csv2 = z19.string().transform(
   (s) => s.split(",").map((x) => x.trim()).filter(Boolean)
 );
-var listEvalSetsQuerySchema = z15.object({
-  agents: csv2.pipe(z15.array(agentSchema)).optional(),
+var listEvalSetsQuerySchema = z19.object({
+  agents: csv2.pipe(z19.array(agentSchema2)).optional(),
   models: csv2.optional(),
-  since: z15.coerce.date().optional()
+  since: z19.coerce.date().optional()
 });
 var evalSetListItemSchema = evalSetSchema.extend({
   stats: evalSetStatSchema
 });
-var listEvalSetsResponseSchema = z15.object({
-  items: z15.array(evalSetListItemSchema)
+var listEvalSetsResponseSchema = z19.object({
+  items: z19.array(evalSetListItemSchema)
 });
-var createEvalSetBodySchema = z15.object({
-  name: z15.string().min(1),
-  promptText: z15.string().min(1),
+var createEvalSetBodySchema = z19.object({
+  name: z19.string().min(1),
+  promptText: z19.string().min(1),
   /** Omit/null = the greenfield scaffold. */
-  repoUrl: z15.string().nullish(),
-  repoRef: z15.string().nullish(),
+  repoUrl: z19.string().nullish(),
+  repoRef: z19.string().nullish(),
   /** Persona id; must belong to the org. */
-  profileId: z15.string().nullish(),
-  criteria: z15.array(criterionInputSchema).min(1),
-  enabled: z15.boolean().optional(),
+  profileId: z19.string().nullish(),
+  criteria: z19.array(criterionInputSchema).min(1),
+  enabled: z19.boolean().optional(),
   /** User tag names, create-on-type (Surface:* rejected/dropped). */
-  tags: z15.array(z15.string()).optional(),
+  tags: z19.array(z19.string()).optional(),
   /** Attach these existing presets, in order. When either preset field is
    *  present the repo/persona fields above are ignored for configuration —
    *  presets are explicit and authoritative (D2). */
-  runPresetIds: z15.array(z15.string().min(1)).optional(),
+  runPresetIds: z19.array(z19.string().min(1)).optional(),
   /** Mint a saved preset and attach it (after runPresetIds). */
   newPreset: inlinePresetSchema.optional()
 });
-var updateEvalSetBodySchema = z15.object({
-  name: z15.string().min(1).optional(),
-  promptText: z15.string().min(1).optional(),
-  repoUrl: z15.string().nullish(),
-  repoRef: z15.string().nullish(),
-  profileId: z15.string().nullish(),
-  criteria: z15.array(criterionInputSchema).min(1).optional(),
-  enabled: z15.boolean().optional(),
-  tags: z15.array(z15.string()).optional()
-});
-var runEvalSetResponseSchema = z15.object({
-  batchIds: z15.array(z15.string()),
-  runIds: z15.array(z15.string())
-});
-var evalSetRunSchema = z15.object({
-  id: z15.string(),
-  status: z15.string(),
-  agent: agentSchema,
-  model: z15.string().nullable(),
-  resolvedModel: z15.string().nullable(),
-  createdAt: z15.string(),
-  startedAt: z15.string().nullable(),
-  finishedAt: z15.string().nullable(),
-  failureReason: z15.string().nullable(),
-  judge: z15.object({ status: z15.string(), error: z15.string().nullable() }).nullable(),
-  criterionResults: z15.array(
-    z15.object({
-      criterionId: z15.string().nullable(),
-      name: z15.string(),
-      passed: z15.boolean(),
-      reasoning: z15.string().nullable()
+var updateEvalSetBodySchema = z19.object({
+  name: z19.string().min(1).optional(),
+  promptText: z19.string().min(1).optional(),
+  repoUrl: z19.string().nullish(),
+  repoRef: z19.string().nullish(),
+  profileId: z19.string().nullish(),
+  criteria: z19.array(criterionInputSchema).min(1).optional(),
+  enabled: z19.boolean().optional(),
+  tags: z19.array(z19.string()).optional()
+});
+var runEvalSetResponseSchema = z19.object({
+  batchIds: z19.array(z19.string()),
+  runIds: z19.array(z19.string())
+});
+var evalSetRunSchema = z19.object({
+  id: z19.string(),
+  status: z19.string(),
+  agent: agentSchema2,
+  model: z19.string().nullable(),
+  resolvedModel: z19.string().nullable(),
+  createdAt: z19.string(),
+  startedAt: z19.string().nullable(),
+  finishedAt: z19.string().nullable(),
+  failureReason: z19.string().nullable(),
+  judge: z19.object({ status: z19.string(), error: z19.string().nullable() }).nullable(),
+  criterionResults: z19.array(
+    z19.object({
+      criterionId: z19.string().nullable(),
+      name: z19.string(),
+      passed: z19.boolean(),
+      reasoning: z19.string().nullable()
     })
   )
 });
-var listEvalSetRunsResponseSchema = z15.object({
-  items: z15.array(evalSetRunSchema)
+var listEvalSetRunsResponseSchema = z19.object({
+  items: z19.array(evalSetRunSchema)
+});
+
+// ../packages/api-schemas/src/executionTargets.ts
+import { z as z20 } from "zod";
+var executionTargetCapabilitiesSchema = z20.object({
+  skills: z20.boolean(),
+  mcp: z20.boolean(),
+  connections: z20.boolean(),
+  agentContext: z20.boolean(),
+  resume: z20.boolean()
+});
+var executionTargetSchema = z20.object({
+  harness: agentSchema2,
+  harnessSlug: z20.string(),
+  harnessLabel: z20.string(),
+  model: z20.string(),
+  modelLabel: z20.string(),
+  providerSlug: z20.string(),
+  providerLabel: z20.string(),
+  capabilities: executionTargetCapabilitiesSchema
+});
+var executionTargetsResponseSchema = z20.object({
+  items: z20.array(executionTargetSchema)
 });
 
 // ../packages/api-schemas/src/experiments.ts
-import { z as z16 } from "zod";
+var experiments_exports = {};
+__export(experiments_exports, {
+  EXPERIMENT_MODES: () => EXPERIMENT_MODES,
+  EXPERIMENT_STATUSES: () => EXPERIMENT_STATUSES,
+  SUPPORT_CLASSES: () => SUPPORT_CLASSES,
+  TERMINAL_EXPERIMENT_STATUSES: () => TERMINAL_EXPERIMENT_STATUSES,
+  addVariantBodySchema: () => addVariantBodySchema,
+  cancelResponseSchema: () => cancelResponseSchema,
+  createExperimentBodyFields: () => createExperimentBodyFields,
+  createExperimentBodySchema: () => createExperimentBodySchema,
+  createExperimentResponseSchema: () => createExperimentResponseSchema,
+  eligibleExperimentRunSchema: () => eligibleExperimentRunSchema,
+  experimentBoundarySchema: () => experimentBoundarySchema,
+  experimentContentQuerySchema: () => experimentContentQuerySchema,
+  experimentContentResponseSchema: () => experimentContentResponseSchema,
+  experimentDetailSchema: () => experimentDetailSchema,
+  experimentListQuerySchema: () => experimentListQuerySchema,
+  experimentListResponseSchema: () => experimentListResponseSchema,
+  experimentModeSchema: () => experimentModeSchema,
+  experimentStatusResponseSchema: () => experimentStatusResponseSchema,
+  experimentStatusSchema: () => experimentStatusSchema,
+  experimentSummarySchema: () => experimentSummarySchema,
+  experimentVariantSchema: () => experimentVariantSchema,
+  fixerEditSchema: () => fixerEditSchema,
+  launchResultSchema: () => launchResultSchema,
+  patchVariantBodySchema: () => patchVariantBodySchema,
+  recommendationSchema: () => recommendationSchema,
+  shipBodySchema: () => shipBodySchema,
+  supportClassSchema: () => supportClassSchema,
+  variantDeltaSchema: () => variantDeltaSchema,
+  variantRefSchema: () => variantRefSchema,
+  variantRunSchema: () => variantRunSchema,
+  writeRoundResponseSchema: () => writeRoundResponseSchema,
+  writeVariantContentBodySchema: () => writeVariantContentBodySchema,
+  writeVariantContentResponseSchema: () => writeVariantContentResponseSchema
+});
+import { z as z21 } from "zod";
 var EXPERIMENT_STATUSES = [
   "DRAFT",
   "GENERATING",
@@ -1394,227 +1851,257 @@ var EXPERIMENT_STATUSES = [
   "FAILED",
   "CANCELED"
 ];
-var experimentStatusSchema = z16.enum(EXPERIMENT_STATUSES);
+var experimentStatusSchema = z21.enum(EXPERIMENT_STATUSES);
+var TERMINAL_EXPERIMENT_STATUSES = [
+  "COMPLETE",
+  "PARTIAL",
+  "FAILED",
+  "CANCELED"
+];
 var SUPPORT_CLASSES = [
   "RECOMMENDED",
   "PROMISING",
   "NOT_SUPPORTED",
   "NOT_EVALUABLE"
 ];
-var supportClassSchema = z16.enum(SUPPORT_CLASSES);
-var jsonValue = z16.unknown();
-var createExperimentBodySchema = z16.object({
-  runId: z16.string().min(1),
-  boundarySeq: z16.string().min(1),
-  problemText: z16.string().trim().min(1).optional()
-});
-var createExperimentResponseSchema = z16.object({
-  experimentId: z16.string(),
+var supportClassSchema = z21.enum(SUPPORT_CLASSES);
+var jsonValue = z21.unknown();
+var EXPERIMENT_MODES = ["PROPOSE", "DIRECT", "MANUAL"];
+var experimentModeSchema = z21.enum(EXPERIMENT_MODES);
+var createExperimentBodyFields = z21.object({
+  runId: z21.string().min(1),
+  boundarySeq: z21.string().min(1),
+  problemText: z21.string().trim().min(1).optional(),
+  /** OPTIONAL, and it stays optional: a CLI built before the bifurcation must
+   *  keep working, and omitting it means PROPOSE — the behaviour it already
+   *  expects. */
+  mode: experimentModeSchema.optional(),
+  /** DIRECT only: the one change to make, in the author's own words. Ignored
+   *  in the other modes. Carried as the single rewrite's title, and REQUIRED
+   *  when `mode` is DIRECT — see the cross-field check below. */
+  changeInstruction: z21.string().trim().min(1).max(200).optional()
+});
+var createExperimentBodySchema = createExperimentBodyFields.superRefine((body, ctx) => {
+  if (body.mode === "DIRECT" && !body.changeInstruction) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["changeInstruction"],
+      message: "mode DIRECT requires changeInstruction \u2014 the one change to make, in your own words"
+    });
+  }
+});
+var createExperimentResponseSchema = z21.object({
+  experimentId: z21.string(),
   /** false = an existing draft for this (run, boundary) was resumed. */
-  created: z16.boolean(),
+  created: z21.boolean(),
   /** What is persisted — a resume keeps the statement it was opened with. */
-  problemText: z16.string()
-});
-var experimentListQuerySchema = z16.object({
-  status: z16.string().transform(
+  problemText: z21.string(),
+  /** The PERSISTED mode, echoed for the same reason `problemText` is: exactly
+   *  one live draft exists per (run, boundary), so a resume returns the mode
+   *  that draft was opened with — which may not be the one this call asked
+   *  for. Clients report what came back, not what they sent. */
+  mode: experimentModeSchema
+});
+var experimentListQuerySchema = z21.object({
+  status: z21.string().transform(
     (s) => s.split(",").map((x) => x.trim().toUpperCase()).filter(Boolean)
-  ).pipe(z16.array(experimentStatusSchema)).optional(),
-  limit: z16.coerce.number().int().min(1).max(100).default(25)
+  ).pipe(z21.array(experimentStatusSchema)).optional(),
+  limit: z21.coerce.number().int().min(1).max(100).default(25)
 });
-var experimentSummarySchema = z16.object({
-  id: z16.string(),
+var experimentSummarySchema = z21.object({
+  id: z21.string(),
   status: experimentStatusSchema,
-  problem: z16.string(),
-  boundaryUrl: z16.string().nullable(),
-  sourceRunId: z16.string(),
-  variantCount: z16.number().int(),
-  createdAt: z16.string()
+  problem: z21.string(),
+  boundaryUrl: z21.string().nullable(),
+  sourceRunId: z21.string(),
+  variantCount: z21.number().int(),
+  createdAt: z21.string()
 });
-var experimentListResponseSchema = z16.object({
-  items: z16.array(experimentSummarySchema)
+var experimentListResponseSchema = z21.object({
+  items: z21.array(experimentSummarySchema)
 });
-var eligibleExperimentRunSchema = z16.object({
-  runId: z16.string(),
-  agent: agentSchema,
-  promptText: z16.string(),
-  createdAt: z16.string(),
-  verdict: z16.string().nullable(),
-  boundaryCount: z16.number().int()
-});
-var experimentBoundarySchema = z16.object({
-  boundarySeq: z16.union([z16.string(), z16.number()]),
-  turn: z16.number().int().nullable(),
-  url: z16.string(),
-  domain: z16.string().nullable(),
-  fetchPrompt: z16.string().nullable(),
-  source: z16.string(),
-  boundaryCheckpointId: z16.string().nullable(),
-  boundaryOrdinal: z16.number().int().nullable(),
-  capturedOccurrence: z16.number().int().nullable()
-});
-var variantRunSchema = z16.object({
-  runId: z16.string(),
-  status: z16.string(),
-  failureReason: z16.string().nullable(),
-  integrations: z16.array(jsonValue)
-});
-var experimentVariantSchema = z16.object({
-  variantId: z16.string(),
-  key: z16.string(),
-  title: z16.string(),
-  hypothesis: z16.string(),
-  rewriteChars: z16.number().int(),
-  hasRewrite: z16.boolean(),
-  invalidReason: z16.string().nullable(),
-  planStatus: z16.string().nullable(),
-  planError: z16.string().nullable(),
-  runs: z16.array(variantRunSchema),
+var eligibleExperimentRunSchema = z21.object({
+  runId: z21.string(),
+  agent: agentSchema2,
+  promptText: z21.string(),
+  createdAt: z21.string(),
+  verdict: z21.string().nullable(),
+  boundaryCount: z21.number().int()
+});
+var experimentBoundarySchema = z21.object({
+  boundarySeq: z21.union([z21.string(), z21.number()]),
+  turn: z21.number().int().nullable(),
+  url: z21.string(),
+  domain: z21.string().nullable(),
+  fetchPrompt: z21.string().nullable(),
+  source: z21.string(),
+  boundaryCheckpointId: z21.string().nullable(),
+  boundaryOrdinal: z21.number().int().nullable(),
+  capturedOccurrence: z21.number().int().nullable()
+});
+var variantRunSchema = z21.object({
+  runId: z21.string(),
+  status: z21.string(),
+  failureReason: z21.string().nullable(),
+  integrations: z21.array(jsonValue)
+});
+var experimentVariantSchema = z21.object({
+  variantId: z21.string(),
+  key: z21.string(),
+  title: z21.string(),
+  hypothesis: z21.string(),
+  rewriteChars: z21.number().int(),
+  hasRewrite: z21.boolean(),
+  invalidReason: z21.string().nullable(),
+  planStatus: z21.string().nullable(),
+  planError: z21.string().nullable(),
+  runs: z21.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 = z16.object({
-  id: z16.string(),
+var experimentDetailSchema = z21.object({
+  id: z21.string(),
   status: experimentStatusSchema,
-  problem: z16.string(),
-  boundaryUrl: z16.string().nullable(),
-  createdAt: z16.string(),
-  editable: z16.boolean(),
-  roundInFlight: z16.boolean(),
-  launching: z16.boolean(),
-  launchError: z16.string().nullable(),
-  planned: z16.boolean(),
+  problem: z21.string(),
+  boundaryUrl: z21.string().nullable(),
+  createdAt: z21.string(),
+  editable: z21.boolean(),
+  roundInFlight: z21.boolean(),
+  launching: z21.boolean(),
+  launchError: z21.string().nullable(),
+  planned: z21.boolean(),
   livePage: jsonValue.nullable(),
-  sourceRun: z16.object({
-    runId: z16.string(),
-    agent: agentSchema,
-    status: z16.string(),
-    task: z16.string(),
-    repoUrl: z16.string().nullable(),
+  sourceRun: z21.object({
+    runId: z21.string(),
+    agent: agentSchema2,
+    status: z21.string(),
+    task: z21.string(),
+    repoUrl: z21.string().nullable(),
     verdict: jsonValue.nullable(),
-    integrations: z16.array(jsonValue)
+    integrations: z21.array(jsonValue)
   }),
-  variants: z16.array(experimentVariantSchema),
+  variants: z21.array(experimentVariantSchema),
   /** The settled comparison (winners vs baseline) — null until launched. */
   summary: jsonValue.nullable()
 });
-var experimentStatusResponseSchema = z16.object({
-  id: z16.string(),
+var experimentStatusResponseSchema = z21.object({
+  id: z21.string(),
   status: experimentStatusSchema,
-  planned: z16.boolean(),
-  writeStartedAt: z16.string().nullable(),
-  launchStartedAt: z16.string().nullable(),
-  launchError: z16.string().nullable(),
-  shippedVariantId: z16.string().nullable(),
-  shippedAt: z16.string().nullable()
-});
-var addVariantBodySchema = z16.object({
-  title: z16.string().optional(),
-  hypothesis: z16.string().optional()
-});
-var patchVariantBodySchema = z16.object({
-  title: z16.string().optional(),
-  hypothesis: z16.string().optional()
-});
-var fixerEditSchema = z16.object({
-  find: z16.string().min(1),
-  replace: z16.string()
-});
-var writeVariantContentBodySchema = z16.object({
-  content: z16.string().optional(),
-  edits: z16.array(fixerEditSchema).optional()
-});
-var writeVariantContentResponseSchema = z16.object({
-  variantId: z16.string(),
-  chars: z16.number().int(),
-  truncated: z16.boolean(),
-  applied: z16.number().int(),
-  skipped: z16.number().int()
-});
-var experimentContentQuerySchema = z16.object({
-  variantId: z16.string().optional(),
-  offset: z16.coerce.number().int().min(0).default(0),
-  maxChars: z16.coerce.number().int().min(1).max(4e4).default(2e4)
-});
-var experimentContentResponseSchema = z16.object({
-  source: z16.string(),
-  totalChars: z16.number().int(),
-  offset: z16.number().int(),
-  returnedChars: z16.number().int(),
-  nextOffset: z16.number().int().nullable(),
-  content: z16.string()
-});
-var writeRoundResponseSchema = z16.object({
-  queued: z16.number().int(),
-  reason: z16.enum(["round_in_flight", "nothing_pending"]).optional()
-});
-var launchResultSchema = z16.object({
-  experimentId: z16.string(),
-  status: z16.literal("LAUNCHING")
-});
-var shipBodySchema = z16.object({ variantId: z16.string().min(1) });
-var cancelResponseSchema = z16.object({
-  id: z16.string(),
-  status: z16.literal("CANCELED")
-});
-var variantDeltaSchema = z16.object({
-  changed: z16.boolean().nullable(),
-  hypothesisSupported: z16.enum(["supported", "refuted", "inconclusive"]).nullable(),
-  summary: z16.string().nullable()
-});
-var variantRefSchema = z16.object({
-  key: z16.string(),
-  title: z16.string(),
-  effect: z16.number().nullable(),
-  consistency: z16.string().nullable(),
-  note: z16.string().nullable(),
+  planned: z21.boolean(),
+  writeStartedAt: z21.string().nullable(),
+  launchStartedAt: z21.string().nullable(),
+  launchError: z21.string().nullable(),
+  shippedVariantId: z21.string().nullable(),
+  shippedAt: z21.string().nullable()
+});
+var addVariantBodySchema = z21.object({
+  title: z21.string().optional(),
+  hypothesis: z21.string().optional()
+});
+var patchVariantBodySchema = z21.object({
+  title: z21.string().optional(),
+  hypothesis: z21.string().optional()
+});
+var fixerEditSchema = z21.object({
+  find: z21.string().min(1),
+  replace: z21.string()
+});
+var writeVariantContentBodySchema = z21.object({
+  content: z21.string().optional(),
+  edits: z21.array(fixerEditSchema).optional()
+});
+var writeVariantContentResponseSchema = z21.object({
+  variantId: z21.string(),
+  chars: z21.number().int(),
+  truncated: z21.boolean(),
+  applied: z21.number().int(),
+  skipped: z21.number().int()
+});
+var experimentContentQuerySchema = z21.object({
+  variantId: z21.string().optional(),
+  offset: z21.coerce.number().int().min(0).default(0),
+  maxChars: z21.coerce.number().int().min(1).max(4e4).default(2e4)
+});
+var experimentContentResponseSchema = z21.object({
+  source: z21.string(),
+  totalChars: z21.number().int(),
+  offset: z21.number().int(),
+  returnedChars: z21.number().int(),
+  nextOffset: z21.number().int().nullable(),
+  content: z21.string()
+});
+var writeRoundResponseSchema = z21.object({
+  queued: z21.number().int(),
+  reason: z21.enum(["round_in_flight", "nothing_pending"]).optional()
+});
+var launchResultSchema = z21.object({
+  experimentId: z21.string(),
+  status: z21.literal("LAUNCHING")
+});
+var shipBodySchema = z21.object({ variantId: z21.string().min(1) });
+var cancelResponseSchema = z21.object({
+  id: z21.string(),
+  status: z21.literal("CANCELED")
+});
+var variantDeltaSchema = z21.object({
+  changed: z21.boolean().nullable(),
+  hypothesisSupported: z21.enum(["supported", "refuted", "inconclusive"]).nullable(),
+  summary: z21.string().nullable()
+});
+var variantRefSchema = z21.object({
+  key: z21.string(),
+  title: z21.string(),
+  effect: z21.number().nullable(),
+  consistency: z21.string().nullable(),
+  note: z21.string().nullable(),
   delta: variantDeltaSchema.nullable().optional()
 });
-var recommendationSchema = z16.object({
-  evaluatorVersion: z16.string(),
-  summary: z16.string(),
-  groups: z16.object({
-    recommended: z16.array(variantRefSchema),
-    promising: z16.array(variantRefSchema),
-    notSupported: z16.array(variantRefSchema),
-    notEvaluable: z16.array(variantRefSchema)
+var recommendationSchema = z21.object({
+  evaluatorVersion: z21.string(),
+  summary: z21.string(),
+  groups: z21.object({
+    recommended: z21.array(variantRefSchema),
+    promising: z21.array(variantRefSchema),
+    notSupported: z21.array(variantRefSchema),
+    notEvaluable: z21.array(variantRefSchema)
   }),
-  tradeoffs: z16.array(z16.string())
+  tradeoffs: z21.array(z21.string())
 });
 
 // ../packages/api-schemas/src/implementationDoc.ts
-import { z as z17 } from "zod";
+import { z as z22 } from "zod";
 var IMPLEMENTATION_DOC_MAX_CHARS = 5e5;
-var implementationDocSchema = z17.object({
+var implementationDocSchema = z22.object({
   /** The whole doc; "" when none has been written. */
-  content: z17.string()
+  content: z22.string()
 });
-var putImplementationDocBodySchema = z17.object({
-  content: z17.string().max(IMPLEMENTATION_DOC_MAX_CHARS)
+var putImplementationDocBodySchema = z22.object({
+  content: z22.string().max(IMPLEMENTATION_DOC_MAX_CHARS)
 });
-var patchImplementationDocBodySchema = z17.object({
-  brandName: z17.string().min(1).max(200),
-  ecosystem: z17.string().max(100).nullish(),
-  package: z17.string().max(300).nullish(),
-  body: z17.string().max(IMPLEMENTATION_DOC_MAX_CHARS)
+var patchImplementationDocBodySchema = z22.object({
+  brandName: z22.string().min(1).max(200),
+  ecosystem: z22.string().max(100).nullish(),
+  package: z22.string().max(300).nullish(),
+  body: z22.string().max(IMPLEMENTATION_DOC_MAX_CHARS)
 });
 
 // ../packages/api-schemas/src/invites.ts
-import { z as z18 } from "zod";
-var inviteSchema = z18.object({
-  id: z18.string(),
-  email: z18.string(),
-  invitedBy: z18.object({
-    name: z18.string().nullable(),
-    email: z18.string().nullable()
+import { z as z23 } from "zod";
+var inviteSchema = z23.object({
+  id: z23.string(),
+  email: z23.string(),
+  invitedBy: z23.object({
+    name: z23.string().nullable(),
+    email: z23.string().nullable()
   }),
-  createdAt: z18.string(),
-  expiresAt: z18.string()
+  createdAt: z23.string(),
+  expiresAt: z23.string()
 });
-var listInvitesResponseSchema = z18.object({
-  items: z18.array(inviteSchema)
+var listInvitesResponseSchema = z23.object({
+  items: z23.array(inviteSchema)
 });
 
 // ../packages/api-schemas/src/keys.ts
@@ -1627,168 +2114,168 @@ __export(keys_exports, {
   setProviderKeyBodySchema: () => setProviderKeyBodySchema,
   setProviderKeyResponseSchema: () => setProviderKeyResponseSchema
 });
-import { z as z19 } from "zod";
+import { z as z24 } from "zod";
 var PROVIDER_TYPES = ["anthropic", "openai"];
-var providerTypeSchema = z19.enum(PROVIDER_TYPES);
-var setProviderKeyBodySchema = z19.object({
+var providerTypeSchema = z24.enum(PROVIDER_TYPES);
+var setProviderKeyBodySchema = z24.object({
   /** The raw provider API key. Verified + stored server-side (AWS Secrets
    *  Manager); never persisted in the app DB and never echoed back. */
-  key: z19.string().min(1)
+  key: z24.string().min(1)
 });
-var setProviderKeyResponseSchema = z19.object({
+var setProviderKeyResponseSchema = z24.object({
   providerType: providerTypeSchema,
-  last4: z19.string()
+  last4: z24.string()
 });
-var providerKeySchema = z19.object({
+var providerKeySchema = z24.object({
   providerType: providerTypeSchema,
-  last4: z19.string(),
-  createdAt: z19.string(),
+  last4: z24.string(),
+  createdAt: z24.string(),
   /** When the key was last saved/rotated. */
-  updatedAt: z19.string()
+  updatedAt: z24.string()
 });
 var providerKeyListResponseSchema = listResponseSchema(providerKeySchema);
 
 // ../packages/api-schemas/src/mcp.ts
-import { z as z21 } from "zod";
+import { z as z26 } from "zod";
 
 // ../packages/api-schemas/src/skills.ts
-import { z as z20 } from "zod";
+import { z as z25 } from "zod";
 var sha256Hex = sha256DigestSchema;
-var skillHandleSchema = z20.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 = z20.object({
-  skillId: z20.string().min(1),
+var skillHandleSchema = z25.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid skill handle").refine((name) => name !== "." && name !== "..", "invalid skill handle");
+var skillSetEntrySchema = z25.object({
+  skillId: z25.string().min(1),
   name: skillHandleSchema,
-  label: z20.string().min(1),
+  label: z25.string().min(1),
   contentDigest: sha256Hex,
   blobDigest: sha256Hex,
   /** `cas/v2/<scope>/skills/sha256/<ab>/<blobDigest>.tar.zst`. */
-  blobKey: z20.string().min(1),
+  blobKey: z25.string().min(1),
   /** Raw canonical-tar size. Bounds the decompression allocation when present. */
-  rawBytes: z20.number().int().positive().optional(),
+  rawBytes: z25.number().int().positive().optional(),
   /** Stored compressed size, verified against the object when present. */
-  storedBytes: z20.number().int().positive().optional(),
+  storedBytes: z25.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: z20.record(z20.string(), z20.unknown()).optional()
+  exposure: z25.record(z25.string(), z25.unknown()).optional()
 });
 var MAX_SKILL_SET_ENTRIES = 32;
-var skillSetSchema = z20.array(skillSetEntrySchema).max(
+var skillSetSchema = z25.array(skillSetEntrySchema).max(
   MAX_SKILL_SET_ENTRIES,
   `a run may stage at most ${MAX_SKILL_SET_ENTRIES} skills`
 );
-var skillSourceWireSchema = z20.object({
-  repoFullName: z20.string(),
-  ref: z20.string(),
-  subpath: z20.string(),
-  autoIngest: z20.boolean(),
-  lastSeenCommit: z20.string().nullable(),
-  lastCheckedAt: z20.string().nullable(),
-  lastError: z20.string().nullable()
-});
-var skillVersionWireSchema = z20.object({
-  id: z20.string(),
-  label: z20.string(),
-  contentDigest: z20.string(),
-  ingestTrigger: z20.string().nullable(),
-  createdAt: z20.string()
-});
-var skillListItemSchema = z20.object({
-  id: z20.string(),
+var skillSourceWireSchema = z25.object({
+  repoFullName: z25.string(),
+  ref: z25.string(),
+  subpath: z25.string(),
+  autoIngest: z25.boolean(),
+  lastSeenCommit: z25.string().nullable(),
+  lastCheckedAt: z25.string().nullable(),
+  lastError: z25.string().nullable()
+});
+var skillVersionWireSchema = z25.object({
+  id: z25.string(),
+  label: z25.string(),
+  contentDigest: z25.string(),
+  ingestTrigger: z25.string().nullable(),
+  createdAt: z25.string()
+});
+var skillListItemSchema = z25.object({
+  id: z25.string(),
   /** OUR storage handle — the {ref} segment. */
   name: skillHandleSchema,
-  note: z20.string().nullable(),
+  note: z25.string().nullable(),
   source: skillSourceWireSchema.nullable(),
   latestVersion: skillVersionWireSchema.nullable(),
-  versionCount: z20.number().int(),
-  createdAt: z20.string(),
-  updatedAt: z20.string()
+  versionCount: z25.number().int(),
+  createdAt: z25.string(),
+  updatedAt: z25.string()
 });
-var listSkillsResponseSchema = z20.object({
-  items: z20.array(skillListItemSchema)
+var listSkillsResponseSchema = z25.object({
+  items: z25.array(skillListItemSchema)
 });
-var skillDetailSchema = skillListItemSchema.omit({ latestVersion: true }).extend({ versions: z20.array(skillVersionWireSchema) });
-var addSkillBodySchema = z20.object({
-  reference: z20.string().min(1),
+var skillDetailSchema = skillListItemSchema.omit({ latestVersion: true }).extend({ versions: z25.array(skillVersionWireSchema) });
+var addSkillBodySchema = z25.object({
+  reference: z25.string().min(1),
   /** OUR handle; defaults to the resolved directory basename. */
   handle: skillHandleSchema.optional(),
   /** Explicit version label — a typed label is intent and always mints;
    *  omitted derives from the resolved anchor and dedups by digest. */
-  label: z20.string().min(1).max(120).optional(),
+  label: z25.string().min(1).max(120).optional(),
   /** Select one skill from a source holding several. */
-  skill: z20.string().min(1).optional(),
-  note: z20.string().max(2e3).optional(),
+  skill: z25.string().min(1).optional(),
+  note: z25.string().max(2e3).optional(),
   /** Track the source branch for auto re-ingest (needs an explicit branch). */
-  trackSource: z20.boolean().optional()
+  trackSource: z25.boolean().optional()
 });
-var addSkillResponseSchema = z20.object({
-  skillId: z20.string().nullable(),
-  handle: z20.string(),
-  label: z20.string(),
+var addSkillResponseSchema = z25.object({
+  skillId: z25.string().nullable(),
+  handle: z25.string(),
+  label: z25.string(),
   /** True = the newest version already carried this content; nothing minted. */
-  unchanged: z20.boolean()
+  unchanged: z25.boolean()
 });
-var updateSkillBodySchema = z20.object({
+var updateSkillBodySchema = z25.object({
   name: skillHandleSchema.optional(),
-  note: z20.string().max(2e3).nullish(),
-  source: z20.object({
-    repoFullName: z20.string().min(1),
+  note: z25.string().max(2e3).nullish(),
+  source: z25.object({
+    repoFullName: z25.string().min(1),
     /** A branch name — never HEAD, never a SHA. */
-    ref: z20.string().min(1),
-    subpath: z20.string().optional(),
-    autoIngest: z20.boolean().optional()
+    ref: z25.string().min(1),
+    subpath: z25.string().optional(),
+    autoIngest: z25.boolean().optional()
   }).nullish()
 });
-var reingestSkillResponseSchema = z20.object({
-  label: z20.string().nullable(),
+var reingestSkillResponseSchema = z25.object({
+  label: z25.string().nullable(),
   /** True = "already current": the source content matches the newest version. */
-  unchanged: z20.boolean()
-});
-var skillRunWireSchema = z20.object({
-  runId: z20.string(),
-  agent: z20.string(),
-  turns: z20.number().int().nullable(),
-  durationMs: z20.number().int().nullable(),
-  costUsd: z20.number().nullable(),
-  finishedAt: z20.string().nullable(),
+  unchanged: z25.boolean()
+});
+var skillRunWireSchema = z25.object({
+  runId: z25.string(),
+  agent: z25.string(),
+  turns: z25.number().int().nullable(),
+  durationMs: z25.number().int().nullable(),
+  costUsd: z25.number().nullable(),
+  finishedAt: z25.string().nullable(),
   /** WHICH version of the skill the session staged. */
-  versionLabel: z20.string().nullable()
+  versionLabel: z25.string().nullable()
 });
-var listSkillRunsResponseSchema = z20.object({
-  items: z20.array(skillRunWireSchema)
+var listSkillRunsResponseSchema = z25.object({
+  items: z25.array(skillRunWireSchema)
 });
 
 // ../packages/api-schemas/src/mcp.ts
 var mcpServerHandleSchema = skillHandleSchema;
 var MCP_SPEC_VERSION = 1;
-var envVarNameSchema = z21.string().min(1).max(128).regex(
+var envVarNameSchema = z26.string().min(1).max(128).regex(
   /^[A-Za-z_][A-Za-z0-9_]*$/,
   "an environment variable name (letters, digits, underscore; not starting with a digit)"
 );
-var headerNameSchema = z21.string().min(1).max(128).regex(
+var headerNameSchema = z26.string().min(1).max(128).regex(
   /^[A-Za-z0-9!#$%&'*+\-.^_`|~]+$/,
   "an HTTP header name (a token \u2014 no colon, no spaces)"
 );
-var mcpToolSchema = z21.object({
-  name: z21.string().min(1).max(128),
-  description: z21.string().max(4096).optional()
+var mcpToolSchema = z26.object({
+  name: z26.string().min(1).max(128),
+  description: z26.string().max(4096).optional()
 });
-var mcpSpecSchema = z21.object({
-  specVersion: z21.literal(MCP_SPEC_VERSION),
-  transport: z21.enum(["stdio", "http"]),
+var mcpSpecSchema = z26.object({
+  specVersion: z26.literal(MCP_SPEC_VERSION),
+  transport: z26.enum(["stdio", "http"]),
   // stdio
-  command: z21.string().min(1).max(512).optional(),
-  args: z21.array(z21.string().max(4096)).max(64).optional(),
-  envNames: z21.array(envVarNameSchema).max(32).optional(),
+  command: z26.string().min(1).max(512).optional(),
+  args: z26.array(z26.string().max(4096)).max(64).optional(),
+  envNames: z26.array(envVarNameSchema).max(32).optional(),
   // http
-  url: z21.string().url().max(2048).optional(),
-  headerNames: z21.array(headerNameSchema).max(32).optional(),
+  url: z26.string().url().max(2048).optional(),
+  headerNames: z26.array(headerNameSchema).max(32).optional(),
   // display only — outside the digest (D13)
   serverName: mcpServerHandleSchema,
-  description: z21.string().max(4096).optional(),
-  tools: z21.array(mcpToolSchema).max(256).optional()
+  description: z26.string().max(4096).optional(),
+  tools: z26.array(mcpToolSchema).max(256).optional()
 }).strict().superRefine((spec, ctx) => {
   if (spec.transport === "stdio") {
     if (!spec.command) {
@@ -1832,17 +2319,17 @@ var mcpSpecSchema = z21.object({
     }
   }
 });
-var mcpExposureSchema = z21.object({
-  serverName: z21.string().min(1),
-  description: z21.string().optional(),
-  tools: z21.array(mcpToolSchema).default([]),
+var mcpExposureSchema = z26.object({
+  serverName: z26.string().min(1),
+  description: z26.string().optional(),
+  tools: z26.array(mcpToolSchema).default([]),
   /** Declared credential NAMES, mirrored here so the picker and the index row can
    *  render the contract without parsing `spec`. Never values. */
-  envNames: z21.array(z21.string()).default([]),
-  headerNames: z21.array(z21.string()).default([])
+  envNames: z26.array(z26.string()).default([]),
+  headerNames: z26.array(z26.string()).default([])
 });
-var mcpWarningSchema = z21.object({
-  code: z21.enum([
+var mcpWarningSchema = z26.object({
+  code: z26.enum([
     "unpinned_package",
     "credential_required",
     "value_discarded",
@@ -1852,734 +2339,487 @@ var mcpWarningSchema = z21.object({
     // contract was recorded when none was (Bugbot, medium).
     "flag_ignored"
   ]),
-  message: z21.string()
+  message: z26.string()
 });
-var mcpSetEntrySchema = z21.object({
+var mcpSetEntrySchema = z26.object({
   /** `McpServer.id` — the stable handle a UI chip links back to; `label` already
    *  names the version, so this is deliberately not `McpServerVersion.id`. */
-  serverId: z21.string().min(1),
+  serverId: z26.string().min(1),
   /** `McpServer.name` — OUR handle, and the CONFIG KEY the serializer writes. NOT
    *  the agent-visible `spec.serverName`. */
   name: mcpServerHandleSchema,
-  label: z21.string().min(1),
-  specDigest: z21.string().min(1),
+  label: z26.string().min(1),
+  specDigest: z26.string().min(1),
   spec: mcpSpecSchema,
   /** Declared tools/description as at authoring time. The preparation path never
    *  branches on it; it rides along for the trace and the UI. */
-  exposure: z21.record(z21.string(), z21.unknown()).optional()
+  exposure: z26.record(z26.string(), z26.unknown()).optional(),
+  /** Connection selected by this immutable MCP version. The matching non-secret
+   * provider metadata lives in Batch.connectionSet. */
+  connectionId: z26.string().min(1).optional()
 });
 var MAX_MCP_SET_ENTRIES = 8;
-var mcpSetSchema = z21.array(mcpSetEntrySchema).max(
+var mcpSetSchema = z26.array(mcpSetEntrySchema).max(
   MAX_MCP_SET_ENTRIES,
   `a run may prepare at most ${MAX_MCP_SET_ENTRIES} MCP servers`
 );
-var mcpRefSchema = z21.string().min(3).max(320).regex(
+var mcpRefSchema = z26.string().min(3).max(320).regex(
   /^[A-Za-z0-9][A-Za-z0-9._-]*@[^,]+$/,
   'an MCP server reference must be "name@label" (a bare name is not a reference)'
 );
-var mcpRefsSchema = z21.array(mcpRefSchema).max(MAX_MCP_SET_ENTRIES);
-var mcpVersionWireSchema = z21.object({
-  id: z21.string(),
-  label: z21.string(),
-  specDigest: z21.string(),
+var mcpRefsSchema = z26.array(mcpRefSchema).max(MAX_MCP_SET_ENTRIES);
+var mcpVersionWireSchema = z26.object({
+  id: z26.string(),
+  label: z26.string(),
+  specDigest: z26.string(),
   spec: mcpSpecSchema,
   exposure: mcpExposureSchema,
-  warnings: z21.array(mcpWarningSchema),
-  createdAt: z21.string()
+  warnings: z26.array(mcpWarningSchema),
+  createdAt: z26.string()
 });
-var mcpServerListItemSchema = z21.object({
-  id: z21.string(),
+var mcpServerListItemSchema = z26.object({
+  id: z26.string(),
   /** OUR handle — the {ref} segment and the config key the serializer writes. */
   name: mcpServerHandleSchema,
-  note: z21.string().nullable(),
+  note: z26.string().nullable(),
   latestVersion: mcpVersionWireSchema.nullable(),
-  versionCount: z21.number().int(),
-  createdAt: z21.string(),
-  updatedAt: z21.string()
+  versionCount: z26.number().int(),
+  createdAt: z26.string(),
+  updatedAt: z26.string()
 });
-var listMcpServersResponseSchema = z21.object({
-  items: z21.array(mcpServerListItemSchema)
+var listMcpServersResponseSchema = z26.object({
+  items: z26.array(mcpServerListItemSchema)
 });
-var mcpServerDetailSchema = mcpServerListItemSchema.omit({ latestVersion: true }).extend({ versions: z21.array(mcpVersionWireSchema) });
-var saveMcpServerBodySchema = z21.object({
+var mcpServerDetailSchema = mcpServerListItemSchema.omit({ latestVersion: true }).extend({ versions: z26.array(mcpVersionWireSchema) });
+var saveMcpServerBodySchema = z26.object({
   name: mcpServerHandleSchema,
-  spec: z21.unknown(),
+  spec: z26.unknown(),
   /** A typed label is intent and always mints; omitted defaults to a UTC
    *  timestamp label and dedups by spec digest. */
-  label: z21.string().min(1).max(120).optional(),
-  note: z21.string().max(2e3).optional()
-});
-var saveMcpServerResponseSchema = z21.object({
-  serverId: z21.string().nullable(),
-  handle: z21.string(),
-  label: z21.string(),
-  specDigest: z21.string(),
-  warnings: z21.array(mcpWarningSchema),
+  label: z26.string().min(1).max(120).optional(),
+  note: z26.string().max(2e3).optional()
+});
+var saveMcpServerResponseSchema = z26.object({
+  serverId: z26.string().nullable(),
+  handle: z26.string(),
+  label: z26.string(),
+  specDigest: z26.string(),
+  warnings: z26.array(mcpWarningSchema),
   /** True = the newest version already carries this exact spec. */
-  unchanged: z21.boolean(),
+  unchanged: z26.boolean(),
   /** Display-only rendered invocation or URL. */
-  invocation: z21.string()
+  invocation: z26.string()
 });
-var updateMcpServerBodySchema = z21.object({
+var updateMcpServerBodySchema = z26.object({
   name: mcpServerHandleSchema.optional(),
-  note: z21.string().max(2e3).nullish()
+  note: z26.string().max(2e3).nullish()
 });
 
 // ../packages/api-schemas/src/me.ts
-import { z as z22 } from "zod";
-var meUserSchema = z22.object({
-  id: z22.string(),
-  email: z22.string().nullable(),
-  isSuperuser: z22.boolean()
+import { z as z27 } from "zod";
+var meUserSchema = z27.object({
+  id: z27.string(),
+  email: z27.string().nullable(),
+  isSuperuser: z27.boolean()
 });
-var meOrgSchema = z22.object({
-  slug: z22.string(),
+var meOrgSchema = z27.object({
+  slug: z27.string(),
   // Gauge's immutable Organization.public_id; null for LOCAL orgs.
-  publicId: z22.string().nullable(),
-  name: z22.string()
+  publicId: z27.string().nullable(),
+  name: z27.string()
 });
-var meResponseSchema = z22.object({
+var meResponseSchema = z27.object({
   user: meUserSchema,
   // Membership-scoped for normal users; superusers see every org (mirrors the
   // web tier's userOrgs).
-  orgs: z22.array(meOrgSchema)
+  orgs: z27.array(meOrgSchema)
 });
 
 // ../packages/api-schemas/src/orgs.ts
-import { z as z23 } from "zod";
-var createOrgRequestSchema = z23.object({
+import { z as z28 } from "zod";
+var createOrgRequestSchema = z28.object({
   /** Workspace display name; the slug is derived server-side. */
-  name: z23.string().trim().min(1).max(200),
+  name: z28.string().trim().min(1).max(200),
   /** Optional company site (logo source; stamped onto the org). */
-  website: z23.string().trim().max(300).optional()
+  website: z28.string().trim().max(300).optional()
 });
-var createOrgResponseSchema = z23.object({
-  slug: z23.string(),
-  name: z23.string(),
+var createOrgResponseSchema = z28.object({
+  slug: z28.string(),
+  name: z28.string(),
   // LOCAL orgs never have a Gauge publicId.
-  publicId: z23.string().nullable()
+  publicId: z28.string().nullable()
 });
-var orgSettingsSchema = z23.object({
-  slug: z23.string(),
-  name: z23.string(),
-  publicId: z23.string().nullable(),
-  website: z23.string().nullable(),
+var orgSettingsSchema = z28.object({
+  slug: z28.string(),
+  name: z28.string(),
+  publicId: z28.string().nullable(),
+  website: z28.string().nullable(),
   /** Per-run max-spend override in USD; null = the server default. */
-  maxSpendUsd: z23.number().nullable(),
-  overageEnabled: z23.boolean(),
+  maxSpendUsd: z28.number().nullable(),
+  overageEnabled: z28.boolean(),
   /** Per-cycle overage cap in credits; null = uncapped. */
-  overageCapCredits: z23.number().int().nullable(),
+  overageCapCredits: z28.number().int().nullable(),
   /** Domain claimed for same-domain auto-join; null = off. */
-  autoJoinDomain: z23.string().nullable()
+  autoJoinDomain: z28.string().nullable()
 });
-var orgMemberSchema = z23.object({
-  userId: z23.string(),
-  name: z23.string().nullable(),
-  email: z23.string().nullable(),
-  joinedAt: z23.string()
+var orgMemberSchema = z28.object({
+  userId: z28.string(),
+  name: z28.string().nullable(),
+  email: z28.string().nullable(),
+  joinedAt: z28.string()
 });
-var listMembersResponseSchema = z23.object({
-  items: z23.array(orgMemberSchema)
+var listMembersResponseSchema = z28.object({
+  items: z28.array(orgMemberSchema)
 });
 
 // ../packages/api-schemas/src/personas.ts
-import { z as z24 } from "zod";
-var personaSchema = z24.object({
-  id: z24.string(),
-  name: z24.string(),
-  description: z24.string(),
+import { z as z29 } from "zod";
+var personaSchema = z29.object({
+  id: z29.string(),
+  name: z29.string(),
+  description: z29.string(),
   /** The judge model this persona calls (Claude only). */
-  model: z24.string(),
-  createdAt: z24.string(),
-  updatedAt: z24.string()
+  model: z29.string(),
+  createdAt: z29.string(),
+  updatedAt: z29.string()
 });
-var listPersonasResponseSchema = z24.object({
-  items: z24.array(personaSchema)
+var listPersonasResponseSchema = z29.object({
+  items: z29.array(personaSchema)
 });
-var createPersonaBodySchema = z24.object({
-  name: z24.string().min(1).max(120),
-  description: z24.string().min(1)
+var createPersonaBodySchema = z29.object({
+  name: z29.string().min(1).max(120),
+  description: z29.string().min(1)
 });
-var updatePersonaBodySchema = z24.object({
-  name: z24.string().min(1).max(120).optional(),
-  description: z24.string().min(1).optional()
+var updatePersonaBodySchema = z29.object({
+  name: z29.string().min(1).max(120).optional(),
+  description: z29.string().min(1).optional()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z28 } from "zod";
+import { z as z32 } from "zod";
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z25 } from "zod";
-var tagSchema = z25.object({
-  id: z25.string(),
-  name: z25.string(),
+import { z as z30 } from "zod";
+var tagSchema = z30.object({
+  id: z30.string(),
+  name: z30.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z25.string()
+  color: z30.string()
 });
-var createTagBodySchema = z25.object({
-  name: z25.string().min(1),
-  color: z25.string().optional()
+var createTagBodySchema = z30.object({
+  name: z30.string().min(1),
+  color: z30.string().optional()
 });
-var updateTagBodySchema = z25.object({
-  name: z25.string().min(1).optional(),
-  color: z25.string().optional()
+var updateTagBodySchema = z30.object({
+  name: z30.string().min(1).optional(),
+  color: z30.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z26 } from "zod";
-var topicSchema = z26.object({
-  id: z26.string(),
-  name: z26.string()
+import { z as z31 } from "zod";
+var topicSchema = z31.object({
+  id: z31.string(),
+  name: z31.string()
 });
-var createTopicBodySchema = z26.object({
-  name: z26.string().min(1, "name is required")
+var createTopicBodySchema = z31.object({
+  name: z31.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
-// ../packages/api-schemas/src/web-fixtures.ts
-import { z as z27 } 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 = z27.object({
-  title: z27.string().min(1),
-  url: z27.url().transform(withoutFragment),
-  snippet: z27.string()
-});
-var searchFixtureSchema = z27.object({
-  query: z27.string().trim().min(1),
-  results: z27.array(searchResultSchema)
-});
-var pageFixtureSchema = z27.object({
-  url: z27.url().transform(withoutFragment),
-  status: z27.int().min(100).max(599).default(200),
-  contentType: z27.string().trim().min(1).default("text/html"),
-  body: z27.string()
-});
-var webFixtureSchema = z27.object({
-  version: z27.literal(1),
-  searches: z27.array(searchFixtureSchema).default([]),
-  pages: z27.array(pageFixtureSchema).default([])
-}).superRefine((fixture, ctx) => {
-  const queries = /* @__PURE__ */ new Set();
-  fixture.searches.forEach((entry, index) => {
-    if (queries.has(entry.query)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["searches", index, "query"],
-        message: `duplicate normalized query: ${entry.query}`
-      });
-    }
-    queries.add(entry.query);
-  });
-  const urls = /* @__PURE__ */ new Set();
-  fixture.pages.forEach((entry, index) => {
-    if (urls.has(entry.url)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["pages", index, "url"],
-        message: `duplicate normalized URL: ${entry.url}`
-      });
-    }
-    urls.add(entry.url);
-  });
-  const bytes = new TextEncoder().encode(JSON.stringify(fixture)).byteLength;
-  if (bytes > MAX_WEB_FIXTURE_BYTES) {
-    ctx.addIssue({
-      code: "custom",
-      message: `serialized fixture is ${bytes} bytes; maximum is ${MAX_WEB_FIXTURE_BYTES}`
-    });
-  }
-});
-
 // ../packages/api-schemas/src/prompts.ts
-var promptSummarySchema = z28.object({
-  id: z28.string(),
-  text: z28.string(),
-  isBranded: z28.boolean(),
+var promptSummarySchema = z32.object({
+  id: z32.string(),
+  text: z32.string(),
+  isBranded: z32.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z28.string().nullable(),
+  externalKey: z32.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z28.array(tagSchema),
-  scheduleCount: z28.number().int(),
-  createdAt: z28.string()
+  tags: z32.array(tagSchema),
+  scheduleCount: z32.number().int(),
+  createdAt: z32.string()
 });
-var promptScheduleRefSchema = z28.object({
-  id: z28.string(),
-  name: z28.string(),
+var promptScheduleRefSchema = z32.object({
+  id: z32.string(),
+  name: z32.string(),
   cadence: cadenceSchema,
-  daysPerWeek: z28.number().int().nullable(),
-  enabled: z28.boolean()
+  daysPerWeek: z32.number().int().nullable(),
+  enabled: z32.boolean()
 });
 var promptDetailSchema = promptSummarySchema.extend({
-  schedules: z28.array(promptScheduleRefSchema)
+  schedules: z32.array(promptScheduleRefSchema)
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z28.string().min(1).optional(),
-  tag: z28.string().min(1).optional(),
-  q: z28.string().min(1).optional()
-});
-var createPromptBodySchema = z28.object({
-  text: z28.string().min(1, "text is required"),
-  isBranded: z28.boolean().default(false),
-  topic: z28.string().min(1).optional(),
-  tags: z28.array(z28.string().min(1)).default([])
-});
-var updatePromptBodySchema = z28.object({
-  text: z28.string().min(1).optional(),
-  isBranded: z28.boolean().optional(),
-  topicId: z28.string().min(1).nullish(),
-  tags: z28.array(z28.string().min(1)).optional()
-});
-var runPromptBodySchema = z28.object({
+  topic: z32.string().min(1).optional(),
+  tag: z32.string().min(1).optional(),
+  q: z32.string().min(1).optional()
+});
+var createPromptBodySchema = z32.object({
+  text: z32.string().min(1, "text is required"),
+  isBranded: z32.boolean().default(false),
+  topic: z32.string().min(1).optional(),
+  tags: z32.array(z32.string().min(1)).default([])
+});
+var updatePromptBodySchema = z32.object({
+  text: z32.string().min(1).optional(),
+  isBranded: z32.boolean().optional(),
+  topicId: z32.string().min(1).nullish(),
+  tags: z32.array(z32.string().min(1)).optional()
+});
+var runPromptBodySchema = z32.object({
   /** Preferred paired representation; each agent may pin its own model tiers. */
-  agentConfigs: z28.array(scheduleAgentConfigInputSchema).min(1).optional(),
+  agentConfigs: z32.array(scheduleAgentConfigInputSchema).min(1).optional(),
   /** Legacy agent set (no per-agent pins), kept during the API transition. */
-  agents: z28.array(agentSchema).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
-  repoUrl: z28.string().min(1).nullish(),
-  repoRef: z28.string().min(1).nullish(),
-  samplesPerCycle: z28.number().int().min(1).max(10).default(1),
+  agents: z32.array(agentSchema).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z32.string().min(1).nullish(),
+  repoRef: z32.string().min(1).nullish(),
+  samplesPerCycle: z32.number().int().min(1).max(10).default(1),
   webFixture: webFixtureSchema.optional()
 });
-var runPromptResponseSchema = z28.object({
-  batchIds: z28.array(z28.string()),
-  runIds: z28.array(z28.string()),
-  blocked: z28.enum(["insufficient_credits", "needs_provider_key"]).optional()
+var runPromptResponseSchema = z32.object({
+  batchIds: z32.array(z32.string()),
+  runIds: z32.array(z32.string()),
+  blocked: z32.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z29 } from "zod";
+import { z as z33 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z29.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z29.object({
-  url: z29.string(),
-  name: z29.string(),
-  isSystem: z29.boolean(),
-  languages: z29.array(z29.string()),
-  frameworks: z29.array(z29.string()),
+var repoSizeBucketSchema = z33.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z33.object({
+  url: z33.string(),
+  name: z33.string(),
+  isSystem: z33.boolean(),
+  languages: z33.array(z33.string()),
+  frameworks: z33.array(z33.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z29.array(z29.string()),
-  primaryLanguage: z29.string(),
-  sizeKb: z29.number(),
+  tags: z33.array(z33.string()),
+  primaryLanguage: z33.string(),
+  sizeKb: z33.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z29.number()
+  stars: z33.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z29.object({
-  url: z29.string().min(1, "url is required"),
+var addRepoBodySchema = z33.object({
+  url: z33.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: z29.string().min(1).optional(),
+  ref: z33.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z29.string().min(1).optional(),
+  name: z33.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z29.array(z29.string()).optional(),
-  tags: z29.array(z29.string()).optional()
+  frameworks: z33.array(z33.string()).optional(),
+  tags: z33.array(z33.string()).optional()
 });
-var updateRepoBodySchema = z29.object({
-  url: z29.string().min(1, "url is required"),
-  name: z29.string().min(1).optional(),
-  frameworks: z29.array(z29.string()).optional(),
-  tags: z29.array(z29.string()).optional()
+var updateRepoBodySchema = z33.object({
+  url: z33.string().min(1, "url is required"),
+  name: z33.string().min(1).optional(),
+  frameworks: z33.array(z33.string()).optional(),
+  tags: z33.array(z33.string()).optional()
 });
-var resyncRepoBodySchema = z29.object({
-  url: z29.string().min(1, "url is required")
+var resyncRepoBodySchema = z33.object({
+  url: z33.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z29.object({
-  url: z29.string().min(1, "url is required")
+var deleteRepoQuerySchema = z33.object({
+  url: z33.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z29.object({
+var repoSyncResultSchema = z33.object({
   repo: repoSchema,
-  synced: z29.boolean()
-});
-
-// ../packages/api-schemas/src/runs.ts
-import { z as z30 } from "zod";
-var RUN_STATUSES = [
-  "QUEUED",
-  "CLAIMED",
-  "PROVISIONING",
-  "RUNNING",
-  "SUCCEEDED",
-  "FAILED",
-  "TIMED_OUT",
-  "CANCELED"
-];
-var runStatusSchema = z30.enum(RUN_STATUSES);
-var AGENTS2 = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema2 = z30.enum(AGENTS2);
-var runStatusFilterSchema = z30.string().transform(
-  (raw) => raw.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean)
-).pipe(z30.array(runStatusSchema).min(1));
-var runListQuerySchema = listQuerySchema.extend({
-  status: runStatusFilterSchema.optional(),
-  batch: z30.string().optional(),
-  prompt: z30.string().optional(),
-  experiment: z30.string().optional(),
-  evalSet: z30.string().optional(),
-  since: z30.string().optional()
-});
-var runListItemSchema = z30.object({
-  id: z30.string(),
-  status: runStatusSchema,
-  agent: agentSchema2,
-  model: z30.string(),
-  promptId: z30.string(),
-  /** First ~80 chars of the batch's prompt snapshot, whitespace-collapsed. */
-  promptSnippet: z30.string(),
-  batchId: z30.string(),
-  experiment: z30.string().nullable(),
-  /** The eval set whose expansion (or backfill) minted the batch; null for
-   *  schedule/visibility/ad-hoc runs. */
-  evalSetId: z30.string().nullable(),
-  turns: z30.number().int().nullable(),
-  usdCost: z30.number().nullable(),
-  durationMs: z30.number().int().nullable(),
-  exitReason: z30.string().nullable(),
-  createdAt: z30.string(),
-  startedAt: z30.string().nullable(),
-  finishedAt: z30.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: z30.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: z30.string().nullable()
-});
-var runListResponseSchema = listResponseSchema(runListItemSchema);
-var runDetailSchema = runListItemSchema.omit({ promptSnippet: true }).extend({
-  promptText: z30.string(),
-  attempt: z30.number().int(),
-  cancelRequested: z30.boolean(),
-  failureReason: z30.string().nullable(),
-  repoUrl: z30.string().nullable(),
-  repoRef: z30.string().nullable(),
-  scenario: z30.string(),
-  funding: z30.string(),
-  /** Raw harness usage write-back (token counts etc.); shape may evolve. */
-  usage: z30.unknown().nullable(),
-  /** Artifact pointer: a working-tree diff exists at GET /runs/{id}/diff. */
-  hasDiff: z30.boolean(),
-  claimedAt: z30.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: z30.array(
-    z30.object({
-      criterionId: z30.string().nullable(),
-      name: z30.string(),
-      passed: z30.boolean(),
-      reasoning: z30.string().nullable()
-    })
-  )
-});
-var cancelRunResponseSchema = z30.object({
-  id: z30.string(),
-  status: runStatusSchema,
-  cancelRequested: z30.boolean(),
-  note: z30.string().optional()
-});
-var forkRunBodySchema = z30.object({
-  prompt: z30.string().trim().min(1).max(2e4),
-  turn: z30.number().int().min(0).optional(),
-  webFixture: webFixtureSchema.optional()
-});
-var forkRunResponseSchema = z30.object({
-  runId: z30.string(),
-  batchId: z30.string(),
-  parentRunId: z30.string(),
-  checkpointId: z30.string(),
-  turn: z30.number().int().min(0)
-});
-var fetchForkAtFetchBodySchema = z30.object({
-  boundarySeq: z30.string().min(1),
-  injectedContent: z30.string(),
-  prompts: z30.array(z30.string()).min(1)
-});
-var fetchForkAtFetchResponseSchema = z30.object({
-  planId: z30.string()
-});
-var fetchForkPlanStatusSchema = z30.enum([
-  "DRAFT",
-  "SURGERY_RUNNING",
-  "SURGERY_READY",
-  "FORKED",
-  "FAILED"
-]);
-var fetchForkPlanResponseSchema = z30.object({
-  id: z30.string(),
-  status: fetchForkPlanStatusSchema,
-  boundaryUrl: z30.string(),
-  boundaryTurn: z30.number().int(),
-  prompts: z30.array(z30.string()),
-  surgicalCheckpointId: z30.string().nullable(),
-  forkBatchId: z30.string().nullable(),
-  errorText: z30.string().nullable(),
-  forkedRunIds: z30.array(z30.string())
-});
-var RUN_INSIGHT_STATUSES = [
-  "PENDING",
-  "RUNNING",
-  "COMPLETE",
-  "FAILED",
-  "SKIPPED"
-];
-var runInsightStatusSchema = z30.enum(RUN_INSIGHT_STATUSES);
-var insightPassSchema = z30.object({
-  status: runInsightStatusSchema,
-  model: z30.string().nullable(),
-  inputTokens: z30.number().int().nullable(),
-  outputTokens: z30.number().int().nullable(),
-  usdCost: z30.number().nullable(),
-  error: z30.string().nullable()
-});
-var runDecisionSchema = z30.object({
-  index: z30.number().int(),
-  category: z30.string(),
-  categoryRaw: z30.string().nullable(),
-  chosenName: z30.string(),
-  chosenEcosystem: z30.string().nullable(),
-  chosenPackage: z30.string().nullable(),
-  reversed: z30.boolean(),
-  detail: z30.unknown()
-});
-var runImplementationSchema = z30.object({
-  brandName: z30.string(),
-  ecosystem: z30.string().nullable(),
-  package: z30.string().nullable(),
-  verdict: z30.string(),
-  docConsulted: z30.boolean(),
-  detail: z30.unknown()
-});
-var RUN_INSIGHT_PASS_KINDS = [
-  "INSTALL",
-  "DECISION",
-  "EVAL",
-  "INTEGRATION",
-  "EXPERIMENT_DELTA",
-  "VISIBILITY"
-];
-var runInsightPassKindSchema = z30.enum(RUN_INSIGHT_PASS_KINDS);
-var insightPipelinePassSchema = insightPassSchema.extend({
-  kind: runInsightPassKindSchema
-});
-var runInsightResponseSchema = z30.object({
-  runId: z30.string(),
-  decision: insightPassSchema,
-  implementation: insightPassSchema,
-  passes: z30.array(insightPipelinePassSchema),
-  decisions: z30.array(runDecisionSchema),
-  implementations: z30.array(runImplementationSchema),
-  experimentDelta: z30.unknown().nullable(),
-  /** The VISIBILITY pass's output (winners/picks) — loose server JSON, null
-   *  for non-visibility runs or before the pass completes. */
-  visibilityVerdict: z30.unknown().nullable()
-});
-var runEventSchema = z30.looseObject({
-  run_id: z30.string(),
-  seq: z30.number(),
-  turn: z30.number(),
-  ts: z30.string(),
-  type: z30.string()
+  synced: z33.boolean()
 });
 
 // ../packages/api-schemas/src/summary.ts
-import { z as z31 } from "zod";
+import { z as z34 } from "zod";
 function cardResultSchema(data) {
-  return z31.union([
-    z31.object({ ok: z31.literal(true), data }),
-    z31.object({ ok: z31.literal(false), error: z31.string() })
+  return z34.union([
+    z34.object({ ok: z34.literal(true), data }),
+    z34.object({ ok: z34.literal(false), error: z34.string() })
   ]);
 }
-var summaryActionSchema = z31.object({
-  id: z31.string(),
-  title: z31.string(),
-  priority: z31.string(),
-  status: z31.string(),
-  evidenceCount: z31.number().int()
-});
-var summaryAeCardSchema = z31.object({
-  id: z31.string(),
-  name: z31.string(),
-  judgedRuns: z31.number().int(),
-  passRate: z31.number().nullable(),
+var summaryActionSchema = z34.object({
+  id: z34.string(),
+  title: z34.string(),
+  priority: z34.string(),
+  status: z34.string(),
+  evidenceCount: z34.number().int()
+});
+var summaryAeCardSchema = z34.object({
+  id: z34.string(),
+  name: z34.string(),
+  judgedRuns: z34.number().int(),
+  passRate: z34.number().nullable(),
   /** pp delta vs the prior 30d; null with no prior. */
-  deltaPP: z31.number().nullable()
-});
-var summaryVisibilityCardSchema = z31.object({
-  name: z31.string(),
-  owned: z31.object({
-    name: z31.string(),
-    rank: z31.number(),
-    chosenRate: z31.number(),
-    mentionRate: z31.number()
+  deltaPP: z34.number().nullable()
+});
+var summaryVisibilityCardSchema = z34.object({
+  name: z34.string(),
+  owned: z34.object({
+    name: z34.string(),
+    rank: z34.number(),
+    chosenRate: z34.number(),
+    mentionRate: z34.number()
   }).nullable(),
-  chosenDeltaPP: z31.number().nullable()
+  chosenDeltaPP: z34.number().nullable()
 });
-var homeSummarySchema = z31.object({
-  hasAnyRuns: z31.boolean(),
-  lastSynthesisAt: z31.string().nullable(),
-  actions: cardResultSchema(z31.array(summaryActionSchema)),
+var homeSummarySchema = z34.object({
+  hasAnyRuns: z34.boolean(),
+  lastSynthesisAt: z34.string().nullable(),
+  actions: cardResultSchema(z34.array(summaryActionSchema)),
   visibility: cardResultSchema(
-    z31.object({
-      cards: z31.array(summaryVisibilityCardSchema),
-      marketsTotal: z31.number().int(),
-      promptCount: z31.number().int()
+    z34.object({
+      cards: z34.array(summaryVisibilityCardSchema),
+      marketsTotal: z34.number().int(),
+      promptCount: z34.number().int()
     })
   ),
   agentExperience: cardResultSchema(
-    z31.object({
-      cards: z31.array(summaryAeCardSchema),
-      total: z31.number().int(),
-      setCount: z31.number().int()
+    z34.object({
+      cards: z34.array(summaryAeCardSchema),
+      total: z34.number().int(),
+      setCount: z34.number().int()
     })
   ),
-  notableSessions: cardResultSchema(z31.array(z31.unknown()))
+  notableSessions: cardResultSchema(z34.array(z34.unknown()))
 });
 
 // ../packages/api-schemas/src/tokens.ts
-import { z as z32 } from "zod";
-var apiTokenSchema = z32.object({
-  id: z32.string(),
-  name: z32.string(),
+import { z as z35 } from "zod";
+var apiTokenSchema = z35.object({
+  id: z35.string(),
+  name: z35.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z32.string(),
-  expiresAt: z32.iso.datetime().nullable(),
-  lastUsedAt: z32.iso.datetime().nullable(),
-  createdAt: z32.iso.datetime(),
-  revokedAt: z32.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z32.object({
-  name: z32.string().min(1).max(100),
+  last4: z35.string(),
+  expiresAt: z35.iso.datetime().nullable(),
+  lastUsedAt: z35.iso.datetime().nullable(),
+  createdAt: z35.iso.datetime(),
+  revokedAt: z35.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z35.object({
+  name: z35.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z32.iso.datetime({ offset: true }).optional()
+  expiresAt: z35.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z32.string()
+  token: z35.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
 // ../packages/api-schemas/src/visibility.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 var VISIBILITY_PROMPT_KINDS = ["HEAD_TO_HEAD", "RECOMMEND"];
-var visibilityPromptKindSchema = z33.enum(VISIBILITY_PROMPT_KINDS);
-var visibilityPromptSchema = z33.object({
-  id: z33.string(),
+var visibilityPromptKindSchema = z36.enum(VISIBILITY_PROMPT_KINDS);
+var visibilityPromptSchema = z36.object({
+  id: z36.string(),
   kind: visibilityPromptKindSchema,
-  promptText: z33.string(),
+  promptText: z36.string(),
   /** HEAD_TO_HEAD is always branded; RECOMMEND may be either. */
-  branded: z33.boolean(),
-  brandA: z33.string().nullable(),
-  brandB: z33.string().nullable(),
+  branded: z36.boolean(),
+  brandA: z36.string().nullable(),
+  brandB: z36.string().nullable(),
   /** null = the greenfield scaffold. */
-  repoUrl: z33.string().nullable(),
-  repoRef: z33.string().nullable(),
-  market: z33.object({ id: z33.string(), slug: z33.string(), name: z33.string() }).nullable(),
-  position: z33.number().int(),
-  enabled: z33.boolean(),
-  createdAt: z33.string(),
+  repoUrl: z36.string().nullable(),
+  repoRef: z36.string().nullable(),
+  market: z36.object({ id: z36.string(), slug: z36.string(), name: z36.string() }).nullable(),
+  position: z36.number().int(),
+  enabled: z36.boolean(),
+  createdAt: z36.string(),
   cycle: cycleSchema,
   /** User tag names on the hidden backing prompt (Surface:* excluded). */
-  tags: z33.array(z33.string()),
-  runCount: z33.number().int(),
-  lastRunAt: z33.string().nullable(),
+  tags: z36.array(z36.string()),
+  runCount: z36.number().int(),
+  lastRunAt: z36.string().nullable(),
   /** ALL attached presets in expansion order — every one runs each cycle.
    *  The flattened repoUrl/repoRef above mirror the primary only. */
-  runPresets: z33.array(runPresetSummarySchema)
+  runPresets: z36.array(runPresetSummarySchema)
 });
-var listVisibilityPromptsResponseSchema = z33.object({
-  items: z33.array(visibilityPromptSchema)
+var listVisibilityPromptsResponseSchema = z36.object({
+  items: z36.array(visibilityPromptSchema)
 });
-var createVisibilityPromptBodySchema = z33.object({
-  promptText: z33.string().min(1),
+var createVisibilityPromptBodySchema = z36.object({
+  promptText: z36.string().min(1),
   kind: visibilityPromptKindSchema,
-  branded: z33.boolean().optional(),
+  branded: z36.boolean().optional(),
   /** Required pair for HEAD_TO_HEAD (order-independent). */
-  brandA: z33.string().nullish(),
-  brandB: z33.string().nullish(),
-  repoUrl: z33.string().nullish(),
-  repoRef: z33.string().nullish(),
+  brandA: z36.string().nullish(),
+  brandB: z36.string().nullish(),
+  repoUrl: z36.string().nullish(),
+  repoRef: z36.string().nullish(),
   /** Measured market id from the org's tracked set. */
-  marketId: z33.string().nullish(),
-  enabled: z33.boolean().optional(),
-  tags: z33.array(z33.string()).optional(),
+  marketId: z36.string().nullish(),
+  enabled: z36.boolean().optional(),
+  tags: z36.array(z36.string()).optional(),
   /** Attach these existing presets, in order. When either preset field is
    *  present the repo fields above are ignored for configuration (D2). */
-  runPresetIds: z33.array(z33.string().min(1)).optional(),
+  runPresetIds: z36.array(z36.string().min(1)).optional(),
   /** Mint a saved preset and attach it (after runPresetIds). */
   newPreset: inlinePresetSchema.optional()
 });
-var synthesizeResponseSchema = z33.object({
+var synthesizeResponseSchema = z36.object({
   /** False when the pre-check found no new evidence and nothing was queued. */
-  queued: z33.boolean()
-});
-var updateVisibilityPromptBodySchema = z33.object({
-  promptText: z33.string().min(1).optional(),
-  branded: z33.boolean().optional(),
-  brandA: z33.string().nullish(),
-  brandB: z33.string().nullish(),
-  repoUrl: z33.string().nullish(),
-  repoRef: z33.string().nullish(),
-  marketId: z33.string().nullish(),
-  enabled: z33.boolean().optional(),
-  tags: z33.array(z33.string()).optional()
-});
-var runVisibilityPromptResponseSchema = z33.object({
-  batchIds: z33.array(z33.string()),
-  runIds: z33.array(z33.string())
-});
-var visibilityPromptRunSchema = z33.object({
-  id: z33.string(),
-  status: z33.string(),
-  agent: agentSchema,
-  model: z33.string().nullable(),
-  resolvedModel: z33.string().nullable(),
-  createdAt: z33.string(),
-  startedAt: z33.string().nullable(),
-  finishedAt: z33.string().nullable(),
-  failureReason: z33.string().nullable(),
-  verdict: z33.object({
-    status: z33.string(),
-    error: z33.string().nullable(),
-    payload: z33.unknown().nullable()
+  queued: z36.boolean()
+});
+var updateVisibilityPromptBodySchema = z36.object({
+  promptText: z36.string().min(1).optional(),
+  branded: z36.boolean().optional(),
+  brandA: z36.string().nullish(),
+  brandB: z36.string().nullish(),
+  repoUrl: z36.string().nullish(),
+  repoRef: z36.string().nullish(),
+  marketId: z36.string().nullish(),
+  enabled: z36.boolean().optional(),
+  tags: z36.array(z36.string()).optional()
+});
+var runVisibilityPromptResponseSchema = z36.object({
+  batchIds: z36.array(z36.string()),
+  runIds: z36.array(z36.string())
+});
+var visibilityPromptRunSchema = z36.object({
+  id: z36.string(),
+  status: z36.string(),
+  agent: agentSchema2,
+  model: z36.string().nullable(),
+  resolvedModel: z36.string().nullable(),
+  createdAt: z36.string(),
+  startedAt: z36.string().nullable(),
+  finishedAt: z36.string().nullable(),
+  failureReason: z36.string().nullable(),
+  verdict: z36.object({
+    status: z36.string(),
+    error: z36.string().nullable(),
+    payload: z36.unknown().nullable()
   }).nullable()
 });
-var listVisibilityPromptRunsResponseSchema = z33.object({
-  items: z33.array(visibilityPromptRunSchema)
+var listVisibilityPromptRunsResponseSchema = z36.object({
+  items: z36.array(visibilityPromptRunSchema)
 });
-var orgMarketSchema = z33.object({
-  marketId: z33.string(),
-  slug: z33.string(),
-  name: z33.string(),
+var orgMarketSchema = z36.object({
+  marketId: z36.string(),
+  slug: z36.string(),
+  name: z36.string(),
   /** The one line saying what the market measures. */
-  capability: z33.string(),
+  capability: z36.string(),
   /** SUGGESTED (the matcher) | USER (a human picked it). */
-  source: z33.string()
+  source: z36.string()
 });
 var addableMarketSchema = orgMarketSchema.omit({ source: true });
-var listMarketsResponseSchema = z33.object({
-  tracked: z33.array(orgMarketSchema),
+var listMarketsResponseSchema = z36.object({
+  tracked: z36.array(orgMarketSchema),
   /** Published markets the org does not track yet (closed set — no free-text
    *  market creation). */
-  addable: z33.array(addableMarketSchema)
+  addable: z36.array(addableMarketSchema)
 });
-var addMarketBodySchema = z33.object({ marketId: z33.string().min(1) });
+var addMarketBodySchema = z36.object({ marketId: z36.string().min(1) });
 
 // src/version.ts
 import { createRequire } from "module";
@@ -2962,7 +3202,7 @@ __export(apply_exports, {
   register: () => register2
 });
 import { readFileSync as readFileSync3 } from "fs";
-import { z as z34 } from "zod";
+import { z as z37 } from "zod";
 var EXAMPLE_SPEC = {
   version: 1,
   expand: true,
@@ -3084,7 +3324,7 @@ function register2(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(z34.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z37.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -3617,7 +3857,11 @@ var AGENT_ALIASES = {
   codex: "CODEX_CLI",
   "codex-cli": "CODEX_CLI",
   codex_cli: "CODEX_CLI",
-  cursor: "CURSOR"
+  cursor: "CURSOR",
+  pi: "PI",
+  opencode: "OPENCODE",
+  "open-code": "OPENCODE",
+  open_code: "OPENCODE"
 };
 function parseAgents(raw) {
   const out = [];
@@ -3628,7 +3872,7 @@ function parseAgents(raw) {
     if (!agent) {
       throw new CliError(
         "usage",
-        `unknown agent "${name}" (expected: claude-code, codex, cursor)`
+        `unknown agent "${name}" (expected: claude-code, codex, cursor, pi, opencode)`
       );
     }
     out.push(agent);
@@ -3643,13 +3887,13 @@ function parseAgentSpec(raw) {
   if (!agent) {
     throw new CliError(
       "usage",
-      `unknown agent "${name}" in --agent "${raw}" (expected: claude-code or codex, optionally ":model1,model2")`
+      `unknown agent "${name}" in --agent "${raw}" (expected: claude-code, codex, pi, or opencode, optionally ":model1,model2")`
     );
   }
   if (agent === "CURSOR") {
     throw new CliError(
       "usage",
-      "cursor is not schedulable \u2014 presets may roster claude-code and codex only"
+      "cursor is not schedulable \u2014 presets may roster claude-code, codex, pi, and opencode"
     );
   }
   const models = colon < 0 ? [] : raw.slice(colon + 1).split(",").map((m) => m.trim()).filter(Boolean);
@@ -3807,7 +4051,9 @@ function statusLines(s) {
       "Overage",
       s.overageEnabled ? `enabled (${s.overageThisPeriod} used${s.overageCapCredits === null ? ", uncapped" : `, cap ${s.overageCapCredits}`})` : "disabled"
     ],
-    ["Can run", s.canRun ? "yes" : "no (out of credits)"],
+    ["Can run eval", s.canRunByWorkload.eval ? "yes" : "no"],
+    ["Can run visibility", s.canRunByWorkload.visibility ? "yes" : "no"],
+    ["Can run generic", s.canRunByWorkload.generic ? "yes" : "no"],
     ["Billing enforced", s.enforced ? "yes" : "no"]
   ];
 }
@@ -4366,7 +4612,9 @@ function presetsPath(org) {
 var AGENT_LABELS = {
   CLAUDE_CODE: "claude-code",
   CODEX_CLI: "codex",
-  CURSOR: "cursor"
+  CURSOR: "cursor",
+  PI: "pi",
+  OPENCODE: "opencode"
 };
 function agentsLabel(agents) {
   return agents.map((a) => {
@@ -4383,6 +4631,7 @@ function printPresetSummaryTable(presets) {
     presets.map((p) => ({
       id: p.id,
       name: p.name,
+      gauge: p.fromGauge ? "yes" : "",
       saved: p.saved ? "yes" : "no",
       repo: presetRepoLabel(p),
       persona: p.profile?.name ?? "",
@@ -4396,6 +4645,8 @@ function printPresetSummaryTable(presets) {
 function printDetail(p) {
   console.log(`id:       ${p.id}`);
   console.log(`name:     ${p.name}`);
+  if (p.fromGauge) console.log("origin:   from the Gauge catalog");
+  if (p.description) console.log(`about:    ${p.description}`);
   console.log(`saved:    ${p.saved ? "yes" : "no (anonymous)"}`);
   console.log(`repo:     ${presetRepoLabel(p)}`);
   console.log(`persona:  ${p.profile ? p.profile.name : "(default judge)"}`);
@@ -5084,13 +5335,37 @@ function register12(program2) {
   ).requiredOption("--run <runId>", "source run id").requiredOption(
     "--boundary <seq>",
     "opaque boundarySeq from `experiments boundaries`"
-  ).option("--problem <text>", "problem statement (derived if omitted)").action(
+  ).option("--problem <text>", "problem statement (derived if omitted)").option(
+    "--mode <mode>",
+    "who writes the rewrites: propose (default, Fixer proposes directions then writes each), direct (one --change instruction, one write), manual (no generation \u2014 the rewrite is seeded with the page the agent read)",
+    "propose"
+  ).option(
+    "--change <text>",
+    "--mode direct only: the one change to make, in your words"
+  ).action(
     async (opts, cmd) => {
       const org = resolveOrg(cmd);
+      const parsedMode = experiments_exports.experimentModeSchema.safeParse(
+        opts.mode.toUpperCase()
+      );
+      if (!parsedMode.success) {
+        throw new Error(
+          `--mode must be one of ${experiments_exports.EXPERIMENT_MODES.map((m) => m.toLowerCase()).join(", ")}`
+        );
+      }
+      const mode = parsedMode.data;
+      if (mode === "DIRECT" && !opts.change?.trim()) {
+        throw new Error("--mode direct requires --change <text>");
+      }
+      if (mode !== "DIRECT" && opts.change !== void 0) {
+        throw new Error(`--change only applies to --mode direct`);
+      }
       const body = {
         runId: opts.run,
         boundarySeq: opts.boundary,
-        ...opts.problem !== void 0 ? { problemText: opts.problem } : {}
+        ...opts.problem !== void 0 ? { problemText: opts.problem } : {},
+        mode,
+        ...opts.change !== void 0 ? { changeInstruction: opts.change.trim() } : {}
       };
       const result = await createClient().post(
         experimentsPath(org),
@@ -5104,8 +5379,14 @@ function register12(program2) {
         `${result.created ? "Created" : "Resumed"} experiment ${result.experimentId}`
       );
       console.log(`Problem: ${result.problemText}`);
+      console.log(`Mode: ${result.mode.toLowerCase()}`);
+      if (!result.created && result.mode !== mode) {
+        console.error(
+          `Note: this fetch already had a live ${result.mode.toLowerCase()} draft, so --mode ${mode.toLowerCase()} was not applied \u2014 that draft was resumed instead.`
+        );
+      }
       console.error(
-        `Tip: \`gauge experiments watch ${result.experimentId}\` follows the plan round`
+        result.mode === "MANUAL" ? `Tip: \`gauge experiments get ${result.experimentId}\` shows the seeded rewrite once the page is recovered` : `Tip: \`gauge experiments watch ${result.experimentId}\` follows the ${result.mode === "DIRECT" ? "write" : "plan"} round`
       );
     }
   );
@@ -5716,10 +5997,47 @@ function register16(program2) {
   });
 }
 
+// src/commands/models.ts
+var models_exports = {};
+__export(models_exports, {
+  capabilityLabel: () => capabilityLabel,
+  executionTargetsPath: () => executionTargetsPath,
+  register: () => register17
+});
+function executionTargetsPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/execution-targets`;
+}
+function capabilityLabel(capabilities) {
+  return Object.entries(capabilities).filter(([, supported]) => supported).map(([name]) => name === "agentContext" ? "context" : name).join(", ");
+}
+function register17(program2) {
+  const group = program2.command("models").description("Discover supported models, harnesses, and providers");
+  group.command("list", { isDefault: true }).description("List execution targets available to the organization").action(async (_opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const response = await createClient().get(
+      executionTargetsPath(org)
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(response.items);
+      return;
+    }
+    printItems(
+      response.items.map((target) => ({
+        model: target.model,
+        name: target.modelLabel,
+        harness: target.harnessSlug,
+        provider: target.providerSlug,
+        capabilities: capabilityLabel(target.capabilities)
+      })),
+      "table"
+    );
+  });
+}
+
 // src/commands/onboard.ts
 var onboard_exports = {};
 __export(onboard_exports, {
-  register: () => register17
+  register: () => register18
 });
 function orgNameFromEmail(email) {
   const domain = email?.split("@")[1] ?? "";
@@ -5727,7 +6045,7 @@ function orgNameFromEmail(email) {
   if (!base) return "My Workspace";
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
-function register17(program2) {
+function register18(program2) {
   program2.command("onboard").description(
     "Self-serve onboarding: sign in (device flow) and create your first workspace"
   ).option("--email <email>", "email a sign-in link (device-flow convenience)").option("--org-name <name>", "workspace name (default: from your email)").option("--website <url>", "company site (scanned to seed the workspace)").option("--new", "create a new workspace even if you already belong to one").option(
@@ -5824,7 +6142,7 @@ Using workspace ${orgSlug}.`
 // src/commands/org.ts
 var org_exports = {};
 __export(org_exports, {
-  register: () => register18
+  register: () => register19
 });
 function printSettings(s) {
   console.log(`slug:            ${s.slug}`);
@@ -5838,7 +6156,7 @@ function printSettings(s) {
   );
   console.log(`auto-join:       ${s.autoJoinDomain ?? "off"}`);
 }
-function register18(program2) {
+function register19(program2) {
   const group = program2.command("org").description(
     "This org's settings, read-only (see `gauge orgs` for the org list)"
   );
@@ -5855,12 +6173,12 @@ function register18(program2) {
 // src/commands/orgs.ts
 var orgs_exports2 = {};
 __export(orgs_exports2, {
-  register: () => register19
+  register: () => register20
 });
 function isDefault(org, defaultOrg) {
   return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
 }
-function register19(program2) {
+function register20(program2) {
   const orgs = program2.command("orgs").description("Organizations");
   orgs.command("list").description("List orgs you belong to").action(async (_opts, command) => {
     const output = resolveOutput(command);
@@ -5931,12 +6249,12 @@ function register19(program2) {
 // src/commands/personas.ts
 var personas_exports2 = {};
 __export(personas_exports2, {
-  register: () => register20
+  register: () => register21
 });
 function personasPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/personas`;
 }
-function register20(program2) {
+function register21(program2) {
   const group = program2.command("personas").description("Manage judge personas (referenced by presets)");
   group.command("list").description("List the org's personas").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -6009,7 +6327,7 @@ function register20(program2) {
 // src/commands/query.ts
 var query_exports2 = {};
 __export(query_exports2, {
-  register: () => register21
+  register: () => register22
 });
 var collect3 = (value, prev = []) => [
   ...prev,
@@ -6201,7 +6519,7 @@ async function showMetadata(command, mode, dataset) {
   console.error(`dataset: ${ds.name} \u2014 ${ds.grain}`);
   printItems(rows, "table");
 }
-function register21(program2) {
+function register22(program2) {
   const group = program2.command("query").description(
     "Flexible reports over your event warehouse (run a report, or discover the catalog)"
   );
@@ -6237,7 +6555,7 @@ function register21(program2) {
 // src/commands/repos.ts
 var repos_exports2 = {};
 __export(repos_exports2, {
-  register: () => register22
+  register: () => register23
 });
 function reposPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/repos`;
@@ -6260,7 +6578,7 @@ function toRow5(repo) {
 function syncWarning(repo) {
   return `warning: GitHub metadata sync failed; retry with \`gauge repos resync ${repo.url}\``;
 }
-function register22(program2) {
+function register23(program2) {
   const repos = program2.command("repos").description("Manage repositories");
   repos.command("list").description("List repositories (yours + read-only Gauge-provided ones)").action(async (_opts, command) => {
     const org = resolveOrg(command);
@@ -6357,7 +6675,7 @@ function register22(program2) {
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register23
+  register: () => register24
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -6379,10 +6697,14 @@ function compact(value, max = 140) {
   return one.length > max ? `${one.slice(0, max - 1)}\u2026` : one;
 }
 function toRow6(run) {
+  const selected = run.selectedProvider?.slug ?? "";
+  const observed = run.observedProvider?.slug;
   return {
     id: run.id,
     status: run.status,
     agent: run.agent,
+    model: run.modelDisplayName ?? run.resolvedModel ?? run.model,
+    provider: observed && observed !== selected ? `${selected || "?"} \u2192 ${observed}` : selected || observed || "",
     experiment: run.experiment ?? "",
     turns: run.turns ?? "",
     cost: fmtUsd(run.usdCost),
@@ -6396,7 +6718,19 @@ function detailLines(run) {
     ["Id", run.id],
     ["Status", run.status],
     ["Agent", run.agent],
-    ["Model", run.model || "(default)"],
+    [
+      "Model",
+      run.modelDisplayName || run.resolvedModel || run.model || "(platform default)"
+    ],
+    ["Requested model", run.model || "(platform default)"],
+    [
+      "Selected provider",
+      run.selectedProvider ? `${run.selectedProvider.displayName} (${run.selectedProvider.slug})` : "\u2014"
+    ],
+    [
+      "Observed provider",
+      run.observedProvider ? `${run.observedProvider.slug} (${run.observedProvider.source.toLowerCase().replaceAll("_", " ")})` : "\u2014"
+    ],
     ["Prompt", compact(run.promptText, 120)],
     ["Prompt id", run.promptId],
     ["Batch", run.batchId],
@@ -6620,7 +6954,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register23(program2) {
+function register24(program2) {
   const runs = program2.command("runs").description("Inspect and manage runs");
   runs.command("list").description("List runs (newest first)").option("--status <status>", "filter by status, e.g. running,queued").option("--batch <id>", "filter by batch").option("--prompt <id>", "filter by prompt").option("--experiment <experiment>", "filter by experiment label").option("--eval-set <id>", "filter by eval set").option("--since <window>", "e.g. 24h, 7d, or an ISO date").option("--limit <n>", "page size (1-200)", "50").option("--cursor <cursor>", "resume from a previous page's nextCursor").action(
     async (opts, command) => {
@@ -6746,7 +7080,7 @@ function register23(program2) {
 var skills_exports2 = {};
 __export(skills_exports2, {
   buildSkillEditBody: () => buildSkillEditBody,
-  register: () => register24
+  register: () => register25
 });
 function skillsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/skills`;
@@ -6808,7 +7142,7 @@ async function buildSkillEditBody(opts, fetchCurrentSource) {
     throw new CliError("usage", "nothing to change");
   return body;
 }
-function register24(program2) {
+function register25(program2) {
   const group = program2.command("skills").description("Manage agent skills (staged into runs via preset refs)");
   group.command("list").description("List the org's skills with their newest version").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -6949,7 +7283,7 @@ function register24(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register25
+  register: () => register26
 });
 function addFilterOptions(cmd) {
   return cmd.option("--prompt <id>", "filter to a single prompt").option("--tag <ids>", "comma-separated tag ids").option("--repo <urls>", "comma-separated base repo urls").option("--language <langs>", "comma-separated repo languages").option("--framework <names>", "comma-separated repo frameworks").option("--size <buckets>", "comma-separated codebase-size buckets").option("--branded", "only branded prompts").option("--unbranded", "only non-branded prompts").option("--limit <n>", "max rows (default 50)").option("--full", "return all rows (up to 1000)");
@@ -7032,7 +7366,7 @@ var domainRow = (r) => ({
   rate: pct2(r.rate),
   requests: r.requests
 });
-function register25(program2) {
+function register26(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -7064,7 +7398,7 @@ function register25(program2) {
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
-  register: () => register26
+  register: () => register27
 });
 function pct3(rate) {
   return rate == null ? "\u2014" : `${Math.round(rate * 100)}%`;
@@ -7074,7 +7408,7 @@ function delta2(pp) {
   const rounded = Math.round(pp);
   return rounded === 0 ? "" : ` (${rounded > 0 ? "+" : ""}${rounded}pp)`;
 }
-function register26(program2) {
+function register27(program2) {
   program2.command("status").description("One-shot org summary: actions, visibility, agent experience").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
     const s = await createClient().get(
@@ -7136,12 +7470,12 @@ function register26(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register27
+  register: () => register28
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register27(program2) {
+function register28(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7184,9 +7518,9 @@ function register27(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register28
+  register: () => register29
 });
-function register28(program2) {
+function register29(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);
@@ -7233,7 +7567,7 @@ function register28(program2) {
 // src/commands/visibility.ts
 var visibility_exports2 = {};
 __export(visibility_exports2, {
-  register: () => register29,
+  register: () => register30,
   visibilityPath: () => visibilityPath
 });
 function visibilityPath(org) {
@@ -7607,7 +7941,7 @@ function registerPreferenceGroup(group) {
     );
   });
 }
-function register29(program2) {
+function register30(program2) {
   const preference = program2.command("preference").description("Manage Agent Preference prompts and measured markets");
   registerPreferenceGroup(preference);
   const legacy = program2.command("visibility", { hidden: true });
@@ -7631,6 +7965,7 @@ for (const group of [
   orgs_exports2,
   org_exports,
   members_exports,
+  models_exports,
   evals_exports2,
   visibility_exports2,
   presets_exports,