@withgauge/cli 0.9.0 → 0.10.2

package/dist/index.js

@@ -80,6 +80,8 @@ import { z as z3 } from "zod";
 var checkStatusSchema = z3.enum(["pass", "attention", "unassessed"]);
 var checklistItemSchema = z3.object({
   label: z3.string().min(1),
+  /** Still running; distinct from a completed, unassessed finding. */
+  pending: z3.boolean().optional(),
   status: checkStatusSchema,
   evidence: z3.string().min(1),
   /** Present when the item is backed by observed coding sessions rather than a
@@ -116,6 +118,34 @@ var sessionUsageSchema = z3.object({
   cacheReadInputTokens: z3.number().int().nonnegative(),
   cacheCreationInputTokens: z3.number().int().nonnegative()
 });
+var sessionFindingSchema = z3.object({
+  title: z3.string().min(1).max(160),
+  detail: z3.string().min(1).max(600),
+  evidence: z3.array(
+    z3.object({
+      seq: z3.number().int().nonnegative(),
+      quote: z3.string().min(1).max(500)
+    })
+  ).min(1).max(4)
+});
+var onboardingSchema = z3.object({
+  status: z3.enum(["verified", "login_required", "not_verified"]),
+  detail: z3.string().min(1).max(600),
+  evidence: z3.array(
+    z3.object({
+      kind: z3.enum(["credentials", "operation", "blocker"]),
+      seq: z3.number().int().nonnegative(),
+      quote: z3.string().min(1).max(500)
+    })
+  ).max(6)
+});
+var sessionAnalysisSchema = z3.object({
+  status: z3.enum(["complete", "unavailable"]),
+  onboarding: onboardingSchema.optional(),
+  hallucinatedUrls: z3.array(sessionFindingSchema).max(8),
+  blockers: z3.array(sessionFindingSchema).max(8),
+  suggestedChanges: z3.array(sessionFindingSchema).max(8)
+});
 var sessionSchema = z3.object({
   id: z3.string().regex(/^[a-z0-9-]+$/),
   name: z3.string().min(1),
@@ -126,10 +156,44 @@ var sessionSchema = z3.object({
   auth: z3.number().int(),
   pricing: z3.number().int(),
   pricingReview: z3.string(),
+  analysis: sessionAnalysisSchema.optional(),
   /** The alg run id the transcript was recorded from. */
   run: z3.string().min(1),
   completed: z3.boolean(),
-  usage: sessionUsageSchema.nullable()
+  usage: sessionUsageSchema.nullable(),
+  /** Public Gauge run page. Null while unpublished (e.g. a private
+   *  calibration org) — never a guessed org-scoped URL. */
+  gaugeUrl: z3.string().url().nullable().default(null)
+});
+var sessionProgressStatusSchema = z3.enum([
+  "queued",
+  "running",
+  "complete",
+  "failed",
+  "timed_out"
+]);
+var checkProgressStatusSchema = z3.enum([
+  "queued",
+  "scanning",
+  "fundamentals_ready",
+  "sessions_queued",
+  "sessions_running",
+  "complete",
+  "failed"
+]);
+var progressSchema = z3.object({
+  revision: z3.string().optional(),
+  status: checkProgressStatusSchema,
+  /** Checks ahead of this one in the sessions queue; null when unknown. */
+  queuePosition: z3.number().int().nonnegative().nullable(),
+  /** When the daily USD budget that is holding this check's sessions back
+   *  resets (the next 00:00 UTC). Null unless the check is waiting on it.
+   *  Optional: the contract landed before the budget was specified, so a
+   *  reader that predates it still parses. */
+  resumesAt: z3.string().datetime().nullable().optional(),
+  sessions: z3.array(
+    z3.object({ id: z3.string().min(1), status: sessionProgressStatusSchema })
+  )
 });
 var accessSchema = z3.object({
   status: checkStatusSchema,
@@ -140,7 +204,36 @@ var gradeSchema = z3.object({
   letter: z3.string().min(1),
   score: z3.number().int(),
   maxScore: z3.number().int().positive(),
-  status: z3.string()
+  status: z3.string(),
+  /** True until the calibration corpus backing the grade is annotated.
+   *  `publishableScore` stays null while this is true. */
+  provisional: z3.boolean().default(true)
+});
+var verdictSchema = z3.object({
+  headline: z3.string().min(1),
+  detail: z3.string().min(1)
+});
+var recentCheckSchema = z3.object({
+  domain: z3.string().min(1),
+  /** ISO date (YYYY-MM-DD) the report was completed. */
+  date: z3.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  grade: gradeSchema,
+  verdict: z3.object({ headline: z3.string().min(1) }),
+  logoUrl: z3.string().url().nullable().default(null),
+  /** See `reportSchema.logoTone`. */
+  logoTone: z3.enum(["light", "dark"]).nullable().default(null),
+  /** The product's name as the fast pass read it (see `reportSchema`). */
+  productName: z3.string().nullable().default(null),
+  completedAt: z3.string().datetime()
+});
+var recentChecksSchema = z3.array(recentCheckSchema);
+var applicabilitySchema = z3.enum([
+  "developer-product",
+  "not-applicable"
+]);
+var homepageNegotiationSchema = z3.object({
+  markdown: z3.boolean(),
+  contentType: z3.string()
 });
 var reportSchema = z3.object({
   domain: z3.string().min(1),
@@ -151,11 +244,32 @@ var reportSchema = z3.object({
   sessionSummary: z3.string(),
   access: accessSchema,
   grade: gradeSchema,
+  verdict: verdictSchema,
   checks: z3.array(fundamentalSchema).min(1),
   surfaces: z3.array(surfaceSchema),
   sessions: z3.array(sessionSchema),
   /** Surface kinds that were not assessed at all (not absent, not failing). */
-  unassessed: z3.array(z3.string())
+  unassessed: z3.array(z3.string()),
+  /** Live status while the check is still in flight. Absent once the caller
+   *  has no better source than the final report (e.g. recorded fixtures). */
+  progress: progressSchema.optional(),
+  /** `apple-touch-icon` / `icon`, else null. Never guessed. */
+  logoUrl: z3.string().url().nullable().default(null),
+  /** Whether `logoUrl`'s mark is light or dark, measured from its pixels by
+   *  the fast pass, so the card can pick a ground it shows up against. Null
+   *  when no icon was measured (none declared, an `.ico`, a fetch failure) —
+   *  "unknown", never a guess. */
+  logoTone: z3.enum(["light", "dark"]).nullable().default(null),
+  /** `og:site_name`, else the `<title>` before its first separator, else
+   *  null — the fast pass's reading, never guessed (the domain is the
+   *  reader's fallback, so "no name" and "the name is the domain" stay
+   *  distinguishable). The header shows it above the domain. */
+  productName: z3.string().nullable().default(null),
+  /** See `applicabilitySchema` above. */
+  applicability: applicabilitySchema.default("developer-product"),
+  /** Null when unmeasured (a report stored before this field existed, or the
+   *  fetch failed for our own reasons) — never a guess. */
+  homepageNegotiation: homepageNegotiationSchema.nullable().default(null)
 });
 var sessionEventSchema = z3.looseObject({
   type: z3.string(),
@@ -167,6 +281,15 @@ var transcriptSchema = z3.object({
   model: z3.string().min(1),
   events: z3.array(sessionEventSchema)
 });
+var liveTranscriptSchema = z3.object({
+  id: z3.string().min(1),
+  status: sessionProgressStatusSchema,
+  /** True once nothing further will ever arrive for this session (it has
+   *  settled, one way or another) — the signal to stop polling. */
+  complete: z3.boolean(),
+  events: z3.array(sessionEventSchema),
+  nextAfter: z3.number().int().nonnegative()
+});
 
 // ../packages/api-schemas/src/batteries.ts
 var batteries_exports = {};
@@ -851,6 +974,19 @@ var connectionSetSchema = z10.array(connectionSetEntrySchema).max(
   MAX_CONNECTION_SET_ENTRIES,
   `a run may attach at most ${MAX_CONNECTION_SET_ENTRIES} connections`
 );
+var connectionSummarySchema = z10.object({
+  id: z10.string(),
+  handle: z10.string(),
+  providerName: z10.string(),
+  credentialKey: z10.string(),
+  allowedHosts: z10.array(z10.string()),
+  profileSlug: z10.string(),
+  profileLabel: z10.string(),
+  kind: z10.enum(["static", "oauth"]),
+  last4: z10.string().nullable(),
+  createdAt: z10.string()
+}).strict();
+var listConnectionsResponseSchema = z10.object({ items: z10.array(connectionSummarySchema) }).strict();
 
 // ../packages/api-schemas/src/dashboards.ts
 import { z as z13 } from "zod";
@@ -955,6 +1091,8 @@ var whereClauseSchema = z12.object({
 });
 var queryFiltersSchema = z12.object({
   prompt: z12.string(),
+  visibilityPrompt: z12.array(z12.string()),
+  preferenceOnly: z12.boolean(),
   topic: z12.array(z12.string()),
   tag: z12.array(z12.string()),
   repo: z12.array(z12.string()),
@@ -1042,11 +1180,24 @@ var widgetEncodingSchema = z13.object({
   y: z13.array(z13.string())
   // metric keys for the value axis
 }).partial();
+var preferenceSpecSchema = z13.object({
+  dataset: z13.literal("preference"),
+  report: z13.enum([
+    "ranking",
+    "head_to_head",
+    "recommended_over_time",
+    "mentioned_over_time"
+  ])
+});
+var widgetSpecSchema = z13.union([
+  querySpecSchema,
+  preferenceSpecSchema
+]);
 var widgetFields = {
   id: z13.string().min(1),
   title: z13.string(),
   viz: vizTypeSchema,
-  spec: querySpecSchema,
+  spec: widgetSpecSchema,
   // 12-col grid placement.
   x: z13.number().int().min(0).max(11),
   y: z13.number().int().min(0),
@@ -2115,6 +2266,15 @@ var reingestSkillResponseSchema = z24.object({
   /** True = "already current": the source content matches the newest version. */
   unchanged: z24.boolean()
 });
+var addSkillVersionBodySchema = z24.object({
+  reference: z24.string().min(1),
+  /** Omitted defaults to the ref name (branch/tag), else the anchor. */
+  label: z24.string().min(1).max(120).optional()
+});
+var addSkillVersionResponseSchema = z24.object({
+  label: z24.string(),
+  unchanged: z24.boolean()
+});
 var skillRunWireSchema = z24.object({
   runId: z24.string(),
   agent: z24.string(),
@@ -2317,375 +2477,857 @@ var meResponseSchema = z26.object({
   orgs: z26.array(meOrgSchema)
 });
 
-// ../packages/api-schemas/src/orgs.ts
+// ../packages/api-schemas/src/optimizations.ts
+import { z as z29 } from "zod";
+
+// ../packages/api-schemas/src/climb.ts
+import { z as z28 } from "zod";
+
+// ../packages/api-schemas/src/climb-kinds.ts
+var LEVER_KINDS = [
+  "DOCS",
+  "MARKETING_SITE",
+  "SDK",
+  "CLI",
+  "SKILL"
+];
+var INTERVENTION_KINDS = [
+  "BASELINE",
+  "ADD_SKILL",
+  "REMOVE_SKILL",
+  "EDIT_SKILL",
+  "REWRITE_DOCS",
+  "PACKAGE_VERSION",
+  "PACKAGE_CONTENT",
+  "CLI_VERSION"
+];
+var LEVER_INTERVENTIONS = {
+  DOCS: ["REWRITE_DOCS"],
+  MARKETING_SITE: ["REWRITE_DOCS"],
+  SDK: ["PACKAGE_VERSION", "PACKAGE_CONTENT"],
+  CLI: ["CLI_VERSION"],
+  SKILL: ["ADD_SKILL", "REMOVE_SKILL", "EDIT_SKILL"]
+};
+
+// ../packages/api-schemas/src/sandbox-overrides.ts
 import { z as z27 } from "zod";
-var createOrgRequestSchema = z27.object({
+var SANDBOX_OVERRIDE_KINDS = ["packages", "clis"];
+var ecosystemSchema = z27.enum(["npm", "pypi", "cargo", "go", "gem"]);
+var overrideFilesSchema = z27.array(
+  z27.object({
+    path: z27.string().min(1).refine(
+      (path) => !path.startsWith("/") && !path.includes("\\") && !path.split("/").includes(".."),
+      "Use a relative path within the target"
+    ),
+    body: z27.string()
+  }).strict()
+).min(1);
+var contentShape = {
+  version: z27.string().trim().min(1).optional(),
+  files: overrideFilesSchema.optional()
+};
+var hasContent = (value) => value.version !== void 0 || value.files !== void 0;
+var sandboxOverridesSchema = z27.object({
+  version: z27.literal(1),
+  packages: z27.array(
+    z27.object({
+      ecosystem: ecosystemSchema,
+      name: z27.string().trim().min(1),
+      ...contentShape
+    }).strict().refine(hasContent, "Specify a version or files")
+  ).optional(),
+  clis: z27.array(
+    z27.object({
+      name: z27.string().trim().min(1),
+      ...contentShape
+    }).strict().refine(hasContent, "Specify a version or files")
+  ).optional()
+}).strict().superRefine((value, ctx) => {
+  const identities = {
+    packages: (value.packages ?? []).map(
+      (entry) => JSON.stringify([entry.ecosystem, entry.name])
+    ),
+    clis: (value.clis ?? []).map((entry) => entry.name)
+  };
+  for (const kind of SANDBOX_OVERRIDE_KINDS) {
+    if (new Set(identities[kind]).size !== identities[kind].length)
+      ctx.addIssue({
+        code: "custom",
+        path: [kind],
+        message: "Duplicate override identity"
+      });
+  }
+  if (new TextEncoder().encode(JSON.stringify(value)).byteLength >= 1e6)
+    ctx.addIssue({
+      code: "custom",
+      message: "Sandbox overrides must be under 1 MB"
+    });
+});
+
+// ../packages/api-schemas/src/climb.ts
+var climbSubjectKindSchema = z28.enum(["EVAL_SET", "VISIBILITY_PROMPT"]);
+var leverKindSchema = z28.enum(LEVER_KINDS);
+var interventionKindSchema = z28.enum(INTERVENTION_KINDS);
+var skill = z28.object({ skillVersionId: z28.string().min(1) }).strict();
+var empty = z28.object({}).strict();
+function validateFixtureIntervention(value, ctx) {
+  const result = webFixtureSchema.safeParse({ version: 1, ...value });
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      ctx.addIssue({
+        code: "custom",
+        path: issue.path,
+        message: issue.message
+      });
+    }
+  }
+}
+var interventionSchema = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("BASELINE"), after: empty }),
+  z28.object({ kind: z28.literal("ADD_SKILL"), after: skill }),
+  z28.object({ kind: z28.literal("REMOVE_SKILL"), before: skill, after: empty }),
+  z28.object({ kind: z28.literal("EDIT_SKILL"), before: skill, after: skill }),
+  z28.object({
+    kind: z28.literal("REWRITE_DOCS"),
+    before: z28.json().optional(),
+    after: z28.object({ pages: webFixtureSchema.shape.pages.unwrap().min(1) }).strict().superRefine(validateFixtureIntervention)
+  }),
+  z28.object({
+    kind: z28.literal("PACKAGE_VERSION"),
+    after: z28.object({
+      ecosystem: ecosystemSchema,
+      name: z28.string().min(1),
+      version: z28.string().min(1)
+    }).strict()
+  }),
+  z28.object({
+    kind: z28.literal("PACKAGE_CONTENT"),
+    after: z28.object({
+      ecosystem: ecosystemSchema,
+      name: z28.string().min(1),
+      files: overrideFilesSchema
+    }).strict()
+  }),
+  z28.object({
+    kind: z28.literal("CLI_VERSION"),
+    after: z28.object({ name: z28.string().min(1), version: z28.string().min(1) }).strict()
+  })
+]);
+var climbSettingsSchema = z28.object({
+  maxRounds: z28.number().int().positive().default(5),
+  sampleCount: z28.number().int().positive().default(1),
+  creditCap: z28.number().int().nonnegative(),
+  exploreModel: z28.string().min(1).optional(),
+  autoAdopt: z28.boolean().default(false),
+  targetScore: z28.number().min(0).max(1).default(1),
+  // Narrow the subject's whole roster to one slot, for the baseline and every
+  // trial alike. A subject rostering ten models otherwise multiplies every
+  // trial by ten, and a one-model trial measured against a ten-model baseline
+  // is not a comparison. `pinnedModel` empty means the agent's default model.
+  pinnedAgent: schedulableAgentSchema.optional(),
+  pinnedModel: z28.string().optional()
+}).strict().refine((value) => value.pinnedAgent !== void 0 || !value.pinnedModel, {
+  path: ["pinnedAgent"],
+  message: "Pin an agent with the model"
+});
+var climbConfigSnapshotSchema = z28.object({
+  promptText: z28.string(),
+  scenario: z28.enum(["GREENFIELD", "MIGRATION"]),
+  repoUrl: z28.string().nullable(),
+  repoRef: z28.string().nullable(),
+  profileId: z28.string().nullable(),
+  profileName: z28.string().nullable(),
+  profileDescription: z28.string().nullable(),
+  profileModel: z28.string().nullable(),
+  limits: z28.json(),
+  agents: z28.array(agentConfigSchema).min(1),
+  skillRefs: z28.array(z28.string()),
+  mcpRefs: z28.array(z28.string()),
+  skillVersionIds: z28.array(z28.string()),
+  mcpServerVersionIds: z28.array(z28.string()),
+  skillSet: z28.json().nullable(),
+  mcpSet: z28.json().nullable(),
+  connectionIds: z28.array(z28.string()),
+  connectionSet: z28.json().nullable(),
+  agentContext: z28.json().nullable(),
+  agentContextDigest: z28.string().nullable(),
+  webFixture: webFixtureSchema.nullable(),
+  sandboxOverrides: sandboxOverridesSchema.nullable(),
+  visibilityScenarioId: z28.string().nullable()
+}).strict();
+var targetRefSchema = z28.object({
+  kind: z28.string().min(1),
+  id: z28.string().optional(),
+  url: z28.url().optional(),
+  package: z28.string().optional()
+}).strict();
+var trialInputSchema = z28.object({
+  title: z28.string().trim().min(1).max(200),
+  hypothesis: z28.string().max(4e3).optional(),
+  lever: leverKindSchema,
+  targetRef: targetRefSchema.optional(),
+  intervention: interventionSchema,
+  authorMode: z28.enum(["MANUAL", "DIRECT", "PROPOSE"]).default("MANUAL")
+}).strict().superRefine((value, ctx) => {
+  const allowed = LEVER_INTERVENTIONS[value.lever];
+  if (!allowed.includes(value.intervention.kind))
+    ctx.addIssue({
+      code: "custom",
+      path: ["intervention", "kind"],
+      message: "This intervention does not change the selected lever"
+    });
+});
+
+// ../packages/api-schemas/src/optimizations.ts
+var OPTIMIZATION_STATUSES = [
+  "ACTIVE",
+  "PAUSED",
+  "DONE",
+  "ARCHIVED"
+];
+var optimizationStatusSchema = z29.enum(OPTIMIZATION_STATUSES);
+var ROUND_STATUSES = [
+  "PROPOSING",
+  "RUNNING",
+  "JUDGING",
+  "SETTLED",
+  "FAILED",
+  "CANCELED"
+];
+var TRIAL_STATUSES = [
+  "DRAFT",
+  "RUNNING",
+  "SETTLED",
+  "FAILED",
+  "CANCELED"
+];
+var TRIAL_VERDICTS = [
+  "BETTER",
+  "WORSE",
+  "INCONCLUSIVE",
+  "NOT_EVALUABLE"
+];
+var OPTIMIZATION_EFFORTS = [
+  { value: "LOW", label: "Quick", sampleCount: 1, maxRounds: 3 },
+  { value: "MEDIUM", label: "Standard", sampleCount: 1, maxRounds: 5 },
+  { value: "HIGH", label: "Thorough", sampleCount: 2, maxRounds: 8 },
+  { value: "XHIGH", label: "Exhaustive", sampleCount: 3, maxRounds: 12 }
+];
+var optimizationEffortSchema = z29.enum(
+  OPTIMIZATION_EFFORTS.map((preset) => preset.value)
+);
+var listOptimizationsQuerySchema = z29.object({
+  status: z29.string().optional().transform(
+    (value) => value ? value.split(",").map((part) => part.trim().toUpperCase()).filter(Boolean) : void 0
+  ).pipe(z29.array(optimizationStatusSchema).optional()),
+  subjectKind: climbSubjectKindSchema.optional(),
+  subjectId: z29.string().min(1).optional(),
+  limit: z29.coerce.number().int().min(1).max(200).default(50)
+});
+var optimizationSummarySchema = z29.object({
+  id: z29.string(),
+  name: z29.string(),
+  status: optimizationStatusSchema,
+  mode: z29.enum(["MANUAL", "AUTO"]),
+  stopReason: z29.string().nullable(),
+  subjectKind: climbSubjectKindSchema,
+  subjectId: z29.string(),
+  subjectName: z29.string(),
+  lever: leverKindSchema.nullable(),
+  round: z29.number().int(),
+  maxRounds: z29.number().int(),
+  /** Starting baseline score, 0..1. */
+  before: z29.number().nullable(),
+  /** Score of the adopted tip, 0..1. */
+  after: z29.number().nullable(),
+  /** Percentage-point change from the starting baseline to the adopted tip. */
+  delta: z29.number().nullable(),
+  /** Score after each round, baseline first. */
+  path: z29.array(z29.number()),
+  creditsSpent: z29.number().int(),
+  creditsReserved: z29.number().int(),
+  summary: z29.string().nullable(),
+  href: z29.string(),
+  createdAt: z29.string(),
+  updatedAt: z29.string()
+});
+var listOptimizationsResponseSchema = z29.object({
+  items: z29.array(optimizationSummarySchema)
+});
+var targetSchema = z29.object({
+  agent: schedulableAgentSchema.optional(),
+  /** Empty or omitted means the agent's default model. */
+  model: z29.string().optional()
+});
+var planShape = {
+  effort: optimizationEffortSchema.optional(),
+  sampleCount: z29.number().int().min(1).max(100).optional(),
+  maxRounds: z29.number().int().min(1).max(100).optional()
+};
+function refinePlan(value, ctx) {
+  if (value.effort && (value.sampleCount || value.maxRounds))
+    ctx.addIssue({
+      code: "custom",
+      path: ["effort"],
+      message: "Pass effort or sampleCount/maxRounds, not both"
+    });
+  if (value.target?.model && !value.target.agent)
+    ctx.addIssue({
+      code: "custom",
+      path: ["target", "agent"],
+      message: "Pin an agent with the model"
+    });
+}
+var startOptimizationBodySchema = z29.object({
+  subjectKind: climbSubjectKindSchema,
+  subjectId: z29.string().min(1),
+  name: z29.string().trim().min(1).max(200).optional(),
+  ...planShape,
+  creditCap: z29.number().int().nonnegative().optional(),
+  autoAdopt: z29.boolean().default(true),
+  targetScore: z29.number().min(0).max(1).optional(),
+  target: targetSchema.extend({ agent: schedulableAgentSchema })
+}).strict().superRefine(refinePlan);
+var estimateOptimizationBodySchema = z29.object({
+  subjectKind: climbSubjectKindSchema,
+  subjectId: z29.string().min(1),
+  ...planShape,
+  target: targetSchema.optional()
+}).strict().superRefine(refinePlan);
+var RUN_CREDIT_BASES = [
+  "subject-history",
+  "model-history",
+  "catalog-rates",
+  "platform-history",
+  "byok",
+  "reserve"
+];
+var runCreditBasisSchema = z29.enum(RUN_CREDIT_BASES);
+var optimizationEstimateSchema = z29.object({
+  sampleCount: z29.number().int(),
+  maxRounds: z29.number().int(),
+  runsPerTrial: z29.number(),
+  executionCredits: z29.number(),
+  judgeCredits: z29.number(),
+  leverPassCredits: z29.number(),
+  trialCredits: z29.number(),
+  /** Whole credits for the full climb; this is what start reserves. */
+  estimate: z29.number().int(),
+  /** True when no price or history covered a model: a bound, not a forecast. */
+  approximate: z29.boolean().default(false),
+  /** Which rung priced the run, so the UI can say why a figure is what it is. */
+  basis: runCreditBasisSchema.optional()
+});
+var diagnoseBodySchema = z29.object({
+  subjectKind: climbSubjectKindSchema,
+  subjectId: z29.string().min(1)
+}).strict();
+var diagnosisSchema = z29.object({
+  id: z29.string(),
+  status: z29.enum(["GENERATING", "READY", "FAILED"]),
+  subjectKind: climbSubjectKindSchema,
+  subjectId: z29.string(),
+  runCount: z29.number().int(),
+  summary: z29.string().nullable(),
+  recommendedLever: leverKindSchema.nullable(),
+  recommendedTarget: z29.unknown().nullable(),
+  clusters: z29.array(
+    z29.object({
+      title: z29.string(),
+      failureMode: z29.string(),
+      criterionIds: z29.array(z29.string()),
+      runIds: z29.array(z29.string()),
+      lever: leverKindSchema.nullable(),
+      targetRef: z29.unknown().nullable(),
+      confidence: z29.number()
+    })
+  ),
+  createdAt: z29.string()
+});
+var trialRunSchema = z29.object({
+  id: z29.string(),
+  status: z29.string(),
+  passed: z29.boolean().nullable(),
+  criteria: z29.array(
+    z29.object({ name: z29.string(), passed: z29.boolean(), reasoning: z29.string() })
+  ),
+  levers: z29.array(
+    z29.object({
+      lever: z29.string(),
+      attributed: z29.boolean(),
+      note: z29.string().nullable()
+    })
+  )
+});
+var trialSchema = z29.object({
+  id: z29.string(),
+  climbId: z29.string(),
+  roundNumber: z29.number().int(),
+  key: z29.string(),
+  parentTrialId: z29.string().nullable(),
+  parentKey: z29.string().nullable(),
+  title: z29.string(),
+  hypothesis: z29.string().nullable(),
+  lever: leverKindSchema.nullable(),
+  kind: interventionKindSchema,
+  status: z29.enum(TRIAL_STATUSES),
+  verdict: z29.enum(TRIAL_VERDICTS).nullable(),
+  score: z29.number().nullable(),
+  baselineScore: z29.number().nullable(),
+  /** Judged sessions behind `score`. */
+  sessions: z29.number().int(),
+  explore: z29.boolean(),
+  isBaseline: z29.boolean(),
+  adopted: z29.boolean(),
+  adoptedAt: z29.string().nullable(),
+  outcome: z29.string().nullable(),
+  /** The kind-specific `after` payload (skill version id, pages, package). */
+  after: z29.unknown(),
+  before: z29.unknown(),
+  runs: z29.array(trialRunSchema),
+  createdAt: z29.string()
+});
+var roundSchema = z29.object({
+  id: z29.string(),
+  number: z29.number().int(),
+  status: z29.enum(ROUND_STATUSES),
+  narrative: z29.string().nullable(),
+  trials: z29.array(trialSchema)
+});
+var optimizationDetailSchema = optimizationSummarySchema.extend({
+  baselineTrialId: z29.string().nullable(),
+  settings: z29.object({
+    sampleCount: z29.number().int(),
+    maxRounds: z29.number().int(),
+    creditCap: z29.number().int(),
+    autoAdopt: z29.boolean(),
+    targetScore: z29.number(),
+    exploreModel: z29.string().nullable(),
+    pinnedAgent: z29.string().nullable(),
+    pinnedModel: z29.string().nullable()
+  }),
+  diagnosis: diagnosisSchema.nullable(),
+  rounds: z29.array(roundSchema)
+});
+var listTrialsResponseSchema = z29.object({
+  items: z29.array(trialSchema)
+});
+var trialDocumentSchema = z29.object({
+  path: z29.string(),
+  before: z29.string(),
+  after: z29.string()
+});
+var trialContentSchema = z29.object({
+  trialId: z29.string(),
+  kind: interventionKindSchema,
+  documents: z29.array(trialDocumentSchema),
+  /** Full page bodies for a docs rewrite, ready to paste; null otherwise. */
+  copyableBody: z29.string().nullable(),
+  configSnapshot: z29.unknown()
+});
+var createTrialBodySchema = z29.object({
+  trial: trialInputSchema,
+  files: overrideFilesSchema.optional(),
+  fork: z29.object({ runId: z29.string().min(1), boundarySeq: z29.string().min(1) }).strict().optional(),
+  launch: z29.boolean().default(true)
+}).strict();
+var proposeBodySchema = z29.object({
+  request: z29.string().trim().max(4e3).optional(),
+  lever: leverKindSchema.optional(),
+  kind: interventionKindSchema.optional(),
+  targetVersionId: z29.string().min(1).optional()
+}).strict();
+var proposalSchema = z29.object({
+  trial: trialInputSchema,
+  files: overrideFilesSchema.optional()
+});
+var proposeResponseSchema = z29.object({
+  items: z29.array(proposalSchema)
+});
+var skillFilesResponseSchema = z29.object({
+  versionId: z29.string(),
+  files: overrideFilesSchema
+});
+var pageBodyResponseSchema = z29.object({
+  url: z29.string(),
+  body: z29.string(),
+  contentType: z29.string().optional()
+});
+var launchTrialResponseSchema = z29.object({
+  trialId: z29.string(),
+  batchIds: z29.array(z29.string()),
+  runIds: z29.array(z29.string())
+});
+
+// ../packages/api-schemas/src/orgs.ts
+import { z as z30 } from "zod";
+var createOrgRequestSchema = z30.object({
   /** Workspace display name; the slug is derived server-side. */
-  name: z27.string().trim().min(1).max(200),
+  name: z30.string().trim().min(1).max(200),
   /** Optional company site (logo source; stamped onto the org). */
-  website: z27.string().trim().max(300).optional()
+  website: z30.string().trim().max(300).optional()
 });
-var createOrgResponseSchema = z27.object({
-  slug: z27.string(),
-  name: z27.string(),
+var createOrgResponseSchema = z30.object({
+  slug: z30.string(),
+  name: z30.string(),
   // LOCAL orgs never have a Gauge publicId.
-  publicId: z27.string().nullable()
+  publicId: z30.string().nullable()
 });
-var orgSettingsSchema = z27.object({
-  slug: z27.string(),
-  name: z27.string(),
-  publicId: z27.string().nullable(),
-  website: z27.string().nullable(),
+var orgSettingsSchema = z30.object({
+  slug: z30.string(),
+  name: z30.string(),
+  publicId: z30.string().nullable(),
+  website: z30.string().nullable(),
   /** Per-run max-spend override in USD; null = the server default. */
-  maxSpendUsd: z27.number().nullable(),
-  overageEnabled: z27.boolean(),
+  maxSpendUsd: z30.number().nullable(),
+  overageEnabled: z30.boolean(),
   /** Per-cycle overage cap in credits; null = uncapped. */
-  overageCapCredits: z27.number().int().nullable(),
+  overageCapCredits: z30.number().int().nullable(),
   /** Domain claimed for same-domain auto-join; null = off. */
-  autoJoinDomain: z27.string().nullable()
+  autoJoinDomain: z30.string().nullable()
 });
-var orgMemberSchema = z27.object({
-  userId: z27.string(),
-  name: z27.string().nullable(),
-  email: z27.string().nullable(),
-  joinedAt: z27.string()
+var orgMemberSchema = z30.object({
+  userId: z30.string(),
+  name: z30.string().nullable(),
+  email: z30.string().nullable(),
+  joinedAt: z30.string()
 });
-var listMembersResponseSchema = z27.object({
-  items: z27.array(orgMemberSchema)
+var listMembersResponseSchema = z30.object({
+  items: z30.array(orgMemberSchema)
 });
 
 // ../packages/api-schemas/src/personas.ts
-import { z as z28 } from "zod";
-var personaSchema = z28.object({
-  id: z28.string(),
-  name: z28.string(),
-  description: z28.string(),
+import { z as z31 } from "zod";
+var personaSchema = z31.object({
+  id: z31.string(),
+  name: z31.string(),
+  description: z31.string(),
   /** The judge model this persona calls (Claude only). */
-  model: z28.string(),
-  createdAt: z28.string(),
-  updatedAt: z28.string()
+  model: z31.string(),
+  createdAt: z31.string(),
+  updatedAt: z31.string()
 });
-var listPersonasResponseSchema = z28.object({
-  items: z28.array(personaSchema)
+var listPersonasResponseSchema = z31.object({
+  items: z31.array(personaSchema)
 });
-var createPersonaBodySchema = z28.object({
-  name: z28.string().min(1).max(120),
-  description: z28.string().min(1)
+var createPersonaBodySchema = z31.object({
+  name: z31.string().min(1).max(120),
+  description: z31.string().min(1)
 });
-var updatePersonaBodySchema = z28.object({
-  name: z28.string().min(1).max(120).optional(),
-  description: z28.string().min(1).optional()
+var updatePersonaBodySchema = z31.object({
+  name: z31.string().min(1).max(120).optional(),
+  description: z31.string().min(1).optional()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z31 } from "zod";
+import { z as z34 } from "zod";
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z29 } from "zod";
-var tagSchema = z29.object({
-  id: z29.string(),
-  name: z29.string(),
+import { z as z32 } from "zod";
+var tagSchema = z32.object({
+  id: z32.string(),
+  name: z32.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z29.string()
+  color: z32.string()
 });
-var createTagBodySchema = z29.object({
-  name: z29.string().min(1),
-  color: z29.string().optional()
+var createTagBodySchema = z32.object({
+  name: z32.string().min(1),
+  color: z32.string().optional()
 });
-var updateTagBodySchema = z29.object({
-  name: z29.string().min(1).optional(),
-  color: z29.string().optional()
+var updateTagBodySchema = z32.object({
+  name: z32.string().min(1).optional(),
+  color: z32.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z30 } from "zod";
-var topicSchema = z30.object({
-  id: z30.string(),
-  name: z30.string()
+import { z as z33 } from "zod";
+var topicSchema = z33.object({
+  id: z33.string(),
+  name: z33.string()
 });
-var createTopicBodySchema = z30.object({
-  name: z30.string().min(1, "name is required")
+var createTopicBodySchema = z33.object({
+  name: z33.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
 // ../packages/api-schemas/src/prompts.ts
-var promptSummarySchema = z31.object({
-  id: z31.string(),
-  text: z31.string(),
-  isBranded: z31.boolean(),
+var promptSummarySchema = z34.object({
+  id: z34.string(),
+  text: z34.string(),
+  isBranded: z34.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z31.string().nullable(),
+  externalKey: z34.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z31.array(tagSchema),
-  createdAt: z31.string()
+  tags: z34.array(tagSchema),
+  createdAt: z34.string()
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z31.string().min(1).optional(),
-  tag: z31.string().min(1).optional(),
-  q: z31.string().min(1).optional()
-});
-var createPromptBodySchema = z31.object({
-  text: z31.string().min(1, "text is required"),
-  isBranded: z31.boolean().default(false),
-  topic: z31.string().min(1).optional(),
-  tags: z31.array(z31.string().min(1)).default([])
-});
-var updatePromptBodySchema = z31.object({
-  text: z31.string().min(1).optional(),
-  isBranded: z31.boolean().optional(),
-  topicId: z31.string().min(1).nullish(),
-  tags: z31.array(z31.string().min(1)).optional()
-});
-var runPromptBodySchema = z31.object({
+  topic: z34.string().min(1).optional(),
+  tag: z34.string().min(1).optional(),
+  q: z34.string().min(1).optional()
+});
+var createPromptBodySchema = z34.object({
+  text: z34.string().min(1, "text is required"),
+  isBranded: z34.boolean().default(false),
+  topic: z34.string().min(1).optional(),
+  tags: z34.array(z34.string().min(1)).default([])
+});
+var updatePromptBodySchema = z34.object({
+  text: z34.string().min(1).optional(),
+  isBranded: z34.boolean().optional(),
+  topicId: z34.string().min(1).nullish(),
+  tags: z34.array(z34.string().min(1)).optional()
+});
+var runPromptBodySchema = z34.object({
   /** Preferred paired representation; each agent may pin its own model tiers. */
-  agentConfigs: z31.array(agentConfigInputSchema).min(1).optional(),
+  agentConfigs: z34.array(agentConfigInputSchema).min(1).optional(),
   /** Legacy agent set (no per-agent pins), kept during the API transition. */
-  agents: z31.array(z31.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
-  repoUrl: z31.string().min(1).nullish(),
-  repoRef: z31.string().min(1).nullish(),
-  samplesPerCycle: z31.number().int().min(1).max(10).default(1),
+  agents: z34.array(z34.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z34.string().min(1).nullish(),
+  repoRef: z34.string().min(1).nullish(),
+  samplesPerCycle: z34.number().int().min(1).max(10).default(1),
   webFixture: webFixtureSchema.optional()
 });
-var runPromptResponseSchema = z31.object({
-  batchIds: z31.array(z31.string()),
-  runIds: z31.array(z31.string()),
-  blocked: z31.enum(["insufficient_credits", "needs_provider_key"]).optional()
+var runPromptResponseSchema = z34.object({
+  batchIds: z34.array(z34.string()),
+  runIds: z34.array(z34.string()),
+  blocked: z34.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z32 } from "zod";
+import { z as z35 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z32.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z32.object({
-  url: z32.string(),
-  name: z32.string(),
-  isSystem: z32.boolean(),
-  languages: z32.array(z32.string()),
-  frameworks: z32.array(z32.string()),
+var repoSizeBucketSchema = z35.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z35.object({
+  url: z35.string(),
+  name: z35.string(),
+  isSystem: z35.boolean(),
+  languages: z35.array(z35.string()),
+  frameworks: z35.array(z35.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z32.array(z32.string()),
-  primaryLanguage: z32.string(),
-  sizeKb: z32.number(),
+  tags: z35.array(z35.string()),
+  primaryLanguage: z35.string(),
+  sizeKb: z35.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z32.number()
+  stars: z35.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z32.object({
-  url: z32.string().min(1, "url is required"),
+var addRepoBodySchema = z35.object({
+  url: z35.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: z32.string().min(1).optional(),
+  ref: z35.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z32.string().min(1).optional(),
+  name: z35.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z32.array(z32.string()).optional(),
-  tags: z32.array(z32.string()).optional()
+  frameworks: z35.array(z35.string()).optional(),
+  tags: z35.array(z35.string()).optional()
 });
-var updateRepoBodySchema = z32.object({
-  url: z32.string().min(1, "url is required"),
-  name: z32.string().min(1).optional(),
-  frameworks: z32.array(z32.string()).optional(),
-  tags: z32.array(z32.string()).optional()
+var updateRepoBodySchema = z35.object({
+  url: z35.string().min(1, "url is required"),
+  name: z35.string().min(1).optional(),
+  frameworks: z35.array(z35.string()).optional(),
+  tags: z35.array(z35.string()).optional()
 });
-var resyncRepoBodySchema = z32.object({
-  url: z32.string().min(1, "url is required")
+var resyncRepoBodySchema = z35.object({
+  url: z35.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z32.object({
-  url: z32.string().min(1, "url is required")
+var deleteRepoQuerySchema = z35.object({
+  url: z35.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z32.object({
+var repoSyncResultSchema = z35.object({
   repo: repoSchema,
-  synced: z32.boolean()
+  synced: z35.boolean()
 });
 
 // ../packages/api-schemas/src/summary.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 function cardResultSchema(data) {
-  return z33.union([
-    z33.object({ ok: z33.literal(true), data }),
-    z33.object({ ok: z33.literal(false), error: z33.string() })
+  return z36.union([
+    z36.object({ ok: z36.literal(true), data }),
+    z36.object({ ok: z36.literal(false), error: z36.string() })
   ]);
 }
-var summaryActionSchema = z33.object({
-  id: z33.string(),
-  title: z33.string(),
-  priority: z33.string(),
-  status: z33.string(),
-  evidenceCount: z33.number().int()
-});
-var summaryAeCardSchema = z33.object({
-  id: z33.string(),
-  name: z33.string(),
-  judgedRuns: z33.number().int(),
-  passRate: z33.number().nullable(),
+var summaryActionSchema = z36.object({
+  id: z36.string(),
+  title: z36.string(),
+  priority: z36.string(),
+  status: z36.string(),
+  evidenceCount: z36.number().int()
+});
+var summaryAeCardSchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  judgedRuns: z36.number().int(),
+  passRate: z36.number().nullable(),
   /** pp delta vs the prior 30d; null with no prior. */
-  deltaPP: z33.number().nullable()
-});
-var summaryVisibilityCardSchema = z33.object({
-  name: z33.string(),
-  owned: z33.object({
-    name: z33.string(),
-    rank: z33.number(),
-    chosenRate: z33.number(),
-    mentionRate: z33.number()
+  deltaPP: z36.number().nullable()
+});
+var summaryVisibilityCardSchema = z36.object({
+  name: z36.string(),
+  owned: z36.object({
+    name: z36.string(),
+    rank: z36.number(),
+    chosenRate: z36.number(),
+    mentionRate: z36.number()
   }).nullable(),
-  chosenDeltaPP: z33.number().nullable()
+  chosenDeltaPP: z36.number().nullable()
 });
-var homeSummarySchema = z33.object({
-  hasAnyRuns: z33.boolean(),
-  lastSynthesisAt: z33.string().nullable(),
-  actions: cardResultSchema(z33.array(summaryActionSchema)),
+var homeSummarySchema = z36.object({
+  hasAnyRuns: z36.boolean(),
+  lastSynthesisAt: z36.string().nullable(),
+  actions: cardResultSchema(z36.array(summaryActionSchema)),
   visibility: cardResultSchema(
-    z33.object({
-      cards: z33.array(summaryVisibilityCardSchema),
-      marketsTotal: z33.number().int(),
-      promptCount: z33.number().int()
+    z36.object({
+      cards: z36.array(summaryVisibilityCardSchema),
+      marketsTotal: z36.number().int(),
+      promptCount: z36.number().int()
     })
   ),
   agentExperience: cardResultSchema(
-    z33.object({
-      cards: z33.array(summaryAeCardSchema),
-      total: z33.number().int(),
-      setCount: z33.number().int()
+    z36.object({
+      cards: z36.array(summaryAeCardSchema),
+      total: z36.number().int(),
+      setCount: z36.number().int()
     })
   ),
-  notableSessions: cardResultSchema(z33.array(z33.unknown()))
+  notableSessions: cardResultSchema(z36.array(z36.unknown()))
 });
 
 // ../packages/api-schemas/src/tokens.ts
-import { z as z34 } from "zod";
-var apiTokenSchema = z34.object({
-  id: z34.string(),
-  name: z34.string(),
+import { z as z37 } from "zod";
+var apiTokenSchema = z37.object({
+  id: z37.string(),
+  name: z37.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z34.string(),
-  expiresAt: z34.iso.datetime().nullable(),
-  lastUsedAt: z34.iso.datetime().nullable(),
-  createdAt: z34.iso.datetime(),
-  revokedAt: z34.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z34.object({
-  name: z34.string().min(1).max(100),
+  last4: z37.string(),
+  expiresAt: z37.iso.datetime().nullable(),
+  lastUsedAt: z37.iso.datetime().nullable(),
+  createdAt: z37.iso.datetime(),
+  revokedAt: z37.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z37.object({
+  name: z37.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z34.iso.datetime({ offset: true }).optional()
+  expiresAt: z37.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z34.string()
+  token: z37.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
 // ../packages/api-schemas/src/visibility.ts
-import { z as z35 } from "zod";
+import { z as z38 } from "zod";
 var VISIBILITY_PROMPT_KINDS = ["HEAD_TO_HEAD", "RECOMMEND"];
-var visibilityPromptKindSchema = z35.enum(VISIBILITY_PROMPT_KINDS);
+var visibilityPromptKindSchema = z38.enum(VISIBILITY_PROMPT_KINDS);
 var visibilityPromptSchema = visibilityPromptSettingsSchema.extend({
-  id: z35.string(),
-  name: z35.string(),
+  id: z38.string(),
+  name: z38.string(),
   kind: visibilityPromptKindSchema,
-  promptText: z35.string(),
+  promptText: z38.string(),
   /** HEAD_TO_HEAD is always branded; RECOMMEND may be either. */
-  branded: z35.boolean(),
-  brandA: z35.string().nullable(),
-  brandB: z35.string().nullable(),
-  market: z35.object({ id: z35.string(), slug: z35.string(), name: z35.string() }).nullable(),
-  position: z35.number().int(),
-  createdAt: z35.string(),
+  branded: z38.boolean(),
+  brandA: z38.string().nullable(),
+  brandB: z38.string().nullable(),
+  market: z38.object({ id: z38.string(), slug: z38.string(), name: z38.string() }).nullable(),
+  position: z38.number().int(),
+  createdAt: z38.string(),
   /** User tag names on the hidden backing prompt (Surface:* excluded). */
-  tags: z35.array(z35.string()),
-  runCount: z35.number().int(),
-  lastRunAt: z35.string().nullable(),
-  scenarios: z35.array(visibilityScenarioSchema)
+  tags: z38.array(z38.string()),
+  runCount: z38.number().int(),
+  lastRunAt: z38.string().nullable(),
+  scenarios: z38.array(visibilityScenarioSchema)
 });
-var listVisibilityPromptsResponseSchema = z35.object({
-  items: z35.array(visibilityPromptSchema)
+var listVisibilityPromptsResponseSchema = z38.object({
+  items: z38.array(visibilityPromptSchema)
 });
-var createVisibilityPromptBodySchema = z35.object({
-  name: z35.string().min(1),
-  promptText: z35.string().min(1),
+var createVisibilityPromptBodySchema = z38.object({
+  name: z38.string().min(1),
+  promptText: z38.string().min(1),
   kind: visibilityPromptKindSchema,
-  branded: z35.boolean().optional(),
+  branded: z38.boolean().optional(),
   /** Required pair for HEAD_TO_HEAD (order-independent). */
-  brandA: z35.string().nullish(),
-  brandB: z35.string().nullish(),
+  brandA: z38.string().nullish(),
+  brandB: z38.string().nullish(),
   /** Measured market id from the org's tracked set. */
-  marketId: z35.string().nullish(),
-  tags: z35.array(z35.string()).optional(),
+  marketId: z38.string().nullish(),
+  tags: z38.array(z38.string()).optional(),
   agents: visibilityPromptSettingsInputShape.agents.optional(),
   skillRefs: visibilityPromptSettingsInputShape.skillRefs,
   mcpRefs: visibilityPromptSettingsInputShape.mcpRefs,
   connectionIds: visibilityPromptSettingsInputShape.connectionIds,
   cadence: visibilityPromptSettingsInputShape.cadence,
   sampleCount: visibilityPromptSettingsInputShape.sampleCount,
-  scenarios: z35.array(visibilityScenarioInputSchema).optional().default([])
+  scenarios: z38.array(visibilityScenarioInputSchema).optional().default([])
 }).strict();
-var synthesizeResponseSchema = z35.object({
+var synthesizeResponseSchema = z38.object({
   /** False when the pre-check found no new evidence and nothing was queued. */
-  queued: z35.boolean()
-});
-var updateVisibilityPromptBodySchema = z35.object({
-  name: z35.string().min(1).optional(),
-  promptText: z35.string().min(1).optional(),
-  branded: z35.boolean().optional(),
-  brandA: z35.string().nullish(),
-  brandB: z35.string().nullish(),
-  marketId: z35.string().nullish(),
-  tags: z35.array(z35.string()).optional(),
+  queued: z38.boolean()
+});
+var updateVisibilityPromptBodySchema = z38.object({
+  name: z38.string().min(1).optional(),
+  promptText: z38.string().min(1).optional(),
+  branded: z38.boolean().optional(),
+  brandA: z38.string().nullish(),
+  brandB: z38.string().nullish(),
+  marketId: z38.string().nullish(),
+  tags: z38.array(z38.string()).optional(),
   ...visibilityPromptSettingsPatchShape,
   /** Replaces the whole scenario set when present. */
-  scenarios: z35.array(visibilityScenarioInputSchema).optional()
+  scenarios: z38.array(visibilityScenarioInputSchema).optional()
 }).strict();
-var runVisibilityPromptResponseSchema = z35.object({
-  batchIds: z35.array(z35.string()),
-  runIds: z35.array(z35.string())
+var runVisibilityPromptResponseSchema = z38.object({
+  batchIds: z38.array(z38.string()),
+  runIds: z38.array(z38.string())
 });
-var visibilityPromptRunSchema = z35.object({
-  id: z35.string(),
-  status: z35.string(),
+var visibilityPromptRunSchema = z38.object({
+  id: z38.string(),
+  status: z38.string(),
   agent: agentSchema,
-  model: z35.string().nullable(),
-  resolvedModel: z35.string().nullable(),
-  createdAt: z35.string(),
-  startedAt: z35.string().nullable(),
-  finishedAt: z35.string().nullable(),
-  failureReason: z35.string().nullable(),
-  verdict: z35.object({
-    status: z35.string(),
-    error: z35.string().nullable(),
-    payload: z35.unknown().nullable()
+  model: z38.string().nullable(),
+  resolvedModel: z38.string().nullable(),
+  createdAt: z38.string(),
+  startedAt: z38.string().nullable(),
+  finishedAt: z38.string().nullable(),
+  failureReason: z38.string().nullable(),
+  verdict: z38.object({
+    status: z38.string(),
+    error: z38.string().nullable(),
+    payload: z38.unknown().nullable()
   }).nullable()
 });
-var listVisibilityPromptRunsResponseSchema = z35.object({
-  items: z35.array(visibilityPromptRunSchema)
+var listVisibilityPromptRunsResponseSchema = z38.object({
+  items: z38.array(visibilityPromptRunSchema)
 });
-var orgMarketSchema = z35.object({
-  marketId: z35.string(),
-  slug: z35.string(),
-  name: z35.string(),
+var orgMarketSchema = z38.object({
+  marketId: z38.string(),
+  slug: z38.string(),
+  name: z38.string(),
   /** The one line saying what the market measures. */
-  capability: z35.string(),
+  capability: z38.string(),
   /** SUGGESTED (the matcher) | USER (a human picked it). */
-  source: z35.string()
+  source: z38.string()
 });
 var addableMarketSchema = orgMarketSchema.omit({ source: true });
-var listMarketsResponseSchema = z35.object({
-  tracked: z35.array(orgMarketSchema),
+var listMarketsResponseSchema = z38.object({
+  tracked: z38.array(orgMarketSchema),
   /** Published markets the org does not track yet (closed set — no free-text
    *  market creation). */
-  addable: z35.array(addableMarketSchema)
+  addable: z38.array(addableMarketSchema)
 });
-var addMarketBodySchema = z35.object({ marketId: z35.string().min(1) });
+var addMarketBodySchema = z38.object({ marketId: z38.string().min(1) });
 
 // src/version.ts
 import { createRequire } from "module";
@@ -3069,7 +3711,7 @@ __export(apply_exports, {
   register: () => register2
 });
 import { readFileSync as readFileSync3 } from "fs";
-import { z as z36 } from "zod";
+import { z as z39 } from "zod";
 function assertRequiredExperiment(spec, required) {
   if (required.length === 0) {
     throw new CliError(
@@ -3221,7 +3863,7 @@ function register2(program2) {
   ).option("--schema", "print the battery spec JSON Schema and exit").option("--example", "print a minimal example battery spec and exit").action(
     async (opts, command) => {
       if (opts.schema) {
-        printJson(z36.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z39.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -4131,16 +4773,50 @@ function register7(program2) {
   });
 }
 
+// src/commands/connections.ts
+var connections_exports2 = {};
+__export(connections_exports2, {
+  register: () => register8
+});
+function connectionsPath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/connections`;
+}
+function register8(program2) {
+  const group = program2.command("connections").alias("credentials").description("Inspect the org's stored credentials (no secrets)");
+  group.command("list").description("List credentials with the ids --connection accepts").action(async (_opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      connectionsPath(org)
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(res.items);
+      return;
+    }
+    printItems(
+      res.items.map((c) => ({
+        id: c.id,
+        name: c.handle,
+        vendor: c.profileLabel,
+        placeholder: c.credentialKey,
+        domains: c.allowedHosts.join(", "),
+        kind: c.kind,
+        value: c.last4 ? `\xB7\xB7\xB7\xB7${c.last4}` : ""
+      })),
+      "table"
+    );
+  });
+}
+
 // src/commands/dashboards.ts
 var dashboards_exports2 = {};
 __export(dashboards_exports2, {
-  register: () => register8
+  register: () => register9
 });
 import { readFileSync as readFileSync5 } from "fs";
 function dashboardsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/dashboards`;
 }
-function register8(program2) {
+function register9(program2) {
   const group = program2.command("dashboards").description("Saved dashboards (CRUD + view filters; layout is UI-only)");
   group.command("list").description("List your dashboard library").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -4242,7 +4918,7 @@ var evals_exports2 = {};
 __export(evals_exports2, {
   evalSetsPath: () => evalSetsPath,
   parseCriterion: () => parseCriterion,
-  register: () => register9
+  register: () => register10
 });
 import { readFileSync as readFileSync6 } from "fs";
 
@@ -4531,7 +5207,7 @@ function printDetail(e) {
   console.log("criteria:");
   for (const c of e.criteria) console.log(`  [${c.id}] ${c.name}: ${c.rubric}`);
 }
-function register9(program2) {
+function register10(program2) {
   const group = program2.command("evals").description("Manage eval sets (judged agent-experience measurements)");
   group.command("list").description("List the org's eval sets with pass-rate stats").option(
     "--agents <agents>",
@@ -4721,7 +5397,7 @@ function register9(program2) {
 // src/commands/experiments.ts
 var experiments_exports2 = {};
 __export(experiments_exports2, {
-  register: () => register10,
+  register: () => register11,
   rewriteContentType: () => rewriteContentType
 });
 import { readFileSync as readFileSync7 } from "fs";
@@ -4784,8 +5460,10 @@ function printDetail2(e) {
     }
   }
 }
-function register10(program2) {
-  const group = program2.command("experiments").description("Author, launch, and read Fixer content experiments");
+function register11(program2) {
+  const group = program2.command("experiments").description(
+    "Author, launch, and read Fixer content experiments (legacy: orgs with Optimizations answer 409 on writes; use `gauge optimizations`)"
+  );
   group.command("list").description("List the org's experiments").option(
     "--status <statuses>",
     "comma-separated statuses (e.g. RUNNING,COMPLETE)"
@@ -5131,7 +5809,7 @@ function register10(program2) {
 // src/commands/keys.ts
 var keys_exports2 = {};
 __export(keys_exports2, {
-  register: () => register11
+  register: () => register12
 });
 function keysPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/provider-keys`;
@@ -5174,7 +5852,7 @@ async function readKeyInput(opts) {
   }
   return key;
 }
-function register11(program2) {
+function register12(program2) {
   const group = program2.command("keys").description("Manage BYOK provider keys (write-only; reads show last4)");
   group.command("set <provider>").description(
     "Set a provider key (anthropic|openai); reads it from stdin or GAUGE_PROVIDER_KEY"
@@ -5230,7 +5908,7 @@ function register11(program2) {
 // src/commands/mcp.ts
 var mcp_exports2 = {};
 __export(mcp_exports2, {
-  register: () => register12
+  register: () => register13
 });
 import { readFileSync as readFileSync8 } from "fs";
 function mcpPath(org) {
@@ -5277,7 +5955,7 @@ function specFromOpts(opts) {
     ...tools.length ? { tools } : {}
   };
 }
-function register12(program2) {
+function register13(program2) {
   const group = program2.command("mcp").description("Manage MCP servers used by eval and visibility runs");
   group.command("list").description("List the org's MCP servers with their newest version").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -5408,9 +6086,9 @@ function register12(program2) {
 // src/commands/members.ts
 var members_exports = {};
 __export(members_exports, {
-  register: () => register13
+  register: () => register14
 });
-function register13(program2) {
+function register14(program2) {
   const group = program2.command("members").description("Team members and pending invites (read-only)");
   group.command("list").description("List members and pending invites").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -5452,7 +6130,7 @@ var models_exports = {};
 __export(models_exports, {
   capabilityLabel: () => capabilityLabel,
   executionTargetsPath: () => executionTargetsPath,
-  register: () => register14
+  register: () => register15
 });
 function executionTargetsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/execution-targets`;
@@ -5460,7 +6138,7 @@ function executionTargetsPath(org) {
 function capabilityLabel(capabilities) {
   return Object.entries(capabilities).filter(([, supported]) => supported).map(([name]) => name === "agentContext" ? "context" : name).join(", ");
 }
-function register14(program2) {
+function register15(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);
@@ -5487,7 +6165,7 @@ function register14(program2) {
 // src/commands/onboard.ts
 var onboard_exports = {};
 __export(onboard_exports, {
-  register: () => register15
+  register: () => register16
 });
 function orgNameFromEmail(email) {
   const domain = email?.split("@")[1] ?? "";
@@ -5495,7 +6173,7 @@ function orgNameFromEmail(email) {
   if (!base) return "My Workspace";
   return base.charAt(0).toUpperCase() + base.slice(1);
 }
-function register15(program2) {
+function register16(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(
@@ -5589,10 +6267,602 @@ Using workspace ${orgSlug}.`
   );
 }
 
+// src/commands/optimizations.ts
+var optimizations_exports2 = {};
+__export(optimizations_exports2, {
+  parseEffort: () => parseEffort,
+  parseStatuses: () => parseStatuses,
+  parseSubject: () => parseSubject,
+  parseTarget: () => parseTarget,
+  planFromOpts: () => planFromOpts,
+  register: () => register17,
+  trialBodyFromOpts: () => trialBodyFromOpts
+});
+import { readFileSync as readFileSync9 } from "fs";
+var TERMINAL2 = /* @__PURE__ */ new Set(["DONE", "ARCHIVED"]);
+var EFFORTS = ["low", "medium", "high", "xhigh"];
+function basePath(org) {
+  return `/api/v1/orgs/${encodeURIComponent(org)}/optimizations`;
+}
+function itemPath2(org, id) {
+  return `${basePath(org)}/${encodeURIComponent(id)}`;
+}
+function trialPath(org, id, trialId) {
+  return `${itemPath2(org, id)}/trials/${encodeURIComponent(trialId)}`;
+}
+function readText2(path) {
+  return readFileSync9(path === "-" ? 0 : path, "utf8");
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseSubject(opts) {
+  if (opts.eval && opts.preference)
+    throw new CliError("usage", "pass --eval or --preference, not both");
+  if (opts.eval) return { subjectKind: "EVAL_SET", subjectId: opts.eval };
+  if (opts.preference)
+    return { subjectKind: "VISIBILITY_PROMPT", subjectId: opts.preference };
+  throw new CliError("usage", "pass --eval <id> or --preference <id>");
+}
+function parseTarget(raw) {
+  const spec = parseAgentSpec(raw);
+  if (spec.models.length > 1)
+    throw new CliError(
+      "usage",
+      `--target "${raw}" names several models; an optimization pins exactly one`
+    );
+  return spec.models.length ? { agent: spec.agent, model: spec.models[0] } : { agent: spec.agent };
+}
+function parseEffort(raw) {
+  const value = raw.trim().toLowerCase();
+  if (!EFFORTS.includes(value))
+    throw new CliError(
+      "usage",
+      `--effort must be one of ${EFFORTS.join(", ")} (got "${raw}")`
+    );
+  return value.toUpperCase();
+}
+function parseCount(raw, flag) {
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1)
+    throw new CliError("usage", `${flag} must be a positive integer`);
+  return n;
+}
+function planFromOpts(opts) {
+  if (opts.effort && (opts.samples || opts.rounds))
+    throw new CliError(
+      "usage",
+      "pass --effort or --samples/--rounds, not both"
+    );
+  return {
+    effort: opts.effort ? parseEffort(opts.effort) : void 0,
+    sampleCount: parseCount(opts.samples, "--samples"),
+    maxRounds: parseCount(opts.rounds, "--rounds"),
+    target: opts.target ? parseTarget(opts.target) : void 0
+  };
+}
+function parseStatuses(raw) {
+  if (!raw) return void 0;
+  const parts = raw.split(",").map((part) => part.trim().toUpperCase()).filter(Boolean);
+  for (const part of parts)
+    if (!["ACTIVE", "PAUSED", "DONE", "ARCHIVED"].includes(part))
+      throw new CliError(
+        "usage",
+        `unknown status "${part}" (expected ACTIVE, PAUSED, DONE, ARCHIVED)`
+      );
+  return parts.join(",");
+}
+function trialBodyFromOpts(opts, read = readText2) {
+  const launch = opts.launch !== false;
+  const fork = opts.forkRun || opts.forkBoundary ? (() => {
+    if (!opts.forkRun || !opts.forkBoundary)
+      throw new CliError(
+        "usage",
+        "--fork-run and --fork-boundary go together"
+      );
+    return { runId: opts.forkRun, boundarySeq: opts.forkBoundary };
+  })() : void 0;
+  if (opts.file) {
+    const parsed = JSON.parse(read(opts.file));
+    const pick = parseCount(opts.pick, "--pick") ?? 1;
+    let chosen;
+    if (Array.isArray(parsed)) {
+      if (pick > parsed.length)
+        throw new CliError(
+          "usage",
+          `--pick ${pick} but the file holds ${parsed.length} proposal${parsed.length === 1 ? "" : "s"}`
+        );
+      chosen = parsed[pick - 1];
+    } else {
+      if (opts.pick !== void 0)
+        throw new CliError("usage", "--pick applies to a proposals array");
+      chosen = parsed;
+    }
+    const record = chosen;
+    const body = "trial" in record ? record : { trial: record };
+    return { ...body, ...fork ? { fork } : {}, launch };
+  }
+  if (!opts.title) throw new CliError("usage", "--title is required");
+  const lever = opts.lever?.toUpperCase();
+  const kind = opts.kind?.toUpperCase();
+  let intervention;
+  if (opts.page || opts.bodyFile) {
+    if (!opts.page || !opts.bodyFile)
+      throw new CliError("usage", "--page and --body-file go together");
+    intervention = {
+      kind: "REWRITE_DOCS",
+      after: { pages: [{ url: opts.page, body: read(opts.bodyFile) }] }
+    };
+  } else if (opts.removeSkill) {
+    intervention = {
+      kind: "REMOVE_SKILL",
+      before: { skillVersionId: opts.removeSkill },
+      after: {}
+    };
+  } else if (opts.skillVersion) {
+    intervention = {
+      kind: kind ?? "ADD_SKILL",
+      after: { skillVersionId: opts.skillVersion },
+      ...kind === "EDIT_SKILL" ? { before: { skillVersionId: opts.skillVersion } } : {}
+    };
+  } else {
+    throw new CliError(
+      "usage",
+      "describe the change: --skill-version <id>, --remove-skill <id>, --page <url> --body-file <path>, or --file <proposal.json>"
+    );
+  }
+  const trial = {
+    title: opts.title,
+    hypothesis: opts.hypothesis,
+    lever: lever ?? (intervention.kind === "REWRITE_DOCS" ? "DOCS" : "SKILL"),
+    intervention,
+    authorMode: "MANUAL"
+  };
+  return { trial, ...fork ? { fork } : {}, launch };
+}
+function pct(value) {
+  return value === null || value === void 0 ? "\u2014" : `${Math.round(value * 100)}%`;
+}
+function subjectLabel(kind) {
+  return kind === "EVAL_SET" ? "eval" : "preference";
+}
+function toRow4(o) {
+  return {
+    id: o.id,
+    name: o.name.length > 40 ? `${o.name.slice(0, 37)}...` : o.name,
+    status: o.status,
+    subject: `${subjectLabel(o.subjectKind)} ${o.subjectName}`,
+    round: `${o.round}/${o.maxRounds}`,
+    baseline: pct(o.before),
+    now: pct(o.after),
+    delta: o.delta === null ? "\u2014" : `${o.delta > 0 ? "+" : ""}${o.delta}pt`,
+    credits: `${o.creditsSpent}/${o.creditsReserved}`,
+    updated: o.updatedAt
+  };
+}
+function trialRow(t) {
+  return {
+    key: t.key,
+    round: t.roundNumber,
+    title: t.title.length > 48 ? `${t.title.slice(0, 45)}...` : t.title,
+    surface: t.lever ?? "",
+    change: t.kind,
+    "builds on": t.parentKey ?? "",
+    status: t.status,
+    score: pct(t.score),
+    result: t.verdict ?? "",
+    sessions: t.sessions,
+    adopted: t.adopted ? "yes" : "",
+    id: t.id
+  };
+}
+function printDetail3(o) {
+  console.log(`id:        ${o.id}`);
+  console.log(`name:      ${o.name}`);
+  console.log(
+    `status:    ${o.status}${o.stopReason ? ` (${o.stopReason})` : ""}`
+  );
+  console.log(`mode:      ${o.mode === "AUTO" ? "Gauge-led" : "manual"}`);
+  console.log(
+    `subject:   ${subjectLabel(o.subjectKind)} ${o.subjectName} (${o.subjectId})`
+  );
+  console.log(
+    `target:    ${o.settings.pinnedAgent ?? "(subject roster)"}${o.settings.pinnedModel ? `:${o.settings.pinnedModel}` : ""}`
+  );
+  console.log(
+    `plan:      ${o.settings.sampleCount} session${o.settings.sampleCount === 1 ? "" : "s"} per trial, up to ${o.settings.maxRounds} rounds, auto-adopt ${o.settings.autoAdopt ? "on" : "off"}`
+  );
+  console.log(`credits:   ${o.creditsSpent} spent of ${o.settings.creditCap}`);
+  console.log(
+    `score:     ${pct(o.before)} \u2192 ${pct(o.after)}${o.delta === null ? "" : ` (${o.delta > 0 ? "+" : ""}${o.delta}pt)`}`
+  );
+  if (o.summary) console.log(`summary:   ${o.summary}`);
+  if (o.diagnosis?.summary) console.log(`diagnosis: ${o.diagnosis.summary}`);
+  console.log("trials:");
+  printItems(o.rounds.flatMap((round) => round.trials).map(trialRow), "table");
+  for (const round of o.rounds)
+    if (round.narrative)
+      console.log(`round ${round.number}: ${round.narrative}`);
+}
+function printTrial(t) {
+  console.log(`key:        ${t.key} (round ${t.roundNumber}) \u2014 ${t.id}`);
+  console.log(`title:      ${t.title}`);
+  if (t.hypothesis) console.log(`hypothesis: ${t.hypothesis}`);
+  console.log(`change:     ${t.kind}${t.lever ? ` on ${t.lever}` : ""}`);
+  console.log(`builds on:  ${t.parentKey ?? "\u2014"}`);
+  console.log(
+    `status:     ${t.status}${t.verdict ? ` \xB7 ${t.verdict}` : ""}${t.adopted ? " \xB7 adopted" : ""}`
+  );
+  console.log(
+    `score:      ${pct(t.baselineScore)} \u2192 ${pct(t.score)} over ${t.sessions} session${t.sessions === 1 ? "" : "s"}`
+  );
+  if (t.outcome) console.log(`outcome:    ${t.outcome}`);
+  if (t.runs.length) {
+    console.log("sessions:");
+    for (const run of t.runs) {
+      const verdict = run.passed === null ? "unjudged" : run.passed ? "pass" : "fail";
+      console.log(`  ${run.id}: ${run.status} \xB7 ${verdict}`);
+      for (const criterion of run.criteria)
+        console.log(`      ${criterion.passed ? "\u2713" : "\u2717"} ${criterion.name}`);
+    }
+  }
+}
+function printChange(content) {
+  for (const doc of content.documents) {
+    console.log(`=== ${doc.path}`);
+    console.log("--- before");
+    console.log(doc.before || "(empty)");
+    console.log("+++ after");
+    console.log(doc.after || "(empty)");
+  }
+}
+function printEstimate(e) {
+  console.log(
+    `plan:      ${e.sampleCount} session${e.sampleCount === 1 ? "" : "s"} per trial \xD7 up to ${e.maxRounds} rounds`
+  );
+  console.log(`per trial: ${e.trialCredits.toFixed(1)} credits`);
+  console.log(`estimate:  ${e.estimate} credits (reserved as the cap)`);
+  if (e.basis === "byok")
+    console.log(
+      "note:      flat rate \u2014 your own key buys the tokens, so every model costs the same"
+    );
+  else if (e.approximate)
+    console.log(
+      "note:      no price or past run covers this model, so the figure is the credit hold, not a forecast"
+    );
+}
+function printDiagnosis(d) {
+  console.log(`id:          ${d.id}`);
+  console.log(`status:      ${d.status} over ${d.runCount} sessions`);
+  console.log(`summary:     ${d.summary ?? "(none)"}`);
+  console.log(`recommended: ${d.recommendedLever ?? "no single lever"}`);
+  if (d.clusters.length) {
+    console.log("opportunities:");
+    for (const cluster of d.clusters)
+      console.log(
+        `  - ${cluster.title} [${cluster.lever ?? "?"} \xB7 ${Math.round(cluster.confidence * 100)}%] ${cluster.failureMode}`
+      );
+  }
+}
+function addSubjectOptions(command) {
+  return command.option("--eval <id>", "an Agent Experience eval").option("--preference <id>", "an Agent Preference prompt");
+}
+function addPlanOptions(command) {
+  return command.option(
+    "--effort <level>",
+    "low (1\xD73), medium (1\xD75, default), high (2\xD78), xhigh (3\xD712)"
+  ).option("--samples <n>", "sessions per trial (instead of --effort)").option("--rounds <n>", "maximum rounds (instead of --effort)").option(
+    "--target <agent[:model]>",
+    "the one harness/model every session runs on, e.g. claude-code:claude-opus-4-8"
+  );
+}
+function register17(program2) {
+  const group = program2.command("optimizations").alias("optimize").description(
+    "Start, steer, and read optimizations: Gauge changes one owned surface per trial and adopts what improves an eval or preference prompt"
+  );
+  group.command("list").description("List the org's optimizations, newest activity first").option("--status <statuses>", "comma-separated: ACTIVE,PAUSED,DONE").option("--eval <id>", "only optimizations on this eval").option("--preference <id>", "only optimizations on this preference prompt").option("--limit <n>", "max rows (default 50)").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const subject = opts.eval || opts.preference ? parseSubject(opts) : void 0;
+      const res = await createClient().get(
+        basePath(org),
+        {
+          status: parseStatuses(opts.status),
+          subjectKind: subject?.subjectKind,
+          subjectId: subject?.subjectId,
+          limit: opts.limit
+        }
+      );
+      if (resolveOutput(cmd) === "json") printJson(res.items);
+      else printItems(res.items.map(toRow4), "table");
+    }
+  );
+  group.command("get <id>").description("One optimization: settings, score, and its trial ladder").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const detail = await createClient().get(itemPath2(org, id));
+    if (resolveOutput(cmd) === "json") printJson(detail);
+    else printDetail3(detail);
+  });
+  addSubjectOptions(
+    group.command("diagnose").description(
+      "Improvement opportunities for an eval or preference prompt from its judged sessions"
+    )
+  ).action(async (opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const diagnosis = await createClient().post(
+      `${basePath(org)}/diagnoses`,
+      parseSubject(opts)
+    );
+    if (resolveOutput(cmd) === "json") printJson(diagnosis);
+    else printDiagnosis(diagnosis);
+  });
+  addPlanOptions(
+    addSubjectOptions(
+      group.command("estimate").description("Price an optimization before starting it")
+    )
+  ).action(async (opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const estimate = await createClient().post(
+      `${basePath(org)}/estimate`,
+      { ...parseSubject(opts), ...planFromOpts(opts) }
+    );
+    if (resolveOutput(cmd) === "json") printJson(estimate);
+    else printEstimate(estimate);
+  });
+  addPlanOptions(
+    addSubjectOptions(
+      group.command("start").description(
+        "Start a Gauge-led optimization (reserves the estimate as the credit cap)"
+      )
+    )
+  ).option("--name <name>", "climb name (default: from the diagnosis)").option("--credit-cap <n>", "reserve this many credits instead").option("--target-score <0-1>", "stop once the score reaches this").option("--no-auto-adopt", "keep improvements pending until you adopt them").option("--yes", "skip the confirmation").action(
+    async (opts, cmd) => {
+      const org = resolveOrg(cmd);
+      if (!opts.target)
+        throw new CliError(
+          "usage",
+          "--target <agent[:model]> is required; see `gauge models list`"
+        );
+      const subject = parseSubject(opts);
+      const plan = planFromOpts(opts);
+      const creditCap = parseCount(opts.creditCap, "--credit-cap");
+      const targetScore = opts.targetScore === void 0 ? void 0 : Number(opts.targetScore);
+      if (targetScore !== void 0 && (Number.isNaN(targetScore) || targetScore < 0 || targetScore > 1))
+        throw new CliError("usage", "--target-score must be between 0 and 1");
+      const client = createClient();
+      const estimate = await client.post(
+        `${basePath(org)}/estimate`,
+        { ...subject, ...plan }
+      );
+      const cap = creditCap ?? estimate.estimate;
+      await confirmOrAbort(
+        `Start an optimization on ${subjectLabel(subject.subjectKind)} ${subject.subjectId}? Up to ${estimate.maxRounds} rounds, ${estimate.sampleCount} session${estimate.sampleCount === 1 ? "" : "s"} per trial, reserving ${cap} credits.`,
+        opts.yes
+      );
+      const detail = await client.post(basePath(org), {
+        ...subject,
+        ...plan,
+        name: opts.name,
+        creditCap,
+        autoAdopt: opts.autoAdopt,
+        targetScore
+      });
+      if (resolveOutput(cmd) === "json") printJson(detail);
+      else {
+        console.log(
+          `Started ${detail.id} "${detail.name}" \u2014 ${detail.creditsReserved} credits reserved. Follow it with \`gauge optimizations watch ${detail.id}\`.`
+        );
+      }
+    }
+  );
+  for (const command of ["pause", "resume", "cancel"]) {
+    group.command(`${command} <id>`).description(
+      {
+        pause: "Pause an active optimization (running sessions finish)",
+        resume: "Resume a paused optimization",
+        cancel: "Cancel an optimization: stops in-flight sessions and releases unspent credits"
+      }[command]
+    ).option("--yes", "skip the confirmation (cancel only)").action(async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      if (command === "cancel")
+        await confirmOrAbort(
+          `Cancel optimization ${id}? In-flight sessions stop and the reservation is released.`,
+          opts.yes
+        );
+      const detail = await createClient().post(
+        `${itemPath2(org, id)}/${command}`,
+        {}
+      );
+      if (resolveOutput(cmd) === "json") printJson(detail);
+      else
+        console.log(
+          `${detail.id}: ${detail.status}${detail.stopReason ? ` (${detail.stopReason})` : ""}`
+        );
+    });
+  }
+  group.command("watch <id>").description("Follow an optimization until it stops, printing each change").option("--interval <seconds>", "poll interval (default 15)").action(async (id, opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const client = createClient();
+    const intervalMs = Math.max(Number(opts.interval ?? 15) * 1e3, 2e3);
+    let last = "";
+    for (; ; ) {
+      const detail = await client.get(itemPath2(org, id));
+      const trials2 = detail.rounds.flatMap((round) => round.trials);
+      const line = `${detail.status} \xB7 round ${detail.round}/${detail.maxRounds} \xB7 ${pct(detail.before)} \u2192 ${pct(detail.after)} \xB7 ${detail.creditsSpent}/${detail.settings.creditCap} credits \xB7 ${trials2.filter((t) => t.status === "RUNNING").map((t) => t.key).join(",") || "idle"}`;
+      if (line !== last) {
+        last = line;
+        console.error(line);
+      }
+      if (TERMINAL2.has(detail.status)) {
+        if (resolveOutput(cmd) === "json") printJson(detail);
+        else printDetail3(detail);
+        return;
+      }
+      await sleep3(intervalMs);
+    }
+  });
+  const trials = group.command("trials").description("List, author, and run trials");
+  trials.command("list <id>").description("Every trial of an optimization with score and verdict").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      `${itemPath2(org, id)}/trials`
+    );
+    if (resolveOutput(cmd) === "json") printJson(res.items);
+    else printItems(res.items.map(trialRow), "table");
+  });
+  trials.command("add <id>").description(
+    "Author a trial on a manual optimization and run it (spends credits)"
+  ).option(
+    "--file <path>",
+    "a proposal JSON: one {trial, files?} or the array `propose -o json` prints; '-' for stdin"
+  ).option("--pick <n>", "which proposal to take from an array (default 1)").option("--title <text>", "what the change is").option("--hypothesis <text>", "why it should help").option("--lever <lever>", "DOCS, MARKETING_SITE, SKILL, SDK, CLI").option(
+    "--kind <kind>",
+    "ADD_SKILL (default with --skill-version), EDIT_SKILL"
+  ).option("--skill-version <id>", "skill version to add (or edit via --file)").option("--remove-skill <id>", "skill version to remove from the baseline").option("--page <url>", "docs page to rewrite (with --body-file)").option("--body-file <path>", "the rewritten page body; '-' for stdin").option("--fork-run <runId>", "fork-at-fetch source run for a docs rewrite").option(
+    "--fork-boundary <seq>",
+    "fork-at-fetch boundary from `gauge experiments boundaries`"
+  ).option(
+    "--no-launch",
+    "save the trial as a draft; run it with `trials run`"
+  ).option("--yes", "skip the confirmation").action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const body = trialBodyFromOpts(opts);
+      if (body.launch !== false)
+        await confirmOrAbort(
+          `Run trial "${body.trial.title}" on ${id} now? Spends credits.`,
+          opts.yes
+        );
+      const result = await createClient().post(`${itemPath2(org, id)}/trials`, body);
+      if (resolveOutput(cmd) === "json") printJson(result);
+      else
+        console.log(
+          `${result.launch ? "Running" : "Saved"} ${result.trial.key} "${result.trial.title}"${result.launch ? ` \u2014 ${result.launch.runIds.length} session${result.launch.runIds.length === 1 ? "" : "s"}` : ""}`
+        );
+    }
+  );
+  trials.command("run <id> <trialId>").description("Run a draft trial now (spends credits)").option("--yes", "skip the confirmation").action(
+    async (id, trialId, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      await confirmOrAbort(
+        `Run trial ${trialId} now? Spends credits.`,
+        opts.yes
+      );
+      const result = await createClient().post(
+        `${trialPath(org, id, trialId)}/launch`,
+        {}
+      );
+      if (resolveOutput(cmd) === "json") printJson(result);
+      else
+        console.log(
+          `Started ${result.runIds.length} session${result.runIds.length === 1 ? "" : "s"} for ${trialId}`
+        );
+    }
+  );
+  group.command("trial <id> <trialId>").description("One trial by id or key (B0, T1, \u2026) with its sessions").action(
+    async (id, trialId, _opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const trial = await createClient().get(
+        trialPath(org, id, trialId)
+      );
+      if (resolveOutput(cmd) === "json") printJson(trial);
+      else printTrial(trial);
+    }
+  );
+  group.command("change <id> <trialId>").description("The change a trial made: before and after text per document").option("--body", "print only the pasteable page body of a docs rewrite").action(
+    async (id, trialId, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const content = await createClient().get(
+        `${trialPath(org, id, trialId)}/content`
+      );
+      if (resolveOutput(cmd) === "json") printJson(content);
+      else if (opts.body) {
+        if (content.copyableBody === null)
+          throw new CliError(
+            "usage",
+            "this trial is not a docs rewrite; drop --body"
+          );
+        console.log(content.copyableBody);
+      } else printChange(content);
+    }
+  );
+  group.command("adopt <id> <trialId>").description(
+    "Make a settled BETTER trial the moving baseline (the eval itself is unchanged)"
+  ).action(
+    async (id, trialId, _opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const detail = await createClient().post(
+        `${trialPath(org, id, trialId)}/adopt`,
+        {}
+      );
+      if (resolveOutput(cmd) === "json") printJson(detail);
+      else
+        console.log(
+          `Adopted ${trialId}; baseline is now ${pct(detail.after)}`
+        );
+    }
+  );
+  group.command("propose <id>").description(
+    "Ask Gauge's proposer for one to three trial drafts (nothing runs; feed one to `trials add --file`)"
+  ).option("--request <text>", "steer the proposer").option("--lever <lever>", "keep to one lever").option("--kind <kind>", "keep to one change kind").option("--target-version <id>", "keep to one skill version").action(
+    async (id, opts, cmd) => {
+      const org = resolveOrg(cmd);
+      const res = await createClient().post(
+        `${itemPath2(org, id)}/propose`,
+        {
+          request: opts.request,
+          lever: opts.lever?.toUpperCase(),
+          kind: opts.kind?.toUpperCase(),
+          targetVersionId: opts.targetVersion
+        }
+      );
+      if (resolveOutput(cmd) === "json") printJson(res.items);
+      else {
+        for (const [index, proposal] of res.items.entries()) {
+          console.log(
+            `[${index + 1}] ${proposal.trial.title} \u2014 ${proposal.trial.intervention.kind} on ${proposal.trial.lever}`
+          );
+          if (proposal.trial.hypothesis)
+            console.log(`    ${proposal.trial.hypothesis}`);
+        }
+        console.error(
+          "Save them with `-o json > proposals.json`, then `gauge optimizations trials add <id> --file proposals.json --pick <n>`."
+        );
+      }
+    }
+  );
+  group.command("skill-files <versionId>").description(
+    "The text files of a skill version, the base an EDIT_SKILL trial edits"
+  ).action(async (versionId, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      `${basePath(org)}/skill-versions/${encodeURIComponent(versionId)}`
+    );
+    if (resolveOutput(cmd) === "json") printJson(res);
+    else
+      for (const file of res.files) {
+        console.log(`=== ${file.path}`);
+        console.log(file.body);
+      }
+  });
+  group.command("page <id>").description(
+    "The baseline body of a docs page, the base a REWRITE_DOCS trial edits"
+  ).requiredOption("--url <url>", "the page URL").action(async (id, opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const res = await createClient().get(
+      `${itemPath2(org, id)}/page`,
+      { url: opts.url }
+    );
+    if (resolveOutput(cmd) === "json") printJson(res);
+    else console.log(res.body);
+  });
+}
+
 // src/commands/org.ts
 var org_exports = {};
 __export(org_exports, {
-  register: () => register16
+  register: () => register18
 });
 function printSettings(s) {
   console.log(`slug:            ${s.slug}`);
@@ -5606,7 +6876,7 @@ function printSettings(s) {
   );
   console.log(`auto-join:       ${s.autoJoinDomain ?? "off"}`);
 }
-function register16(program2) {
+function register18(program2) {
   const group = program2.command("org").description(
     "This org's settings, read-only (see `gauge orgs` for the org list)"
   );
@@ -5623,12 +6893,12 @@ function register16(program2) {
 // src/commands/orgs.ts
 var orgs_exports2 = {};
 __export(orgs_exports2, {
-  register: () => register17
+  register: () => register19
 });
 function isDefault(org, defaultOrg) {
   return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
 }
-function register17(program2) {
+function register19(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);
@@ -5699,12 +6969,12 @@ function register17(program2) {
 // src/commands/personas.ts
 var personas_exports2 = {};
 __export(personas_exports2, {
-  register: () => register18
+  register: () => register20
 });
 function personasPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/personas`;
 }
-function register18(program2) {
+function register20(program2) {
   const group = program2.command("personas").description("Manage simulated-user personas for eval and visibility runs");
   group.command("list").description("List the org's personas").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -5777,7 +7047,7 @@ function register18(program2) {
 // src/commands/query.ts
 var query_exports2 = {};
 __export(query_exports2, {
-  register: () => register19
+  register: () => register21
 });
 var collect3 = (value, prev = []) => [
   ...prev,
@@ -5882,7 +7152,7 @@ async function buildSpec(opts) {
   }
   return spec;
 }
-var pct = (n) => `${(n * 100).toFixed(1)}%`;
+var pct2 = (n) => `${(n * 100).toFixed(1)}%`;
 function noteFreshness(f) {
   if (!f.available) {
     console.error(
@@ -5916,7 +7186,7 @@ ${res.sql}
     const out = {};
     for (const col of res.columns) {
       const v = row[col.key];
-      out[col.key] = rateKeys.has(col.key) && typeof v === "number" ? pct(v) : v;
+      out[col.key] = rateKeys.has(col.key) && typeof v === "number" ? pct2(v) : v;
     }
     return out;
   });
@@ -5969,7 +7239,7 @@ async function showMetadata(command, mode, dataset) {
   console.error(`dataset: ${ds.name} \u2014 ${ds.grain}`);
   printItems(rows, "table");
 }
-function register19(program2) {
+function register21(program2) {
   const group = program2.command("query").description(
     "Flexible reports over your event warehouse (run a report, or discover the catalog)"
   );
@@ -6005,7 +7275,7 @@ function register19(program2) {
 // src/commands/repos.ts
 var repos_exports2 = {};
 __export(repos_exports2, {
-  register: () => register20
+  register: () => register22
 });
 function reposPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/repos`;
@@ -6013,7 +7283,7 @@ function reposPath(org) {
 async function fetchAllRepos(client, org) {
   return fetchAllPages(client, reposPath(org));
 }
-function toRow4(repo) {
+function toRow5(repo) {
   return {
     name: repo.name,
     url: repo.url,
@@ -6028,7 +7298,7 @@ function toRow4(repo) {
 function syncWarning(repo) {
   return `warning: GitHub metadata sync failed; retry with \`gauge repos resync ${repo.url}\``;
 }
-function register20(program2) {
+function register22(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);
@@ -6038,7 +7308,7 @@ function register20(program2) {
       printJson(items);
       return;
     }
-    printItems(items.map(toRow4), "table");
+    printItems(items.map(toRow5), "table");
   });
   repos.command("add <url>").description("Add a repository (pulls languages/size/stars from GitHub)").option(
     "--ref <ref>",
@@ -6125,7 +7395,7 @@ function register20(program2) {
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register21
+  register: () => register23
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -6146,7 +7416,7 @@ function compact(value, max = 140) {
   const one = s.replace(/\s+/g, " ").trim();
   return one.length > max ? `${one.slice(0, max - 1)}\u2026` : one;
 }
-function toRow5(run) {
+function toRow6(run) {
   const selected = run.selectedProvider?.slug ?? "";
   const observed = run.observedProvider?.slug;
   return {
@@ -6385,7 +7655,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register21(program2) {
+function register23(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) => {
@@ -6408,7 +7678,7 @@ function register21(program2) {
         printJson(page);
         return;
       }
-      printItems(page.items.map(toRow5), "table");
+      printItems(page.items.map(toRow6), "table");
       if (page.nextCursor) {
         console.error(
           `(more results \u2014 rerun with --cursor ${page.nextCursor})`
@@ -6509,7 +7779,7 @@ function register21(program2) {
 var skills_exports2 = {};
 __export(skills_exports2, {
   buildSkillEditBody: () => buildSkillEditBody,
-  register: () => register22
+  register: () => register24
 });
 function skillsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/skills`;
@@ -6571,7 +7841,7 @@ async function buildSkillEditBody(opts, fetchCurrentSource) {
     throw new CliError("usage", "nothing to change");
   return body;
 }
-function register22(program2) {
+function register24(program2) {
   const group = program2.command("skills").description("Manage agent skills used by eval and visibility runs");
   group.command("list").description("List the org's skills with their newest version").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -6593,21 +7863,21 @@ function register22(program2) {
   });
   group.command("get <ref>").description("Show one skill: source, note, every version").action(async (ref, _opts, cmd) => {
     const org = resolveOrg(cmd);
-    const skill = await createClient().get(
+    const skill2 = await createClient().get(
       skillPath(org, ref)
     );
     if (resolveOutput(cmd) === "json") {
-      printJson(skill);
+      printJson(skill2);
       return;
     }
-    console.log(`name:    ${skill.name}`);
-    console.log(`id:      ${skill.id}`);
-    console.log(`note:    ${skill.note ?? "(none)"}`);
-    console.log(`source:  ${sourceLabel(skill.source) || "(untracked)"}`);
+    console.log(`name:    ${skill2.name}`);
+    console.log(`id:      ${skill2.id}`);
+    console.log(`note:    ${skill2.note ?? "(none)"}`);
+    console.log(`source:  ${sourceLabel(skill2.source) || "(untracked)"}`);
     console.log("versions:");
-    for (const v of skill.versions)
+    for (const v of skill2.versions)
       console.log(
-        `  ${skill.name}@${v.label}  ${v.contentDigest.slice(0, 19)}  ${v.createdAt}`
+        `  ${skill2.name}@${v.label}  ${v.contentDigest.slice(0, 19)}  ${v.createdAt}`
       );
   });
   group.command("add <reference>").description("Ingest a skill from owner/repo[/skill][#ref] or a GitHub URL").option("--as <handle>", "our handle (default: the directory basename)").option(
@@ -6652,8 +7922,8 @@ function register22(program2) {
     const org = resolveOrg(cmd);
     const client = createClient();
     const body = await buildSkillEditBody(opts, async () => {
-      const skill = await client.get(skillPath(org, ref));
-      return skill.source;
+      const skill2 = await client.get(skillPath(org, ref));
+      return skill2.source;
     });
     const updated = await client.patch(
       skillPath(org, ref),
@@ -6712,7 +7982,7 @@ function register22(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register23
+  register: () => register25
 });
 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)");
@@ -6732,7 +8002,7 @@ function filterQuery(opts) {
     limit: opts.full ? "1000" : opts.limit
   };
 }
-var pct2 = (rate) => `${(rate * 100).toFixed(1)}%`;
+var pct3 = (rate) => `${(rate * 100).toFixed(1)}%`;
 var delta = (d) => d === null || d === 0 ? "\u2014" : d > 0 ? `+${d}` : String(d);
 function noteFreshness2(f) {
   if (!f.available) {
@@ -6745,7 +8015,7 @@ function noteFreshness2(f) {
     );
   }
 }
-async function runStats(command, resource, opts, toRow7) {
+async function runStats(command, resource, opts, toRow8) {
   const org = resolveOrg(command);
   const output = resolveOutput(command);
   const res = await createClient().get(
@@ -6756,7 +8026,7 @@ async function runStats(command, resource, opts, toRow7) {
     printJson(res);
     return;
   }
-  printItems(res.items.map(toRow7), "table");
+  printItems(res.items.map(toRow8), "table");
   noteFreshness2(res.freshness);
 }
 var rankingRow = (r) => ({
@@ -6764,8 +8034,8 @@ var rankingRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  "install%": pct2(r.installRate),
-  "mention%": pct2(r.mentionRate),
+  "install%": pct3(r.installRate),
+  "mention%": pct3(r.mentionRate),
   delta: delta(r.deltaRank)
 });
 var packageRow = (r) => ({
@@ -6774,28 +8044,28 @@ var packageRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  rate: pct2(r.rate)
+  rate: pct3(r.rate)
 });
 var brandRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  rate: pct2(r.rate)
+  rate: pct3(r.rate)
 });
 var funnelRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
-  "mention%": pct2(r.mentionRate),
-  "install%": pct2(r.installRate)
+  "mention%": pct3(r.mentionRate),
+  "install%": pct3(r.installRate)
 });
 var domainRow = (r) => ({
   domain: r.domain,
   brand: r.brandName,
   runs: r.runs,
-  rate: pct2(r.rate),
+  rate: pct3(r.rate),
   requests: r.requests
 });
-function register23(program2) {
+function register25(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -6827,9 +8097,9 @@ function register23(program2) {
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
-  register: () => register24
+  register: () => register26
 });
-function pct3(rate) {
+function pct4(rate) {
   return rate == null ? "\u2014" : `${Math.round(rate * 100)}%`;
 }
 function delta2(pp) {
@@ -6837,7 +8107,7 @@ function delta2(pp) {
   const rounded = Math.round(pp);
   return rounded === 0 ? "" : ` (${rounded > 0 ? "+" : ""}${rounded}pp)`;
 }
-function register24(program2) {
+function register26(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(
@@ -6862,7 +8132,7 @@ function register24(program2) {
     } else {
       for (const card of s.agentExperience.data.cards) {
         console.log(
-          `  ${card.name}: ${pct3(card.passRate)}${delta2(card.deltaPP)} over ${card.judgedRuns} judged run(s)`
+          `  ${card.name}: ${pct4(card.passRate)}${delta2(card.deltaPP)} over ${card.judgedRuns} judged run(s)`
         );
       }
       const extra = s.agentExperience.data.setCount - s.agentExperience.data.cards.length;
@@ -6875,7 +8145,7 @@ function register24(program2) {
       console.log("  (no visibility runs in the last 30 days)");
     } else {
       for (const card of s.visibility.data.cards) {
-        const owned = card.owned ? `${card.owned.name} #${card.owned.rank}, chosen ${pct3(card.owned.chosenRate)}${delta2(card.chosenDeltaPP)}` : "no owned brand ranked";
+        const owned = card.owned ? `${card.owned.name} #${card.owned.rank}, chosen ${pct4(card.owned.chosenRate)}${delta2(card.chosenDeltaPP)}` : "no owned brand ranked";
         console.log(`  ${card.name}: ${owned}`);
       }
     }
@@ -6899,12 +8169,12 @@ function register24(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register25
+  register: () => register27
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register25(program2) {
+function register27(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -6947,9 +8217,9 @@ function register25(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register26
+  register: () => register28
 });
-function register26(program2) {
+function register28(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);
@@ -6996,7 +8266,7 @@ function register26(program2) {
 // src/commands/visibility.ts
 var visibility_exports2 = {};
 __export(visibility_exports2, {
-  register: () => register27,
+  register: () => register29,
   visibilityPath: () => visibilityPath
 });
 function visibilityPath(org) {
@@ -7027,7 +8297,7 @@ function brandsLabel(v) {
   if (v.kind === "HEAD_TO_HEAD") return `${v.brandA} vs ${v.brandB}`;
   return v.branded ? v.brandA ?? "branded" : "organic";
 }
-function toRow6(v) {
+function toRow7(v) {
   return {
     id: v.id,
     name: v.name,
@@ -7039,7 +8309,7 @@ function toRow6(v) {
     "last run": v.lastRunAt ?? "-"
   };
 }
-function printDetail3(v) {
+function printDetail4(v) {
   console.log(`id:      ${v.id}`);
   console.log(`name:    ${v.name}`);
   console.log(`kind:    ${v.kind}`);
@@ -7074,7 +8344,7 @@ function registerPreferenceGroup(group) {
       visibilityPath(org)
     );
     if (resolveOutput(cmd) === "json") printJson(res.items);
-    else printItems(res.items.map(toRow6), "table");
+    else printItems(res.items.map(toRow7), "table");
   });
   group.command("get <id>").description("Show one preference prompt").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7082,7 +8352,7 @@ function registerPreferenceGroup(group) {
       `${visibilityPath(org)}/${encodeURIComponent(id)}`
     );
     if (resolveOutput(cmd) === "json") printJson(vp);
-    else printDetail3(vp);
+    else printDetail4(vp);
   });
   addRunSettingsCreateOptions(
     group.command("create").description(
@@ -7345,7 +8615,7 @@ function registerPreferenceGroup(group) {
     );
   });
 }
-function register27(program2) {
+function register29(program2) {
   const preference = program2.command("preference").description("Manage Agent Preference prompts and measured markets");
   registerPreferenceGroup(preference);
   const legacy = program2.command("visibility", { hidden: true });
@@ -7375,8 +8645,10 @@ for (const group of [
   personas_exports2,
   skills_exports2,
   mcp_exports2,
+  connections_exports2,
   repos_exports2,
   runs_exports2,
+  optimizations_exports2,
   experiments_exports2,
   apply_exports,
   batches_exports,