@withgauge/cli 0.11.2 → 0.12.1

package/dist/index.js

@@ -1883,7 +1883,9 @@ var updateEvalSetBodySchema = z20.object({
 }).extend(ownedConfigurationPatchShape).strict();
 var runEvalSetResponseSchema = z20.object({
   batchIds: z20.array(z20.string()),
-  runIds: z20.array(z20.string())
+  runIds: z20.array(z20.string()),
+  /** Durable launch request; absent for older and climb-trial launch paths. */
+  runRequestId: z20.string().optional()
 });
 var evalSetRunSchema = z20.object({
   id: z20.string(),
@@ -2564,10 +2566,578 @@ var meResponseSchema = z27.object({
 });
 
 // ../packages/api-schemas/src/optimizations.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
+
+// ../packages/api-schemas/src/cli-interventions.ts
+import { z as z28 } from "zod";
+var digest = z28.string().regex(/^[a-f0-9]{64}$/);
+var token = z28.string().min(1).max(4096);
+var optionFlag = z28.string().regex(/^--?[A-Za-z0-9][A-Za-z0-9-]*$/);
+var envKey = z28.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var relativePath = z28.string().min(1).max(1024).refine(
+  (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.includes("\0") && path2.split("/").every(
+    (part) => part && part !== "." && part !== ".." && ![".git", "node_modules", ".pnpm", ".yarn", ".venv"].includes(part)
+  ),
+  "Use a workspace-relative path without traversal"
+);
+var sourcedValue = z28.discriminatedUnion("source", [
+  z28.object({ source: z28.literal("literal"), value: z28.string().max(8192) }).strict(),
+  z28.object({ source: z28.literal("localFact"), key: envKey }).strict()
+]);
+var cliLaunchFormSchema = z28.enum([
+  "native",
+  "path",
+  "symlink",
+  "shebang",
+  "node-script",
+  "python-script",
+  "python-module",
+  "execveat-path",
+  "execveat-fd"
+]);
+var cliObservationReasonSchema = z28.enum([
+  "eligible",
+  "other-target",
+  "other-command",
+  "selector-mismatch",
+  "unknown-command",
+  "identity-unresolved",
+  "artifact-mismatch",
+  "runtime-mismatch",
+  "launch-form",
+  "io-profile",
+  "operation-profile",
+  "descriptor-lifetime"
+]);
+var cliIoProfileSchema = z28.enum([
+  "pipes",
+  "redirected",
+  "shared-descriptor",
+  "pty"
+]);
+var cliObservationSchema = z28.object({
+  invocationId: z28.string().regex(/^[a-f0-9]{32}$/),
+  targetId: token,
+  commandId: token.nullable(),
+  entrypointSha256: digest,
+  runtimeSha256: digest.nullable(),
+  launchForm: cliLaunchFormSchema.nullable(),
+  ioProfile: cliIoProfileSchema.nullable(),
+  reason: cliObservationReasonSchema
+});
+var cliCoverageSchema = z28.object({
+  attempt: z28.number().int().nonnegative(),
+  observedInvocationCount: z28.number().int().nonnegative().nullable(),
+  invocationCount: z28.number().int().nonnegative(),
+  appliedInvocationCount: z28.number().int().nonnegative(),
+  incompleteCount: z28.number().int().nonnegative(),
+  unsupportedCount: z28.number().int().nonnegative(),
+  instrumentationFailed: z28.boolean(),
+  observations: z28.array(cliObservationSchema),
+  unsupportedDiagnostics: z28.array(z28.string())
+});
+var cliOperationKindSchema = z28.enum([
+  "ensureOption",
+  "replaceOption",
+  "setEnv",
+  "streamOutput",
+  "completeOutput",
+  "structuredStdin",
+  "promptRecipe",
+  "generatedFile"
+]);
+var commandCapabilitiesSchema = z28.object({
+  operations: z28.array(cliOperationKindSchema).max(8),
+  options: z28.array(z28.object({ flag: optionFlag, takesValue: z28.boolean() }).strict()).max(100).default([]),
+  settings: z28.array(envKey).max(100).default([]),
+  localFacts: z28.array(envKey).max(30).default([]),
+  generatedPaths: z28.array(relativePath).max(50).default([]),
+  outputModes: z28.array(z28.enum(["streaming", "completed"])).max(2).default([]),
+  stdinFormats: z28.array(z28.enum(["text", "json", "jsonl"])).max(3).default([]),
+  recipeIds: z28.array(token).max(50).default([])
+}).strict();
+var cliTargetSchema = z28.object({
+  id: token,
+  vendor: token,
+  package: token,
+  version: token.nullable(),
+  /** Published artifact identity and exact executable/entrypoint identity. */
+  artifactSha256: digest.nullable(),
+  entrypointSha256: digest.nullable(),
+  /** Trace-derived recognition hints. Actual bytes are captured by record mode. */
+  discovery: z28.object({
+    ecosystem: token.nullable(),
+    program: token,
+    executables: z28.array(token).max(20)
+  }).strict().optional(),
+  ownershipEvidence: z28.string().min(1).max(2048),
+  entrypoints: z28.array(z28.string().min(1).max(1024)).max(20),
+  /** Flags accepted before the subcommand, with explicit value arity. */
+  globalOptions: z28.array(z28.object({ flag: optionFlag, takesValue: z28.boolean() }).strict()).max(100),
+  launchForms: z28.array(cliLaunchFormSchema).min(1),
+  ioProfiles: z28.array(cliIoProfileSchema).min(1),
+  commands: z28.array(
+    z28.object({
+      id: token,
+      /** Tokens following global options, before a literal `--`. */
+      subcommand: z28.array(token).max(8),
+      capabilities: commandCapabilitiesSchema
+    }).strict()
+  ).min(1)
+}).strict().superRefine((target, ctx) => {
+  if (!target.discovery && (!target.version || !target.artifactSha256 || !target.entrypointSha256 || !target.entrypoints.length))
+    ctx.addIssue({
+      code: "custom",
+      message: "Registered targets need complete artifact identities"
+    });
+  if (target.discovery && (target.artifactSha256 !== null || target.entrypointSha256 !== null))
+    ctx.addIssue({
+      code: "custom",
+      message: "Discovered targets learn bytes from baseline invocations"
+    });
+  for (const [index, command] of target.commands.entries()) {
+    if (target.commands.findIndex((other) => other.id === command.id) !== index)
+      ctx.addIssue({
+        code: "custom",
+        path: ["commands", index, "id"],
+        message: "Duplicate command ID"
+      });
+    const { capabilities } = command;
+    if (new Set(capabilities.operations).size !== capabilities.operations.length)
+      ctx.addIssue({
+        code: "custom",
+        path: ["commands", index, "capabilities", "operations"],
+        message: "Duplicate operation"
+      });
+    const requires = (kind, valid, message) => {
+      if (capabilities.operations.includes(kind) && !valid)
+        ctx.addIssue({
+          code: "custom",
+          path: ["commands", index, "capabilities", "operations"],
+          message
+        });
+    };
+    requires(
+      "streamOutput",
+      capabilities.outputModes.includes("streaming"),
+      "Streaming output needs a qualified streaming mode"
+    );
+    requires(
+      "completeOutput",
+      capabilities.outputModes.includes("completed"),
+      "Completed output needs a qualified completed mode"
+    );
+    requires(
+      "structuredStdin",
+      capabilities.stdinFormats.length > 0,
+      "Structured stdin needs a qualified format"
+    );
+    requires(
+      "promptRecipe",
+      capabilities.recipeIds.length > 0,
+      "Prompt recipes need qualified prompt IDs"
+    );
+    requires(
+      "generatedFile",
+      capabilities.generatedPaths.length > 0,
+      "Generated files need attributed output paths"
+    );
+    requires(
+      "setEnv",
+      capabilities.settings.length > 0,
+      "Environment changes need supported settings"
+    );
+    requires(
+      "ensureOption",
+      capabilities.options.length > 0,
+      "Arguments need supported options"
+    );
+    requires(
+      "replaceOption",
+      capabilities.options.length > 0,
+      "Arguments need supported options"
+    );
+  }
+});
+var CLI_CATALOG_MAX_TARGETS = 100;
+var cliCatalogSchema = z28.object({
+  version: z28.union([z28.literal(1), z28.literal(2)]),
+  engineVersion: token,
+  digest,
+  targets: z28.array(cliTargetSchema).max(CLI_CATALOG_MAX_TARGETS)
+}).strict().superRefine((catalog, ctx) => {
+  if (catalog.version === 1 && (!catalog.targets.length || catalog.targets.some((target) => target.discovery)))
+    ctx.addIssue({
+      code: "custom",
+      message: "Discovery requires catalog version 2"
+    });
+  catalog.targets.forEach((target, index) => {
+    if (catalog.targets.findIndex((other) => other.id === target.id) !== index)
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", index, "id"],
+        message: "Duplicate target ID"
+      });
+  });
+});
+var exitPredicate = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("any") }).strict(),
+  z28.object({
+    kind: z28.literal("code"),
+    value: z28.number().int().min(0).max(255)
+  }).strict()
+]);
+var outputStream = z28.enum(["stdout", "stderr", "combined"]);
+var literalEdit = z28.object({ find: z28.string().min(1).max(8192), replace: z28.string().max(8192) }).strict();
+function boundedOutputPattern(pattern) {
+  let at = pattern.startsWith("^") ? 1 : 0;
+  const end = pattern.endsWith("$") && pattern.length > at ? pattern.length - 1 : pattern.length;
+  let stars = 0;
+  let literalBytes = 0;
+  while (at < end) {
+    const char = pattern[at];
+    if (char === "\\") {
+      if (++at >= end || !"\\.^$*+?[]{}()|".includes(pattern[at])) return false;
+      literalBytes++;
+    } else if (char === "." && pattern[at + 1] === "*") {
+      if (++stars > 1) return false;
+      at++;
+    } else if (".^$*+?[]{}()|\n\r".includes(char)) {
+      return false;
+    } else {
+      literalBytes++;
+    }
+    at++;
+  }
+  return literalBytes > 0;
+}
+var operationSchema = z28.discriminatedUnion("kind", [
+  z28.object({
+    kind: z28.literal("ensureOption"),
+    option: optionFlag,
+    value: sourcedValue.optional()
+  }).strict(),
+  z28.object({
+    kind: z28.literal("replaceOption"),
+    option: optionFlag,
+    value: sourcedValue
+  }).strict(),
+  z28.object({
+    kind: z28.literal("setEnv"),
+    key: envKey,
+    value: sourcedValue,
+    whenAbsent: z28.boolean()
+  }).strict(),
+  z28.object({
+    kind: z28.literal("streamOutput"),
+    stream: outputStream,
+    edit: literalEdit
+  }).strict(),
+  z28.object({
+    kind: z28.literal("completeOutput"),
+    stream: outputStream,
+    matcher: z28.discriminatedUnion("kind", [
+      z28.object({
+        kind: z28.literal("literal"),
+        text: z28.string().min(1).max(8192)
+      }).strict(),
+      z28.object({
+        kind: z28.literal("re2"),
+        pattern: z28.string().min(1).max(2048).refine(
+          boundedOutputPattern,
+          "Use literals, anchors, and at most one greedy .*; escape literal regex punctuation"
+        )
+      }).strict()
+    ]),
+    replace: z28.string().max(8192),
+    exit: exitPredicate
+  }).strict(),
+  z28.object({
+    kind: z28.literal("structuredStdin"),
+    format: z28.enum(["text", "json", "jsonl"]),
+    payload: sourcedValue,
+    timing: z28.literal("onLaunch"),
+    callerInput: z28.literal("replace"),
+    eof: z28.literal("close")
+  }).strict(),
+  z28.object({
+    kind: z28.literal("promptRecipe"),
+    recipeId: token,
+    steps: z28.array(
+      z28.object({
+        prompt: z28.string().min(1).max(4096),
+        response: sourcedValue,
+        timeoutMs: z28.number().int().min(1).max(12e4)
+      }).strict()
+    ).min(1).max(20),
+    overallTimeoutMs: z28.number().int().min(1).max(6e5),
+    completion: z28.string().min(1).max(4096)
+  }).strict(),
+  z28.object({
+    kind: z28.literal("generatedFile"),
+    path: relativePath,
+    beforeSha256: digest.nullable(),
+    generatedSha256: digest,
+    outcome: exitPredicate,
+    edit: literalEdit,
+    required: z28.boolean()
+  }).strict()
+]);
+var cliBaselineRecordFileSchema = z28.object({
+  pathIndex: z28.number().int().nonnegative().max(49),
+  path: relativePath,
+  status: z28.enum(["generated", "not-exercised"]),
+  beforeSha256: digest.nullable(),
+  generatedSha256: digest.nullable()
+}).strict();
+var baselineInvocationSchema = z28.object({
+  runId: token,
+  invocationId: token,
+  targetId: token,
+  commandId: token,
+  artifactSha256: digest.nullable(),
+  entrypointSha256: digest,
+  engineSha256: digest.optional(),
+  runtimeSha256: digest.optional(),
+  launchForm: cliLaunchFormSchema,
+  ioProfile: cliIoProfileSchema,
+  recordFiles: z28.array(cliBaselineRecordFileSchema).max(50).default([])
+}).strict();
+var cliInterventionSchema = z28.object({
+  schemaVersion: z28.union([z28.literal(1), z28.literal(2)]),
+  identityPolicy: z28.literal("artifact").optional(),
+  engineVersion: token,
+  engineSha256: digest.nullable(),
+  bundleSha256: digest,
+  catalog: cliCatalogSchema,
+  mode: z28.enum(["record", "trial"]),
+  captureProfiles: z28.array(cliIoProfileSchema).min(1),
+  activeTargetId: token.nullable(),
+  activeCommandId: token.nullable(),
+  selector: z28.object({
+    optionPresent: z28.array(optionFlag).max(20),
+    optionAbsent: z28.array(optionFlag).max(20)
+  }).strict().nullable(),
+  baselineInvocations: z28.array(baselineInvocationSchema).max(500),
+  operations: z28.array(operationSchema).max(50),
+  limits: z28.object({
+    completedStreamBytes: z28.number().int().min(1).max(2 * 1024 * 1024),
+    replacementBytes: z28.number().int().min(1).max(8192),
+    generatedFileBytes: z28.number().int().min(1).max(2 * 1024 * 1024),
+    generatedAggregateBytes: z28.number().int().min(1).max(8 * 1024 * 1024),
+    generatedFileCount: z28.number().int().min(1).max(50)
+  }).strict(),
+  shippingIntent: z28.enum([
+    "default",
+    "message",
+    "interaction",
+    "invocation-guidance",
+    "template"
+  ]).nullable()
+}).strict().superRefine((bundle, ctx) => {
+  const fail = (path2, message) => ctx.addIssue({ code: "custom", path: path2, message });
+  if (bundle.schemaVersion !== bundle.catalog.version)
+    fail(["schemaVersion"], "Bundle and catalog schema versions differ");
+  if (bundle.identityPolicy && bundle.schemaVersion !== 2)
+    fail(["identityPolicy"], "Artifact identity requires schema version 2");
+  if (bundle.identityPolicy && bundle.baselineInvocations.some((row2) => !row2.runtimeSha256))
+    fail(
+      ["baselineInvocations"],
+      "Artifact identity requires the recorded runtime bytes"
+    );
+  if (!bundle.engineSha256 && (bundle.schemaVersion === 1 || bundle.mode !== "record"))
+    fail(["engineSha256"], "A trial must pin the recorded engine bytes");
+  if (!bundle.catalog.targets.length)
+    fail(["catalog"], "A run needs at least one CLI target");
+  if (bundle.schemaVersion === 2 && bundle.mode === "trial" && bundle.baselineInvocations.some(
+    (item) => item.engineSha256 !== bundle.engineSha256
+  ))
+    fail(
+      ["baselineInvocations"],
+      "Baseline invocations must share the pinned engine"
+    );
+  bundle.baselineInvocations.forEach((invocation, index) => {
+    const command2 = bundle.catalog.targets.find((target2) => target2.id === invocation.targetId)?.commands.find((item) => item.id === invocation.commandId);
+    for (const [fileIndex, file] of invocation.recordFiles.entries()) {
+      if (command2?.capabilities.generatedPaths[file.pathIndex] !== file.path || file.status === "generated" && !file.generatedSha256 || file.status === "not-exercised" && file.generatedSha256 !== file.beforeSha256)
+        fail(
+          ["baselineInvocations", index, "recordFiles", fileIndex],
+          "Recorded file does not match the qualified command"
+        );
+    }
+  });
+  if (bundle.engineVersion !== bundle.catalog.engineVersion)
+    fail(["engineVersion"], "Engine and catalog versions differ");
+  if (bundle.mode === "record") {
+    if (bundle.activeTargetId || bundle.activeCommandId || bundle.selector || bundle.operations.length || bundle.shippingIntent)
+      fail(["mode"], "Record mode cannot select or modify a command");
+    return;
+  }
+  const target = bundle.catalog.targets.find(
+    (item) => item.id === bundle.activeTargetId
+  );
+  const command = target?.commands.find(
+    (item) => item.id === bundle.activeCommandId
+  );
+  if (!target || !command) {
+    fail(
+      ["activeCommandId"],
+      "Select a qualified command in the frozen catalog"
+    );
+    return;
+  }
+  if (!bundle.selector) fail(["selector"], "A trial needs token predicates");
+  else {
+    for (const flag of [
+      ...bundle.selector.optionPresent,
+      ...bundle.selector.optionAbsent
+    ])
+      if (!command.capabilities.options.some((option) => option.flag === flag))
+        fail(["selector"], `Unsupported selector option: ${flag}`);
+    if (bundle.selector.optionPresent.some(
+      (flag) => bundle.selector?.optionAbsent.includes(flag)
+    ))
+      fail(
+        ["selector"],
+        "A selector cannot require and forbid the same option"
+      );
+  }
+  if (!bundle.shippingIntent || !bundle.operations.length)
+    fail(
+      ["operations"],
+      "A trial needs a shipping intent and at least one operation"
+    );
+  if (bundle.operations.some((item) => item.kind === "promptRecipe") && bundle.operations.some((item) => item.kind === "completeOutput"))
+    fail(
+      ["operations"],
+      "Completed-output buffering cannot block an interactive prompt"
+    );
+  if (bundle.captureProfiles.includes("pty")) {
+    for (const [index, operation] of bundle.operations.entries()) {
+      if (operation.kind === "structuredStdin")
+        fail(
+          ["operations", index],
+          "PTY structured stdin cannot prove the declared EOF; use a prompt recipe"
+        );
+      if ((operation.kind === "streamOutput" || operation.kind === "completeOutput") && operation.stream !== "combined")
+        fail(["operations", index], "PTY output combines stdout and stderr");
+    }
+  }
+  if (bundle.operations.some((item) => item.kind === "promptRecipe") && bundle.operations.some((item) => item.kind === "structuredStdin"))
+    fail(
+      ["operations"],
+      "A prompt recipe and structured stdin cannot both control the same input stream"
+    );
+  if (bundle.operations.some(
+    (item) => (item.kind === "streamOutput" || item.kind === "completeOutput") && item.stream === "combined"
+  ) && !bundle.baselineInvocations.some(
+    (item) => item.targetId === target.id && item.commandId === command.id && item.artifactSha256 === target.artifactSha256 && (target.discovery !== void 0 || item.entrypointSha256 === target.entrypointSha256) && target.launchForms.includes(item.launchForm) && (item.ioProfile === "shared-descriptor" || item.ioProfile === "pty") && target.ioProfiles.includes(item.ioProfile) && bundle.captureProfiles.includes(item.ioProfile)
+  ))
+    fail(
+      ["operations"],
+      "Combined output requires a shared-descriptor or PTY baseline profile"
+    );
+  if (!bundle.baselineInvocations.some(
+    (item) => item.targetId === target.id && item.commandId === command.id && item.artifactSha256 === target.artifactSha256 && (target.discovery !== void 0 || item.entrypointSha256 === target.entrypointSha256) && target.launchForms.includes(item.launchForm) && target.ioProfiles.includes(item.ioProfile) && bundle.captureProfiles.includes(item.ioProfile)
+  ))
+    fail(
+      ["baselineInvocations"],
+      "No baseline invocation matches this exact command, artifact, launch form, and I/O profile"
+    );
+  const seen = /* @__PURE__ */ new Set();
+  const changedEnvironment = new Set(
+    bundle.operations.flatMap(
+      (item) => item.kind === "setEnv" ? [item.key] : []
+    )
+  );
+  bundle.operations.forEach((operation, index) => {
+    const path2 = ["operations", index];
+    if (!command.capabilities.operations.includes(operation.kind))
+      fail(path2, `${operation.kind} is not qualified for this command`);
+    if ("option" in operation && !command.capabilities.options.some(
+      (option) => option.flag === operation.option
+    ))
+      fail(path2, "Option is not supported by this version");
+    if (operation.kind === "ensureOption" || operation.kind === "replaceOption") {
+      const option = command.capabilities.options.find(
+        (item) => item.flag === operation.option
+      );
+      if (option && option.takesValue !== (operation.value !== void 0))
+        fail(path2, "Option value does not match its qualified arity");
+    }
+    if (operation.kind === "setEnv" && !command.capabilities.settings.includes(operation.key))
+      fail(path2, "Environment setting is not supported by this version");
+    if (operation.kind === "structuredStdin" && !command.capabilities.stdinFormats.includes(operation.format))
+      fail(path2, "Stdin format is not qualified");
+    if (operation.kind === "structuredStdin" && operation.payload.source === "literal" && operation.format !== "text") {
+      const records = operation.format === "json" ? [operation.payload.value] : operation.payload.value.trimEnd().split("\n");
+      try {
+        if (records.some((record) => !record.trim()))
+          throw new Error("Empty structured stdin record");
+        for (const record of records) JSON.parse(record);
+      } catch {
+        fail(
+          path2,
+          "Structured stdin payload does not match its declared JSON format"
+        );
+      }
+    }
+    if (operation.kind === "promptRecipe" && !command.capabilities.recipeIds.includes(operation.recipeId))
+      fail(path2, "Prompt recipe is not qualified");
+    if (operation.kind === "generatedFile" && !command.capabilities.generatedPaths.includes(operation.path))
+      fail(path2, "Output path is not attributed to this command");
+    if (operation.kind === "generatedFile" && !bundle.baselineInvocations.some(
+      (invocation) => invocation.targetId === target.id && invocation.commandId === command.id && invocation.recordFiles.some(
+        (file) => file.path === operation.path && file.status === "generated" && file.beforeSha256 === operation.beforeSha256 && file.generatedSha256 === operation.generatedSha256
+      )
+    ))
+      fail(
+        path2,
+        "No attributed baseline file matches the preimage and real generated bytes"
+      );
+    if (operation.kind === "streamOutput" && !command.capabilities.outputModes.includes("streaming"))
+      fail(path2, "Streaming output is not qualified");
+    if (operation.kind === "completeOutput" && !command.capabilities.outputModes.includes("completed"))
+      fail(path2, "Completed output is not qualified");
+    if (operation.kind === "streamOutput" && operation.edit.find === operation.edit.replace || operation.kind === "generatedFile" && operation.edit.find === operation.edit.replace || operation.kind === "completeOutput" && operation.matcher.kind === "literal" && operation.matcher.text === operation.replace)
+      fail(path2, "A trial operation must change the matched content");
+    const sources = [
+      "value" in operation ? operation.value : null,
+      operation.kind === "structuredStdin" ? operation.payload : null,
+      ...operation.kind === "promptRecipe" ? operation.steps.map((step) => step.response) : []
+    ];
+    if (sources.some(
+      (source) => source?.source === "localFact" && !command.capabilities.localFacts.includes(source.key)
+    ))
+      fail(path2, "Local fact is not declared non-secret for this command");
+    if (sources.some(
+      (source) => source?.source === "localFact" && changedEnvironment.has(source.key)
+    ))
+      fail(
+        path2,
+        "A local fact cannot be changed by another operation in the same trial"
+      );
+    const conflict = operation.kind === "ensureOption" || operation.kind === "replaceOption" ? `option:${operation.option}` : operation.kind === "setEnv" ? `env:${operation.key}` : operation.kind === "structuredStdin" ? "stdin" : operation.kind === "promptRecipe" ? `prompt:${operation.recipeId}` : operation.kind === "generatedFile" ? `file:${operation.path}` : null;
+    if (conflict && seen.has(conflict))
+      fail(path2, "Conflicting operation on the same input or output");
+    if (conflict) seen.add(conflict);
+  });
+  if (bundle.operations.filter((item) => item.kind === "generatedFile").length > bundle.limits.generatedFileCount)
+    fail(
+      ["limits", "generatedFileCount"],
+      "Generated file count exceeds limit"
+    );
+});
+var cliTrialChangeSchema = z28.object({
+  targetId: token,
+  commandId: token,
+  selector: cliInterventionSchema.shape.selector.unwrap(),
+  operations: cliInterventionSchema.shape.operations.min(1),
+  shippingIntent: cliInterventionSchema.shape.shippingIntent.unwrap()
+}).strict();
 
 // ../packages/api-schemas/src/climb.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // ../packages/api-schemas/src/climb-kinds.ts
 var LEVER_KINDS = [
@@ -2585,46 +3155,47 @@ var INTERVENTION_KINDS = [
   "REWRITE_DOCS",
   "PACKAGE_VERSION",
   "PACKAGE_CONTENT",
-  "CLI_VERSION"
+  "CLI_VERSION",
+  "CLI_INTERVENTION"
 ];
 var LEVER_INTERVENTIONS = {
   DOCS: ["REWRITE_DOCS"],
   MARKETING_SITE: ["REWRITE_DOCS"],
   SDK: ["PACKAGE_VERSION", "PACKAGE_CONTENT"],
-  CLI: ["CLI_VERSION"],
+  CLI: ["CLI_INTERVENTION"],
   SKILL: ["ADD_SKILL", "REMOVE_SKILL", "EDIT_SKILL"]
 };
 
 // ../packages/api-schemas/src/sandbox-overrides.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var SANDBOX_OVERRIDE_KINDS = ["packages", "clis"];
-var ecosystemSchema = z28.enum(["npm", "pypi", "cargo", "go", "gem"]);
-var overrideFilesSchema = z28.array(
-  z28.object({
-    path: z28.string().min(1).refine(
+var ecosystemSchema = z29.enum(["npm", "pypi", "cargo", "go", "gem"]);
+var overrideFilesSchema = z29.array(
+  z29.object({
+    path: z29.string().min(1).refine(
       (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.split("/").includes(".."),
       "Use a relative path within the target"
     ),
-    body: z28.string()
+    body: z29.string()
   }).strict()
 ).min(1);
 var contentShape = {
-  version: z28.string().trim().min(1).optional(),
+  version: z29.string().trim().min(1).optional(),
   files: overrideFilesSchema.optional()
 };
 var hasContent = (value) => value.version !== void 0 || value.files !== void 0;
-var sandboxOverridesSchema = z28.object({
-  version: z28.literal(1),
-  packages: z28.array(
-    z28.object({
+var sandboxOverridesSchema = z29.object({
+  version: z29.literal(1),
+  packages: z29.array(
+    z29.object({
       ecosystem: ecosystemSchema,
-      name: z28.string().trim().min(1),
+      name: z29.string().trim().min(1),
       ...contentShape
     }).strict().refine(hasContent, "Specify a version or files")
   ).optional(),
-  clis: z28.array(
-    z28.object({
-      name: z28.string().trim().min(1),
+  clis: z29.array(
+    z29.object({
+      name: z29.string().trim().min(1),
       ...contentShape
     }).strict().refine(hasContent, "Specify a version or files")
   ).optional()
@@ -2651,11 +3222,11 @@ var sandboxOverridesSchema = z28.object({
 });
 
 // ../packages/api-schemas/src/climb.ts
-var climbSubjectKindSchema = z29.enum(["EVAL_SET", "VISIBILITY_PROMPT"]);
-var leverKindSchema = z29.enum(LEVER_KINDS);
-var interventionKindSchema = z29.enum(INTERVENTION_KINDS);
-var skill = z29.object({ skillVersionId: z29.string().min(1) }).strict();
-var empty = z29.object({}).strict();
+var climbSubjectKindSchema = z30.enum(["EVAL_SET", "VISIBILITY_PROMPT"]);
+var leverKindSchema = z30.enum(LEVER_KINDS);
+var interventionKindSchema = z30.enum(INTERVENTION_KINDS);
+var skill = z30.object({ skillVersionId: z30.string().min(1) }).strict();
+var empty = z30.object({}).strict();
 function validateFixtureIntervention(value, ctx) {
   const result = webFixtureSchema.safeParse({ version: 1, ...value });
   if (!result.success) {
@@ -2668,69 +3239,75 @@ function validateFixtureIntervention(value, ctx) {
     }
   }
 }
-var interventionSchema = z29.discriminatedUnion("kind", [
-  z29.object({ kind: z29.literal("BASELINE"), after: empty }),
-  z29.object({ kind: z29.literal("ADD_SKILL"), after: skill }),
-  z29.object({ kind: z29.literal("REMOVE_SKILL"), before: skill, after: empty }),
-  z29.object({ kind: z29.literal("EDIT_SKILL"), before: skill, after: skill }),
-  z29.object({
-    kind: z29.literal("REWRITE_DOCS"),
-    before: z29.json().optional(),
-    after: z29.object({ pages: webFixtureSchema.shape.pages.unwrap().min(1) }).strict().superRefine(validateFixtureIntervention)
+var interventionSchema = z30.discriminatedUnion("kind", [
+  z30.object({ kind: z30.literal("BASELINE"), after: empty }),
+  z30.object({ kind: z30.literal("ADD_SKILL"), after: skill }),
+  z30.object({ kind: z30.literal("REMOVE_SKILL"), before: skill, after: empty }),
+  z30.object({ kind: z30.literal("EDIT_SKILL"), before: skill, after: skill }),
+  z30.object({
+    kind: z30.literal("REWRITE_DOCS"),
+    before: z30.json().optional(),
+    after: z30.object({ pages: webFixtureSchema.shape.pages.unwrap().min(1) }).strict().superRefine(validateFixtureIntervention)
   }),
-  z29.object({
-    kind: z29.literal("PACKAGE_VERSION"),
-    after: z29.object({
+  z30.object({
+    kind: z30.literal("PACKAGE_VERSION"),
+    after: z30.object({
       ecosystem: ecosystemSchema,
-      name: z29.string().min(1),
-      version: z29.string().min(1)
+      name: z30.string().min(1),
+      version: z30.string().min(1)
     }).strict()
   }),
-  z29.object({
-    kind: z29.literal("PACKAGE_CONTENT"),
-    after: z29.object({
+  z30.object({
+    kind: z30.literal("PACKAGE_CONTENT"),
+    after: z30.object({
       ecosystem: ecosystemSchema,
-      name: z29.string().min(1),
+      name: z30.string().min(1),
       files: overrideFilesSchema
     }).strict()
   }),
-  z29.object({
-    kind: z29.literal("CLI_VERSION"),
-    after: z29.object({ name: z29.string().min(1), version: z29.string().min(1) }).strict()
+  z30.object({
+    kind: z30.literal("CLI_VERSION"),
+    after: z30.object({ name: z30.string().min(1), version: z30.string().min(1) }).strict()
+  }),
+  z30.object({
+    kind: z30.literal("CLI_INTERVENTION"),
+    after: cliInterventionSchema.refine((bundle) => bundle.mode === "trial", {
+      message: "A CLI trial requires a trial-mode bundle"
+    })
   })
 ]);
-var climbSettingsSchema = z29.object({
-  maxRounds: z29.number().int().positive().default(5),
-  sampleCount: z29.number().int().positive().default(1),
-  creditCap: z29.number().int().nonnegative(),
-  targetScore: z29.number().min(0).max(1).default(1),
+var climbSettingsSchema = z30.object({
+  maxRounds: z30.number().int().positive().default(5),
+  sampleCount: z30.number().int().positive().default(1),
+  creditCap: z30.number().int().nonnegative(),
+  targetScore: z30.number().min(0).max(1).default(1),
   // 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: z29.string().optional(),
-  maxTrialsPerRound: z29.number().int().min(1).max(10).default(3),
+  pinnedModel: z30.string().optional(),
+  maxTrialsPerRound: z30.number().int().min(1).max(10).default(3),
   // The round a continuation started at; the no-improvement counter
   // restarts here.
-  continuedAtRound: z29.number().int().nonnegative().optional()
+  continuedAtRound: z30.number().int().nonnegative().optional()
 }).strip().refine((value) => value.pinnedAgent !== void 0 || !value.pinnedModel, {
   path: ["pinnedAgent"],
   message: "Pin an agent with the model"
 });
-var climbDirectionSchema = z29.object({
-  focus: z29.string().trim().max(2e3).nullable().default(null),
-  preserve: z29.array(z29.string().trim().min(1).max(500)).max(20).default([]),
-  exclude: z29.array(z29.string().trim().min(1).max(500)).max(20).default([]),
-  notes: z29.string().trim().max(4e3).nullable().default(null)
-});
-var climbDirectionPatchSchema = z29.object({
-  focus: z29.string().trim().max(2e3).nullable().optional(),
-  preserve: z29.array(z29.string().trim().min(1).max(500)).max(20).optional(),
-  exclude: z29.array(z29.string().trim().min(1).max(500)).max(20).optional(),
-  notes: z29.string().trim().max(4e3).nullable().optional(),
+var climbDirectionSchema = z30.object({
+  focus: z30.string().trim().max(2e3).nullable().default(null),
+  preserve: z30.array(z30.string().trim().min(1).max(500)).max(20).default([]),
+  exclude: z30.array(z30.string().trim().min(1).max(500)).max(20).default([]),
+  notes: z30.string().trim().max(4e3).nullable().default(null)
+});
+var climbDirectionPatchSchema = z30.object({
+  focus: z30.string().trim().max(2e3).nullable().optional(),
+  preserve: z30.array(z30.string().trim().min(1).max(500)).max(20).optional(),
+  exclude: z30.array(z30.string().trim().min(1).max(500)).max(20).optional(),
+  notes: z30.string().trim().max(4e3).nullable().optional(),
   /** One line on why this was recorded; becomes the DIRECTION row summary. */
-  rationale: z29.string().trim().max(500).optional()
+  rationale: z30.string().trim().max(500).optional()
 }).strict();
 var CLIMB_ACTIVITY_KINDS = [
   "STARTED",
@@ -2749,73 +3326,74 @@ var CLIMB_ACTIVITY_KINDS = [
   "CONTINUED",
   "CANCELED"
 ];
-var climbActivityKindSchema = z29.enum(CLIMB_ACTIVITY_KINDS);
-var proposerTraceStepSchema = z29.object({
-  tool: z29.string(),
-  args: z29.string(),
-  result: z29.string().nullable(),
-  isError: z29.boolean().optional()
-});
-var proposerTraceSchema = z29.object({
-  steps: z29.array(proposerTraceStepSchema),
-  reasoning: z29.string(),
-  durationMs: z29.number().int().nonnegative(),
-  model: z29.string()
-});
-var climbActivitySchema = z29.object({
-  id: z29.string(),
-  climbId: z29.string(),
-  roundId: z29.string().nullable(),
-  trialId: z29.string().nullable(),
+var climbActivityKindSchema = z30.enum(CLIMB_ACTIVITY_KINDS);
+var proposerTraceStepSchema = z30.object({
+  tool: z30.string(),
+  args: z30.string(),
+  result: z30.string().nullable(),
+  isError: z30.boolean().optional()
+});
+var proposerTraceSchema = z30.object({
+  steps: z30.array(proposerTraceStepSchema),
+  reasoning: z30.string(),
+  durationMs: z30.number().int().nonnegative(),
+  model: z30.string()
+});
+var climbActivitySchema = z30.object({
+  id: z30.string(),
+  climbId: z30.string(),
+  roundId: z30.string().nullable(),
+  trialId: z30.string().nullable(),
   kind: climbActivityKindSchema,
-  actorUserId: z29.string().nullable(),
-  actorName: z29.string().nullable(),
-  summary: z29.string(),
-  detail: z29.unknown().nullable(),
-  createdAt: z29.string()
-});
-var activityQuerySchema = z29.object({
-  after: z29.string().datetime().optional(),
-  limit: z29.coerce.number().int().min(1).max(500).default(500)
-});
-var climbConfigSnapshotSchema = z29.object({
-  promptText: z29.string(),
-  scenario: z29.enum(["GREENFIELD", "MIGRATION"]),
-  repoUrl: z29.string().nullable(),
-  repoRef: z29.string().nullable(),
-  profileId: z29.string().nullable(),
-  profileName: z29.string().nullable(),
-  profileDescription: z29.string().nullable(),
-  profileModel: z29.string().nullable(),
-  limits: z29.json(),
-  agents: z29.array(agentConfigSchema).min(1),
-  skillRefs: z29.array(z29.string()),
-  mcpRefs: z29.array(z29.string()),
-  skillVersionIds: z29.array(z29.string()),
-  mcpServerVersionIds: z29.array(z29.string()),
-  skillSet: z29.json().nullable(),
-  mcpSet: z29.json().nullable(),
-  connectionIds: z29.array(z29.string()),
-  connectionSet: z29.json().nullable(),
-  agentContext: z29.json().nullable(),
-  agentContextDigest: z29.string().nullable(),
+  actorUserId: z30.string().nullable(),
+  actorName: z30.string().nullable(),
+  summary: z30.string(),
+  detail: z30.unknown().nullable(),
+  createdAt: z30.string()
+});
+var activityQuerySchema = z30.object({
+  after: z30.string().datetime().optional(),
+  limit: z30.coerce.number().int().min(1).max(500).default(500)
+});
+var climbConfigSnapshotSchema = z30.object({
+  promptText: z30.string(),
+  scenario: z30.enum(["GREENFIELD", "MIGRATION"]),
+  repoUrl: z30.string().nullable(),
+  repoRef: z30.string().nullable(),
+  profileId: z30.string().nullable(),
+  profileName: z30.string().nullable(),
+  profileDescription: z30.string().nullable(),
+  profileModel: z30.string().nullable(),
+  limits: z30.json(),
+  agents: z30.array(agentConfigSchema).min(1),
+  skillRefs: z30.array(z30.string()),
+  mcpRefs: z30.array(z30.string()),
+  skillVersionIds: z30.array(z30.string()),
+  mcpServerVersionIds: z30.array(z30.string()),
+  skillSet: z30.json().nullable(),
+  mcpSet: z30.json().nullable(),
+  connectionIds: z30.array(z30.string()),
+  connectionSet: z30.json().nullable(),
+  agentContext: z30.json().nullable(),
+  agentContextDigest: z30.string().nullable(),
   webFixture: webFixtureSchema.nullable(),
+  cliIntervention: cliInterventionSchema.nullable().default(null),
   sandboxOverrides: sandboxOverridesSchema.nullable(),
-  visibilityScenarioId: z29.string().nullable()
+  visibilityScenarioId: z30.string().nullable()
 }).strict();
-var targetRefSchema = z29.object({
-  kind: z29.string().min(1),
-  id: z29.string().optional(),
-  url: z29.url().optional(),
-  package: z29.string().optional()
+var targetRefSchema = z30.object({
+  kind: z30.string().min(1),
+  id: z30.string().optional(),
+  url: z30.url().optional(),
+  package: z30.string().optional()
 }).strict();
-var trialInputSchema = z29.object({
-  title: z29.string().trim().min(1).max(200),
-  hypothesis: z29.string().max(4e3).optional(),
+var trialInputSchema = z30.object({
+  title: z30.string().trim().min(1).max(200),
+  hypothesis: z30.string().max(4e3).optional(),
   lever: leverKindSchema,
   targetRef: targetRefSchema.optional(),
   intervention: interventionSchema,
-  authorMode: z29.enum(["MANUAL", "DIRECT", "PROPOSE"]).default("MANUAL")
+  authorMode: z30.enum(["MANUAL", "DIRECT", "PROPOSE"]).default("MANUAL")
 }).strict().superRefine((value, ctx) => {
   const allowed = LEVER_INTERVENTIONS[value.lever];
   if (!allowed.includes(value.intervention.kind))
@@ -2834,7 +3412,7 @@ var OPTIMIZATION_STATUSES = [
   "DONE",
   "ARCHIVED"
 ];
-var optimizationStatusSchema = z30.enum(OPTIMIZATION_STATUSES);
+var optimizationStatusSchema = z31.enum(OPTIMIZATION_STATUSES);
 var ROUND_STATUSES = [
   "PROPOSING",
   "PROPOSED",
@@ -2863,61 +3441,61 @@ var OPTIMIZATION_EFFORTS = [
   { value: "HIGH", label: "Thorough", sampleCount: 2, maxRounds: 8 },
   { value: "XHIGH", label: "Exhaustive", sampleCount: 3, maxRounds: 12 }
 ];
-var optimizationEffortSchema = z30.enum(
+var optimizationEffortSchema = z31.enum(
   OPTIMIZATION_EFFORTS.map((preset) => preset.value)
 );
-var listOptimizationsQuerySchema = z30.object({
-  status: z30.string().optional().transform(
+var listOptimizationsQuerySchema = z31.object({
+  status: z31.string().optional().transform(
     (value) => value ? value.split(",").map((part) => part.trim().toUpperCase()).filter(Boolean) : void 0
-  ).pipe(z30.array(optimizationStatusSchema).optional()),
+  ).pipe(z31.array(optimizationStatusSchema).optional()),
   subjectKind: climbSubjectKindSchema.optional(),
-  subjectId: z30.string().min(1).optional(),
-  limit: z30.coerce.number().int().min(1).max(200).default(50),
+  subjectId: z31.string().min(1).optional(),
+  limit: z31.coerce.number().int().min(1).max(200).default(50),
   /** Drafts are workspaces, not runs; older clients never see them. */
-  includeDrafts: z30.union([z30.boolean(), z30.string()]).optional().transform((value) => value === true || value === "true" || value === "1")
+  includeDrafts: z31.union([z31.boolean(), z31.string()]).optional().transform((value) => value === true || value === "true" || value === "1")
 });
-var optimizationSummarySchema = z30.object({
-  id: z30.string(),
-  name: z30.string(),
+var optimizationSummarySchema = z31.object({
+  id: z31.string(),
+  name: z31.string(),
   status: optimizationStatusSchema,
-  mode: z30.enum(["MANUAL", "AUTO"]),
+  mode: z31.enum(["MANUAL", "AUTO"]),
   /** Autonomous launches every proposed round; interactive waits for one. */
-  autonomous: z30.boolean(),
-  stopReason: z30.string().nullable(),
+  autonomous: z31.boolean(),
+  stopReason: z31.string().nullable(),
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string(),
-  subjectName: z30.string(),
+  subjectId: z31.string(),
+  subjectName: z31.string(),
   lever: leverKindSchema.nullable(),
-  round: z30.number().int(),
-  maxRounds: z30.number().int(),
+  round: z31.number().int(),
+  maxRounds: z31.number().int(),
   /** Starting baseline score, 0..1. */
-  before: z30.number().nullable(),
+  before: z31.number().nullable(),
   /** Score of the marked winner, or best BETTER trial, 0..1. */
-  after: z30.number().nullable(),
+  after: z31.number().nullable(),
   /** Percentage-point change from the baseline to the winner or best BETTER trial. */
-  delta: z30.number().nullable(),
+  delta: z31.number().nullable(),
   /** Score after each round, baseline first. */
-  path: z30.array(z30.number()),
-  creditsSpent: z30.number().int(),
-  creditsReserved: z30.number().int(),
-  summary: z30.string().nullable(),
-  href: z30.string(),
-  createdAt: z30.string(),
-  updatedAt: z30.string()
-});
-var listOptimizationsResponseSchema = z30.object({
-  items: z30.array(optimizationSummarySchema)
-});
-var targetSchema = z30.object({
+  path: z31.array(z31.number()),
+  creditsSpent: z31.number().int(),
+  creditsReserved: z31.number().int(),
+  summary: z31.string().nullable(),
+  href: z31.string(),
+  createdAt: z31.string(),
+  updatedAt: z31.string()
+});
+var listOptimizationsResponseSchema = z31.object({
+  items: z31.array(optimizationSummarySchema)
+});
+var targetSchema = z31.object({
   agent: schedulableAgentSchema.optional(),
   /** Empty or omitted means the agent's default model. */
-  model: z30.string().optional()
+  model: z31.string().optional()
 });
 var planShape = {
   effort: optimizationEffortSchema.optional(),
-  sampleCount: z30.number().int().min(1).max(100).optional(),
-  maxRounds: z30.number().int().min(1).max(100).optional(),
-  maxTrialsPerRound: z30.number().int().min(1).max(10).optional()
+  sampleCount: z31.number().int().min(1).max(100).optional(),
+  maxRounds: z31.number().int().min(1).max(100).optional(),
+  maxTrialsPerRound: z31.number().int().min(1).max(10).optional()
 };
 function refinePlan(value, ctx) {
   if (value.effort && (value.sampleCount || value.maxRounds))
@@ -2933,18 +3511,18 @@ function refinePlan(value, ctx) {
       message: "Pin an agent with the model"
     });
 }
-var startOptimizationBodySchema = z30.object({
+var startOptimizationBodySchema = z31.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string().min(1),
-  name: z30.string().trim().min(1).max(200).optional(),
+  subjectId: z31.string().min(1),
+  name: z31.string().trim().min(1).max(200).optional(),
   ...planShape,
-  creditCap: z30.number().int().nonnegative().optional(),
-  targetScore: z30.number().min(0).max(1).optional(),
+  creditCap: z31.number().int().nonnegative().optional(),
+  targetScore: z31.number().min(0).max(1).optional(),
   target: targetSchema.extend({ agent: schedulableAgentSchema })
 }).strict().superRefine(refinePlan);
-var estimateOptimizationBodySchema = z30.object({
+var estimateOptimizationBodySchema = z31.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string().min(1),
+  subjectId: z31.string().min(1),
   ...planShape,
   target: targetSchema.optional()
 }).strict().superRefine(refinePlan);
@@ -2956,100 +3534,101 @@ var RUN_CREDIT_BASES = [
   "byok",
   "reserve"
 ];
-var runCreditBasisSchema = z30.enum(RUN_CREDIT_BASES);
-var optimizationEstimateSchema = z30.object({
-  sampleCount: z30.number().int(),
-  maxRounds: z30.number().int(),
-  runsPerTrial: z30.number(),
-  executionCredits: z30.number(),
-  judgeCredits: z30.number(),
-  leverPassCredits: z30.number(),
-  trialCredits: z30.number(),
+var runCreditBasisSchema = z31.enum(RUN_CREDIT_BASES);
+var optimizationEstimateSchema = z31.object({
+  sampleCount: z31.number().int(),
+  maxRounds: z31.number().int(),
+  runsPerTrial: z31.number(),
+  executionCredits: z31.number(),
+  judgeCredits: z31.number(),
+  leverPassCredits: z31.number(),
+  trialCredits: z31.number(),
   /** Estimate, not a reservation or enforced spending cap. */
-  estimate: z30.number().int(),
+  estimate: z31.number().int(),
   /** True when no price or history covered a model: a bound, not a forecast. */
-  approximate: z30.boolean().default(false),
+  approximate: z31.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 = z30.object({
+var diagnoseBodySchema = z31.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string().min(1)
+  subjectId: z31.string().min(1)
 }).strict();
-var diagnosisSchema = z30.object({
-  id: z30.string(),
-  status: z30.enum(["GENERATING", "READY", "FAILED"]),
+var diagnosisSchema = z31.object({
+  id: z31.string(),
+  status: z31.enum(["GENERATING", "READY", "FAILED"]),
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string(),
-  runCount: z30.number().int(),
-  summary: z30.string().nullable(),
+  subjectId: z31.string(),
+  runCount: z31.number().int(),
+  summary: z31.string().nullable(),
   recommendedLever: leverKindSchema.nullable(),
-  recommendedTarget: z30.unknown().nullable(),
-  clusters: z30.array(
-    z30.object({
-      title: z30.string(),
-      failureMode: z30.string(),
-      criterionIds: z30.array(z30.string()),
-      runIds: z30.array(z30.string()),
+  recommendedTarget: z31.unknown().nullable(),
+  clusters: z31.array(
+    z31.object({
+      title: z31.string(),
+      failureMode: z31.string(),
+      criterionIds: z31.array(z31.string()),
+      runIds: z31.array(z31.string()),
       lever: leverKindSchema.nullable(),
-      targetRef: z30.unknown().nullable(),
-      confidence: z30.number()
+      targetRef: z31.unknown().nullable(),
+      confidence: z31.number()
     })
   ),
-  unsupportedLevers: z30.array(leverKindSchema).default([]),
-  createdAt: z30.string()
-});
-var trialRunSchema = z30.object({
-  id: z30.string(),
-  status: z30.string(),
-  passed: z30.boolean().nullable(),
-  criteria: z30.array(
-    z30.object({ name: z30.string(), passed: z30.boolean(), reasoning: z30.string() })
+  unsupportedLevers: z31.array(leverKindSchema).default([]),
+  createdAt: z31.string()
+});
+var trialRunSchema = z31.object({
+  id: z31.string(),
+  status: z31.string(),
+  cliCoverage: cliCoverageSchema.nullable().optional(),
+  passed: z31.boolean().nullable(),
+  criteria: z31.array(
+    z31.object({ name: z31.string(), passed: z31.boolean(), reasoning: z31.string() })
   ),
-  levers: z30.array(
-    z30.object({
-      lever: z30.string(),
-      attributed: z30.boolean(),
-      note: z30.string().nullable()
+  levers: z31.array(
+    z31.object({
+      lever: z31.string(),
+      attributed: z31.boolean(),
+      note: z31.string().nullable()
     })
   )
 });
-var trialSchema = z30.object({
-  id: z30.string(),
-  climbId: z30.string(),
-  roundNumber: z30.number().int(),
-  key: z30.string(),
+var trialSchema = z31.object({
+  id: z31.string(),
+  climbId: z31.string(),
+  roundNumber: z31.number().int(),
+  key: z31.string(),
   /** @deprecated All trials branch from the baseline. */
-  parentTrialId: z30.string().nullable(),
+  parentTrialId: z31.string().nullable(),
   /** @deprecated Always the baseline key for non-baseline trials. */
-  parentKey: z30.string().nullable(),
-  title: z30.string(),
-  hypothesis: z30.string().nullable(),
+  parentKey: z31.string().nullable(),
+  title: z31.string(),
+  hypothesis: z31.string().nullable(),
   lever: leverKindSchema.nullable(),
   kind: interventionKindSchema,
-  status: z30.enum(TRIAL_STATUSES),
-  verdict: z30.enum(TRIAL_VERDICTS).nullable(),
-  score: z30.number().nullable(),
-  baselineScore: z30.number().nullable(),
+  status: z31.enum(TRIAL_STATUSES),
+  verdict: z31.enum(TRIAL_VERDICTS).nullable(),
+  score: z31.number().nullable(),
+  baselineScore: z31.number().nullable(),
   /** Judged sessions behind `score`. */
-  sessions: z30.number().int(),
-  isBaseline: z30.boolean(),
+  sessions: z31.number().int(),
+  isBaseline: z31.boolean(),
   /** The user marked this trial as the winner; it does not move the baseline. */
-  adopted: z30.boolean(),
-  adoptedAt: z30.string().nullable(),
-  outcome: z30.string().nullable(),
+  adopted: z31.boolean(),
+  adoptedAt: z31.string().nullable(),
+  outcome: z31.string().nullable(),
   /** The kind-specific `after` payload (skill version id, pages, package). */
-  after: z30.unknown(),
-  before: z30.unknown(),
-  runs: z30.array(trialRunSchema),
-  createdAt: z30.string()
-});
-var roundSchema = z30.object({
-  id: z30.string(),
-  number: z30.number().int(),
-  status: z30.enum(ROUND_STATUSES),
-  narrative: z30.string().nullable(),
-  trials: z30.array(trialSchema)
+  after: z31.unknown(),
+  before: z31.unknown(),
+  runs: z31.array(trialRunSchema),
+  createdAt: z31.string()
+});
+var roundSchema = z31.object({
+  id: z31.string(),
+  number: z31.number().int(),
+  status: z31.enum(ROUND_STATUSES),
+  narrative: z31.string().nullable(),
+  trials: z31.array(trialSchema)
 });
 var OPTIMIZATION_NEXT_ACTIONS = [
   "START",
@@ -3060,471 +3639,894 @@ var OPTIMIZATION_NEXT_ACTIONS = [
   "RESUME",
   "NONE"
 ];
-var optimizationNextActionSchema = z30.enum(OPTIMIZATION_NEXT_ACTIONS);
+var optimizationNextActionSchema = z31.enum(OPTIMIZATION_NEXT_ACTIONS);
 var optimizationDetailSchema = optimizationSummarySchema.extend({
-  baselineTrialId: z30.string().nullable(),
+  baselineTrialId: z31.string().nullable(),
   /** The one thing a client does next. WAIT and NONE need nobody. */
   nextAction: optimizationNextActionSchema,
-  settings: z30.object({
-    sampleCount: z30.number().int(),
-    maxRounds: z30.number().int(),
-    maxTrialsPerRound: z30.number().int(),
-    creditCap: z30.number().int(),
-    targetScore: z30.number(),
-    pinnedAgent: z30.string().nullable(),
-    pinnedModel: z30.string().nullable(),
-    continuedAtRound: z30.number().int().nullable()
+  settings: z31.object({
+    sampleCount: z31.number().int(),
+    maxRounds: z31.number().int(),
+    maxTrialsPerRound: z31.number().int(),
+    creditCap: z31.number().int(),
+    targetScore: z31.number(),
+    pinnedAgent: z31.string().nullable(),
+    pinnedModel: z31.string().nullable(),
+    continuedAtRound: z31.number().int().nullable()
   }),
   direction: climbDirectionSchema,
-  rounds: z30.array(roundSchema)
+  rounds: z31.array(roundSchema)
 });
-var listTrialsResponseSchema = z30.object({
-  items: z30.array(trialSchema)
+var listTrialsResponseSchema = z31.object({
+  items: z31.array(trialSchema)
 });
-var trialDocumentSchema = z30.object({
-  path: z30.string(),
-  before: z30.string(),
-  after: z30.string()
+var trialDocumentSchema = z31.object({
+  path: z31.string(),
+  before: z31.string(),
+  after: z31.string()
 });
-var trialContentSchema = z30.object({
-  trialId: z30.string(),
+var trialContentSchema = z31.object({
+  trialId: z31.string(),
   kind: interventionKindSchema,
-  documents: z30.array(trialDocumentSchema),
+  documents: z31.array(trialDocumentSchema),
   /** Full page bodies for a docs rewrite, ready to paste; null otherwise. */
-  copyableBody: z30.string().nullable(),
-  configSnapshot: z30.unknown()
+  copyableBody: z31.string().nullable(),
+  configSnapshot: z31.unknown()
 });
-var createTrialBodySchema = z30.object({
+var createTrialBodySchema = z31.object({
   trial: trialInputSchema,
   files: overrideFilesSchema.optional(),
-  fork: z30.object({ runId: z30.string().min(1), boundarySeq: z30.string().min(1) }).strict().optional(),
-  launch: z30.boolean().default(false),
+  fork: z31.object({ runId: z31.string().min(1), boundarySeq: z31.string().min(1) }).strict().optional(),
+  launch: z31.boolean().default(false),
   /** Replays return the trial the first call created instead of a second
    *  one. Scoped to the optimization. */
-  idempotencyKey: z30.string().min(1).max(200).optional()
+  idempotencyKey: z31.string().min(1).max(200).optional()
 }).strict();
-var skillFilesResponseSchema = z30.object({
-  versionId: z30.string(),
+var skillFilesResponseSchema = z31.object({
+  versionId: z31.string(),
   files: overrideFilesSchema
 });
-var pageBodyResponseSchema = z30.object({
-  url: z30.string(),
-  body: z30.string(),
-  contentType: z30.string().optional()
+var pageBodyResponseSchema = z31.object({
+  url: z31.string(),
+  body: z31.string(),
+  contentType: z31.string().optional()
 });
-var launchTrialResponseSchema = z30.object({
-  trialId: z30.string(),
-  batchIds: z30.array(z30.string()),
-  runIds: z30.array(z30.string())
+var launchTrialResponseSchema = z31.object({
+  trialId: z31.string(),
+  batchIds: z31.array(z31.string()),
+  runIds: z31.array(z31.string())
 });
-var createDraftOptimizationBodySchema = z30.object({
+var createDraftOptimizationBodySchema = z31.object({
   subjectKind: climbSubjectKindSchema,
-  subjectId: z30.string().min(1),
-  name: z30.string().trim().min(1).max(200).optional(),
+  subjectId: z31.string().min(1),
+  name: z31.string().trim().min(1).max(200).optional(),
   ...planShape,
   target: targetSchema.optional(),
-  autonomous: z30.boolean().optional()
+  autonomous: z31.boolean().optional()
 }).strict().superRefine(refinePlan);
 var planPatchShape = {
-  name: z30.string().trim().min(1).max(200).optional(),
+  name: z31.string().trim().min(1).max(200).optional(),
   ...planShape,
   target: targetSchema.optional()
 };
-var optimizationPlanPatchSchema = z30.object(planPatchShape).strict().superRefine(refinePlan);
-var startDraftOptimizationBodySchema = z30.object({
+var optimizationPlanPatchSchema = z31.object(planPatchShape).strict().superRefine(refinePlan);
+var startDraftOptimizationBodySchema = z31.object({
   ...planPatchShape,
-  creditCap: z30.number().int().nonnegative().optional()
+  creditCap: z31.number().int().nonnegative().optional()
 }).strict().superRefine(refinePlan);
-var setModeBodySchema = z30.object({ autonomous: z30.boolean() }).strict();
-var launchRoundResponseSchema = z30.object({
-  roundNumber: z30.number().int().nullable(),
-  launched: z30.array(z30.string()),
+var setModeBodySchema = z31.object({ autonomous: z31.boolean() }).strict();
+var launchRoundResponseSchema = z31.object({
+  roundNumber: z31.number().int().nullable(),
+  launched: z31.array(z31.string()),
   /** True when nothing was left to launch: someone else got there first. */
-  alreadyLaunched: z30.boolean()
+  alreadyLaunched: z31.boolean()
 });
-var resolveChatResponseSchema = z30.object({
-  chatId: z30.string(),
-  href: z30.string()
+var resolveChatResponseSchema = z31.object({
+  chatId: z31.string(),
+  href: z31.string()
 });
-var continueOptimizationBodySchema = z30.object({
-  rounds: z30.number().int().min(1).max(20).default(1),
-  maxTrialsPerRound: z30.number().int().min(1).max(10).optional()
+var continueOptimizationBodySchema = z31.object({
+  rounds: z31.number().int().min(1).max(20).default(1),
+  maxTrialsPerRound: z31.number().int().min(1).max(10).optional()
 }).strict();
-var patchOptimizationBodySchema = z30.object({
+var patchOptimizationBodySchema = z31.object({
   ...planPatchShape,
   direction: climbDirectionPatchSchema.optional(),
-  autonomous: z30.boolean().optional()
+  autonomous: z31.boolean().optional()
 }).strict().superRefine(refinePlan);
 
 // ../packages/api-schemas/src/orgs.ts
-import { z as z31 } from "zod";
-var createOrgRequestSchema = z31.object({
+import { z as z32 } from "zod";
+var createOrgRequestSchema = z32.object({
   /** Workspace display name; the slug is derived server-side. */
-  name: z31.string().trim().min(1).max(200),
+  name: z32.string().trim().min(1).max(200),
   /** Optional company site (logo source; stamped onto the org). */
-  website: z31.string().trim().max(300).optional()
+  website: z32.string().trim().max(300).optional()
 });
-var createOrgResponseSchema = z31.object({
-  slug: z31.string(),
-  name: z31.string(),
+var createOrgResponseSchema = z32.object({
+  slug: z32.string(),
+  name: z32.string(),
   // LOCAL orgs never have a Gauge publicId.
-  publicId: z31.string().nullable()
+  publicId: z32.string().nullable()
 });
-var orgSettingsSchema = z31.object({
-  slug: z31.string(),
-  name: z31.string(),
-  publicId: z31.string().nullable(),
-  website: z31.string().nullable(),
+var orgSettingsSchema = z32.object({
+  slug: z32.string(),
+  name: z32.string(),
+  publicId: z32.string().nullable(),
+  website: z32.string().nullable(),
   /** Per-run max-spend override in USD; null = the server default. */
-  maxSpendUsd: z31.number().nullable(),
-  overageEnabled: z31.boolean(),
+  maxSpendUsd: z32.number().nullable(),
+  overageEnabled: z32.boolean(),
   /** Per-cycle overage cap in credits; null = uncapped. */
-  overageCapCredits: z31.number().int().nullable(),
+  overageCapCredits: z32.number().int().nullable(),
   /** Domain claimed for same-domain auto-join; null = off. */
-  autoJoinDomain: z31.string().nullable()
+  autoJoinDomain: z32.string().nullable()
 });
-var orgMemberSchema = z31.object({
-  userId: z31.string(),
-  name: z31.string().nullable(),
-  email: z31.string().nullable(),
-  joinedAt: z31.string()
+var orgMemberSchema = z32.object({
+  userId: z32.string(),
+  name: z32.string().nullable(),
+  email: z32.string().nullable(),
+  joinedAt: z32.string()
 });
-var listMembersResponseSchema = z31.object({
-  items: z31.array(orgMemberSchema)
+var listMembersResponseSchema = z32.object({
+  items: z32.array(orgMemberSchema)
 });
 
 // ../packages/api-schemas/src/personas.ts
-import { z as z32 } from "zod";
-var personaSchema = z32.object({
-  id: z32.string(),
-  name: z32.string(),
-  description: z32.string(),
+import { z as z33 } from "zod";
+var personaSchema = z33.object({
+  id: z33.string(),
+  name: z33.string(),
+  description: z33.string(),
   /** The judge model this persona calls (Claude only). */
-  model: z32.string(),
-  createdAt: z32.string(),
-  updatedAt: z32.string()
+  model: z33.string(),
+  createdAt: z33.string(),
+  updatedAt: z33.string()
 });
-var listPersonasResponseSchema = z32.object({
-  items: z32.array(personaSchema)
+var listPersonasResponseSchema = z33.object({
+  items: z33.array(personaSchema)
 });
-var createPersonaBodySchema = z32.object({
-  name: z32.string().min(1).max(120),
-  description: z32.string().min(1)
+var createPersonaBodySchema = z33.object({
+  name: z33.string().min(1).max(120),
+  description: z33.string().min(1)
 });
-var updatePersonaBodySchema = z32.object({
-  name: z32.string().min(1).max(120).optional(),
-  description: z32.string().min(1).optional()
+var updatePersonaBodySchema = z33.object({
+  name: z33.string().min(1).max(120).optional(),
+  description: z33.string().min(1).optional()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z33 } from "zod";
-var tagSchema = z33.object({
-  id: z33.string(),
-  name: z33.string(),
+import { z as z34 } from "zod";
+var tagSchema = z34.object({
+  id: z34.string(),
+  name: z34.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z33.string()
+  color: z34.string()
 });
-var createTagBodySchema = z33.object({
-  name: z33.string().min(1),
-  color: z33.string().optional()
+var createTagBodySchema = z34.object({
+  name: z34.string().min(1),
+  color: z34.string().optional()
 });
-var updateTagBodySchema = z33.object({
-  name: z33.string().min(1).optional(),
-  color: z33.string().optional()
+var updateTagBodySchema = z34.object({
+  name: z34.string().min(1).optional(),
+  color: z34.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z34 } from "zod";
-var topicSchema = z34.object({
-  id: z34.string(),
-  name: z34.string()
+import { z as z35 } from "zod";
+var topicSchema = z35.object({
+  id: z35.string(),
+  name: z35.string()
 });
-var createTopicBodySchema = z34.object({
-  name: z34.string().min(1, "name is required")
+var createTopicBodySchema = z35.object({
+  name: z35.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
 // ../packages/api-schemas/src/prompts.ts
-var promptSummarySchema = z35.object({
-  id: z35.string(),
-  text: z35.string(),
-  isBranded: z35.boolean(),
+var promptSummarySchema = z36.object({
+  id: z36.string(),
+  text: z36.string(),
+  isBranded: z36.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z35.string().nullable(),
+  externalKey: z36.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z35.array(tagSchema),
-  createdAt: z35.string()
+  tags: z36.array(tagSchema),
+  createdAt: z36.string()
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z35.string().min(1).optional(),
-  tag: z35.string().min(1).optional(),
-  q: z35.string().min(1).optional()
-});
-var createPromptBodySchema = z35.object({
-  text: z35.string().min(1, "text is required"),
-  isBranded: z35.boolean().default(false),
-  topic: z35.string().min(1).optional(),
-  tags: z35.array(z35.string().min(1)).default([])
-});
-var updatePromptBodySchema = z35.object({
-  text: z35.string().min(1).optional(),
-  isBranded: z35.boolean().optional(),
-  topicId: z35.string().min(1).nullish(),
-  tags: z35.array(z35.string().min(1)).optional()
-});
-var runPromptBodySchema = z35.object({
+  topic: z36.string().min(1).optional(),
+  tag: z36.string().min(1).optional(),
+  q: z36.string().min(1).optional()
+});
+var createPromptBodySchema = z36.object({
+  text: z36.string().min(1, "text is required"),
+  isBranded: z36.boolean().default(false),
+  topic: z36.string().min(1).optional(),
+  tags: z36.array(z36.string().min(1)).default([])
+});
+var updatePromptBodySchema = z36.object({
+  text: z36.string().min(1).optional(),
+  isBranded: z36.boolean().optional(),
+  topicId: z36.string().min(1).nullish(),
+  tags: z36.array(z36.string().min(1)).optional()
+});
+var runPromptBodySchema = z36.object({
   /** Preferred paired representation; each agent may pin its own model tiers. */
-  agentConfigs: z35.array(agentConfigInputSchema).min(1).optional(),
+  agentConfigs: z36.array(agentConfigInputSchema).min(1).optional(),
   /** Legacy agent set (no per-agent pins), kept during the API transition. */
-  agents: z35.array(z35.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
-  repoUrl: z35.string().min(1).nullish(),
-  repoRef: z35.string().min(1).nullish(),
-  samplesPerCycle: z35.number().int().min(1).max(10).default(1),
+  agents: z36.array(z36.enum(["CLAUDE_CODE", "CODEX_CLI", "CURSOR"])).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z36.string().min(1).nullish(),
+  repoRef: z36.string().min(1).nullish(),
+  samplesPerCycle: z36.number().int().min(1).max(10).default(1),
   webFixture: webFixtureSchema.optional()
 });
-var runPromptResponseSchema = z35.object({
-  batchIds: z35.array(z35.string()),
-  runIds: z35.array(z35.string()),
-  blocked: z35.enum(["insufficient_credits", "needs_provider_key"]).optional()
+var runPromptResponseSchema = z36.object({
+  batchIds: z36.array(z36.string()),
+  runIds: z36.array(z36.string()),
+  blocked: z36.enum(["insufficient_credits", "needs_provider_key"]).optional()
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z36.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z36.object({
-  url: z36.string(),
-  name: z36.string(),
-  isSystem: z36.boolean(),
-  languages: z36.array(z36.string()),
-  frameworks: z36.array(z36.string()),
+var repoSizeBucketSchema = z37.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z37.object({
+  url: z37.string(),
+  name: z37.string(),
+  isSystem: z37.boolean(),
+  languages: z37.array(z37.string()),
+  frameworks: z37.array(z37.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z36.array(z36.string()),
-  primaryLanguage: z36.string(),
-  sizeKb: z36.number(),
+  tags: z37.array(z37.string()),
+  primaryLanguage: z37.string(),
+  sizeKb: z37.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z36.number()
+  stars: z37.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z36.object({
-  url: z36.string().min(1, "url is required"),
+var addRepoBodySchema = z37.object({
+  url: z37.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: z36.string().min(1).optional(),
+  ref: z37.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z36.string().min(1).optional(),
+  name: z37.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z36.array(z36.string()).optional(),
-  tags: z36.array(z36.string()).optional()
+  frameworks: z37.array(z37.string()).optional(),
+  tags: z37.array(z37.string()).optional()
 });
-var updateRepoBodySchema = z36.object({
-  url: z36.string().min(1, "url is required"),
-  name: z36.string().min(1).optional(),
-  frameworks: z36.array(z36.string()).optional(),
-  tags: z36.array(z36.string()).optional()
+var updateRepoBodySchema = z37.object({
+  url: z37.string().min(1, "url is required"),
+  name: z37.string().min(1).optional(),
+  frameworks: z37.array(z37.string()).optional(),
+  tags: z37.array(z37.string()).optional()
 });
-var resyncRepoBodySchema = z36.object({
-  url: z36.string().min(1, "url is required")
+var resyncRepoBodySchema = z37.object({
+  url: z37.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z36.object({
-  url: z36.string().min(1, "url is required")
+var deleteRepoQuerySchema = z37.object({
+  url: z37.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z36.object({
+var repoSyncResultSchema = z37.object({
   repo: repoSchema,
-  synced: z36.boolean()
+  synced: z37.boolean()
+});
+
+// ../packages/api-schemas/src/runAddons.ts
+import { z as z38 } from "zod";
+var runAddonsSchema = z38.object({
+  browser: z38.object({
+    session: z38.string().min(1),
+    projectId: z38.number().int().positive(),
+    region: z38.literal("us").default("us")
+  }).strict().optional()
+}).strict();
+
+// ../packages/api-schemas/src/runDefinitions.ts
+import { z as z40 } from "zod";
+
+// ../packages/api-schemas/src/runPlan.ts
+import { z as z39 } from "zod";
+var runPlanCriterionSchema = z39.object({
+  id: z39.string().min(1),
+  name: z39.string(),
+  rubric: z39.string()
+});
+var criteriaSnapshotV1Schema = z39.object({
+  version: z39.literal(1),
+  // File-authored criteria have no saved EvalSet; their identity is frozen
+  // in the request and result rows retain the criterion text without an FK.
+  evalSetId: z39.string().min(1).nullable(),
+  criteria: z39.array(runPlanCriterionSchema)
+});
+var runPlanCaseSchema = z39.object({
+  id: z39.string().min(1),
+  prompt: z39.object({ id: z39.string().min(1), text: z39.string() }),
+  workspace: z39.object({
+    repoUrl: z39.string().nullable(),
+    repoRef: z39.string().nullable()
+  }),
+  agents: z39.array(
+    agentConfigSchema.extend({
+      // Validated against the current catalog request schema when lowered.
+      catalogSelections: z39.record(z39.string(), z39.unknown()).optional()
+    })
+  ),
+  samples: z39.number().int().min(1).max(50),
+  evalSetId: z39.string().min(1).optional(),
+  criteriaSnapshot: criteriaSnapshotV1Schema.optional(),
+  sourceRepoCommit: z39.string().nullable().optional(),
+  experiment: z39.string().nullable().optional(),
+  membershipTagIds: z39.array(z39.string()).optional(),
+  profile: z39.object({
+    id: z39.string(),
+    name: z39.string(),
+    description: z39.string(),
+    model: z39.string()
+  }).nullable().optional(),
+  skillSet: skillSetSchema.optional(),
+  mcpSet: mcpSetSchema.optional(),
+  connectionSet: connectionSetSchema.optional(),
+  // The server's agentContextSnapshotV1Schema validates this at lowering.
+  agentContext: z39.unknown().optional(),
+  agentContextDigest: z39.string().nullable().optional(),
+  addons: runAddonsSchema.optional(),
+  /** Names of resources the coordinator must prepare before expansion. */
+  inputs: z39.array(z39.string().min(1)).default([])
+});
+var builtDirectoryResourceSchema = z39.object({
+  name: z39.string().min(1),
+  type: z39.literal("built-directory"),
+  source: z39.object({
+    type: z39.literal("git-checkout"),
+    repoUrl: z39.string().min(1),
+    commit: z39.string().regex(/^[a-f0-9]{40}$/i)
+  }),
+  build: z39.object({
+    runtime: z39.literal("node-24"),
+    run: z39.string().min(1),
+    output: z39.string().min(1),
+    /** Declared command name plus args, invoked from a clean cwd before a session. */
+    smoke: z39.array(z39.string().min(1)).min(1)
+  }),
+  expose: z39.object({
+    type: z39.literal("command"),
+    commands: z39.record(z39.string().min(1), z39.array(z39.string().min(1)).min(1))
+  })
+}).superRefine((resource, ctx) => {
+  if (!(resource.build.smoke[0] in resource.expose.commands))
+    ctx.addIssue({
+      code: "custom",
+      path: ["build", "smoke", 0],
+      message: "Smoke command must name an exposed command"
+    });
+});
+var bundleRelativeScriptSchema = z39.string().min(1).refine(
+  (path2) => !path2.startsWith("/") && !path2.includes("\\") && !path2.includes("\0") && !path2.split("/").includes("..") && path2.split("/").some((part) => part !== "" && part !== "."),
+  "Install script must be a bundle-relative path without traversal"
+);
+var preparedDirectoryPrepareSchema = z39.union([
+  z39.object({ run: z39.string().min(1) }).strict(),
+  z39.object({
+    type: z39.literal("npm-cli"),
+    build: z39.string().min(1).optional()
+  }).strict()
+]);
+var preparedDirectoryResourceSchema = z39.object({
+  name: z39.string().min(1),
+  type: z39.literal("prepared-directory"),
+  source: z39.object({
+    type: z39.literal("git-checkout"),
+    repoUrl: z39.string().min(1),
+    commit: z39.string().regex(/^[a-f0-9]{40}$/i)
+  }).strict(),
+  prepare: preparedDirectoryPrepareSchema,
+  install: bundleRelativeScriptSchema.optional()
+}).strict().superRefine((resource, ctx) => {
+  if ("type" in resource.prepare && resource.install)
+    ctx.addIssue({
+      code: "custom",
+      path: ["install"],
+      message: "npm-cli products cannot declare an install script"
+    });
+});
+var runPlanResourceSchema = z39.union([
+  builtDirectoryResourceSchema,
+  preparedDirectoryResourceSchema
+]);
+var runPlanSchema = z39.object({
+  version: z39.literal(1),
+  /** Existing launches keep their current measurement semantics. */
+  measurementMode: z39.enum(["EXISTING", "AGENT_EXPERIENCE"]),
+  cases: z39.array(runPlanCaseSchema).min(1),
+  resources: z39.array(runPlanResourceSchema).default([]),
+  /** Server-populated context retained across deferred preparation. */
+  launch: z39.object({
+    origin: z39.discriminatedUnion("initiator", [
+      z39.object({
+        initiator: z39.literal("API"),
+        userId: z39.string().min(1),
+        email: z39.string().nullable()
+      }).strict(),
+      z39.object({
+        initiator: z39.literal("GITHUB"),
+        userId: z39.null(),
+        email: z39.null()
+      }).strict()
+    ]),
+    funding: z39.enum(["ORG", "PLATFORM"]),
+    queueClass: z39.literal("INTERACTIVE")
+  }).strict().optional(),
+  provenance: z39.object({
+    definition: z39.object({
+      repoUrl: z39.string().min(1),
+      commit: z39.string().regex(/^[a-f0-9]{40}$/i),
+      digest: z39.string().min(1),
+      /** File submissions are asserted by the caller until server-side
+       * committed-byte fetching is available. */
+      verification: z39.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"]).optional()
+    }).optional(),
+    liveDependencies: z39.array(
+      z39.object({
+        name: z39.string().min(1),
+        url: z39.string().url().optional()
+      })
+    ).default([])
+  })
+}).superRefine((plan, ctx) => {
+  const resourceNames = new Set(
+    plan.resources.map((resource) => resource.name)
+  );
+  for (const [index, item] of plan.cases.entries()) {
+    if (plan.measurementMode === "AGENT_EXPERIENCE" && !item.agents.length)
+      ctx.addIssue({
+        code: "custom",
+        path: ["cases", index, "agents"],
+        message: "Agent Experience cases require a selected agent"
+      });
+    if (plan.measurementMode === "AGENT_EXPERIENCE" && !item.criteriaSnapshot?.criteria.length)
+      ctx.addIssue({
+        code: "custom",
+        path: ["cases", index, "criteriaSnapshot"],
+        message: "Agent Experience cases require criteria"
+      });
+    if (item.criteriaSnapshot && item.criteriaSnapshot.evalSetId !== (item.evalSetId ?? null))
+      ctx.addIssue({
+        code: "custom",
+        path: ["cases", index, "criteriaSnapshot", "evalSetId"],
+        message: "Criteria snapshot must belong to the case's eval"
+      });
+    for (const input of item.inputs) {
+      if (!resourceNames.has(input))
+        ctx.addIssue({
+          code: "custom",
+          path: ["cases", index, "inputs"],
+          message: `Unknown resource: ${input}`
+        });
+    }
+  }
+  if (new Set(plan.cases.map((item) => item.id)).size !== plan.cases.length)
+    ctx.addIssue({
+      code: "custom",
+      path: ["cases"],
+      message: "Case ids must be unique"
+    });
+  if (resourceNames.size !== plan.resources.length)
+    ctx.addIssue({
+      code: "custom",
+      path: ["resources"],
+      message: "Resource names must be unique"
+    });
+});
+
+// ../packages/api-schemas/src/runDefinitions.ts
+var uncredentialedRepoUrlSchema = z40.string().min(1).refine((raw) => {
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return true;
+  try {
+    const url = new URL(raw);
+    return (url.protocol === "ssh:" || !url.username) && !url.password && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}, "Repository URL must not contain embedded credentials or query parameters");
+var runDefinitionConfigSchema = z40.object({
+  agents: z40.array(agentConfigInputSchema).min(1),
+  sampleCount: z40.number().int().min(1).max(50).optional(),
+  repoUrl: uncredentialedRepoUrlSchema.nullable().optional(),
+  repoRef: z40.string().min(1).nullable().optional(),
+  profileId: z40.string().min(1).nullable().optional(),
+  skillRefs: assetRefListSchema.optional(),
+  mcpRefs: assetRefListSchema.optional(),
+  connectionIds: z40.array(z40.string().min(1)).max(32).optional(),
+  addons: runAddonsSchema.optional()
+}).strict();
+var githubCasePathSchema = z40.string().regex(
+  /^evals\/[A-Za-z0-9_./-]+\.md$/,
+  "Expected an explicit evals/*.md path"
+).refine(
+  (path2) => path2.split("/").every((part) => part !== "" && part !== "." && part !== ".."),
+  "Case path must not contain traversal or empty segments"
+);
+var runDefinitionFileConfigSchema = z40.object({
+  version: z40.literal(1).default(1),
+  org: z40.string().min(1).optional(),
+  product: z40.object({
+    type: z40.literal("npm-cli"),
+    build: z40.string().min(1).optional()
+  }).strict().optional(),
+  prepare: z40.string().min(1).optional(),
+  install: bundleRelativeScriptSchema.optional(),
+  github: z40.object({
+    enabled: z40.literal(true),
+    files: z40.array(githubCasePathSchema).min(1).max(20).refine(
+      (paths) => new Set(paths).size === paths.length,
+      "Case paths must be unique"
+    )
+  }).strict().optional()
+}).strict().superRefine((config, ctx) => {
+  if (config.product && config.prepare)
+    ctx.addIssue({
+      code: "custom",
+      path: ["product"],
+      message: "product and prepare are alternatives"
+    });
+  if (config.product && config.install)
+    ctx.addIssue({
+      code: "custom",
+      path: ["install"],
+      message: "npm-cli products cannot declare an install script"
+    });
+});
+var runDefinitionCriterionSchema = z40.object({ name: z40.string().min(1), rubric: z40.string().min(1) }).strict();
+var runDefinitionFrontmatterSchema = z40.object({
+  criteria: z40.array(runDefinitionCriterionSchema).min(1),
+  config: runDefinitionConfigSchema
+}).strict();
+var runDefinitionCaseSchema = z40.object({
+  path: z40.string().min(1),
+  prompt: z40.string().min(1),
+  criteria: z40.array(runDefinitionCriterionSchema).min(1),
+  config: runDefinitionConfigSchema
+}).strict();
+var runDefinitionSubmissionSchema = z40.object({
+  version: z40.literal(1),
+  source: z40.object({
+    repoUrl: uncredentialedRepoUrlSchema,
+    commit: z40.string().regex(/^[a-f0-9]{40}$/i),
+    digest: z40.string().regex(/^sha256:[a-f0-9]{64}$/),
+    verification: z40.enum(["SUBMITTED_UNVERIFIED", "GITHUB_VERIFIED"])
+  }).strict(),
+  resources: z40.array(preparedDirectoryResourceSchema).max(1).default([]),
+  cases: z40.array(runDefinitionCaseSchema).min(1)
+}).strict().superRefine((definition, ctx) => {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [index, item] of definition.cases.entries()) {
+    if (paths.has(item.path))
+      ctx.addIssue({
+        code: "custom",
+        path: ["cases", index, "path"],
+        message: "Case paths must be unique"
+      });
+    paths.add(item.path);
+  }
+  for (const [index, resource] of definition.resources.entries()) {
+    if (resource.name !== "project")
+      ctx.addIssue({
+        code: "custom",
+        path: ["resources", index, "name"],
+        message: "The project preparation must use the reserved name project"
+      });
+    if (resource.source.repoUrl !== definition.source.repoUrl || resource.source.commit !== definition.source.commit)
+      ctx.addIssue({
+        code: "custom",
+        path: ["resources", index, "source"],
+        message: "Project preparation must use the definition repository and commit"
+      });
+    if (!resource.source.repoUrl.startsWith("https://"))
+      ctx.addIssue({
+        code: "custom",
+        path: ["resources", index, "source", "repoUrl"],
+        message: "Project preparation requires a public HTTPS Git source"
+      });
+    if (!uncredentialedRepoUrlSchema.safeParse(resource.source.repoUrl).success)
+      ctx.addIssue({
+        code: "custom",
+        path: ["resources", index, "source", "repoUrl"],
+        message: "Repository URL must not contain embedded credentials or query parameters"
+      });
+  }
+});
+var runDefinitionPublicSubmissionSchema = runDefinitionSubmissionSchema.refine(
+  (definition) => definition.source.verification === "SUBMITTED_UNVERIFIED",
+  {
+    path: ["source", "verification"],
+    message: "Only the GitHub App may verify committed bytes"
+  }
+);
+var runDefinitionPlanResponseSchema = z40.object({
+  source: runDefinitionSubmissionSchema.shape.source,
+  measurementMode: z40.literal("AGENT_EXPERIENCE"),
+  cases: z40.array(
+    z40.object({
+      path: z40.string(),
+      agents: z40.array(agentConfigSchema),
+      samples: z40.number().int().nonnegative(),
+      expectedRuns: z40.number().int().nonnegative(),
+      workspace: z40.object({
+        repoUrl: z40.string().nullable(),
+        repoRef: z40.string().nullable()
+      }),
+      criteriaCount: z40.number().int().nonnegative(),
+      inputs: z40.array(z40.string())
+    })
+  ),
+  resources: z40.array(
+    z40.object({ name: z40.string(), type: z40.literal("prepared-directory") })
+  ),
+  expectedRuns: z40.number().int().nonnegative(),
+  canRun: z40.boolean()
+});
+var runDefinitionRunResponseSchema = z40.object({
+  runRequestId: z40.string(),
+  batchIds: z40.array(z40.string()),
+  runIds: z40.array(z40.string()),
+  requestedRuns: z40.number().int().nonnegative(),
+  createdRuns: z40.number().int().nonnegative(),
+  aggregateUrl: z40.string()
+});
+
+// ../packages/api-schemas/src/runRequests.ts
+import { z as z41 } from "zod";
+var runRequestStatusSchema = z41.enum([
+  "PENDING",
+  "PREPARING",
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELED"
+]);
+var runRequestResultSchema = z41.enum([
+  "PENDING",
+  "PASSED",
+  "QUALITY_FAILED",
+  "EXECUTION_FAILED",
+  "PREPARATION_FAILED",
+  "JUDGE_FAILED",
+  "INCOMPLETE",
+  "CANCELED"
+]);
+var runRequestCriterionResultSchema = z41.object({
+  criterionId: z41.string().nullable(),
+  name: z41.string(),
+  passed: z41.boolean(),
+  reasoning: z41.string().nullable()
+});
+var runRequestRunSchema = z41.object({
+  id: z41.string(),
+  batchId: z41.string(),
+  status: z41.string(),
+  agent: agentSchema,
+  model: z41.string(),
+  result: runRequestResultSchema,
+  judge: z41.object({ status: z41.string() }).nullable(),
+  criterionResults: z41.array(runRequestCriterionResultSchema)
+});
+var runRequestResponseSchema = z41.object({
+  id: z41.string(),
+  status: runRequestStatusSchema,
+  result: runRequestResultSchema,
+  settled: z41.boolean(),
+  counts: z41.object({
+    requestedRuns: z41.number().int().nonnegative(),
+    createdRuns: z41.number().int().nonnegative(),
+    terminalRuns: z41.number().int().nonnegative(),
+    judgedRuns: z41.number().int().nonnegative(),
+    passedRuns: z41.number().int().nonnegative(),
+    qualityFailedRuns: z41.number().int().nonnegative(),
+    executionFailedRuns: z41.number().int().nonnegative(),
+    judgeFailedRuns: z41.number().int().nonnegative(),
+    pendingRuns: z41.number().int().nonnegative()
+  }),
+  batches: z41.array(
+    z41.object({ id: z41.string(), runs: z41.array(runRequestRunSchema) })
+  ),
+  createdAt: z41.string(),
+  updatedAt: z41.string(),
+  finishedAt: z41.string().nullable()
 });
 
 // ../packages/api-schemas/src/summary.ts
-import { z as z37 } from "zod";
+import { z as z42 } from "zod";
 function cardResultSchema(data) {
-  return z37.union([
-    z37.object({ ok: z37.literal(true), data }),
-    z37.object({ ok: z37.literal(false), error: z37.string() })
+  return z42.union([
+    z42.object({ ok: z42.literal(true), data }),
+    z42.object({ ok: z42.literal(false), error: z42.string() })
   ]);
 }
-var summaryActionSchema = z37.object({
-  id: z37.string(),
-  title: z37.string(),
-  priority: z37.string(),
-  status: z37.string(),
-  evidenceCount: z37.number().int()
-});
-var summaryAeCardSchema = z37.object({
-  id: z37.string(),
-  name: z37.string(),
-  judgedRuns: z37.number().int(),
-  passRate: z37.number().nullable(),
+var summaryActionSchema = z42.object({
+  id: z42.string(),
+  title: z42.string(),
+  priority: z42.string(),
+  status: z42.string(),
+  evidenceCount: z42.number().int()
+});
+var summaryAeCardSchema = z42.object({
+  id: z42.string(),
+  name: z42.string(),
+  judgedRuns: z42.number().int(),
+  passRate: z42.number().nullable(),
   /** pp delta vs the prior 30d; null with no prior. */
-  deltaPP: z37.number().nullable()
-});
-var summaryVisibilityCardSchema = z37.object({
-  name: z37.string(),
-  owned: z37.object({
-    name: z37.string(),
-    rank: z37.number(),
-    chosenRate: z37.number(),
-    mentionRate: z37.number()
+  deltaPP: z42.number().nullable()
+});
+var summaryVisibilityCardSchema = z42.object({
+  name: z42.string(),
+  owned: z42.object({
+    name: z42.string(),
+    rank: z42.number(),
+    chosenRate: z42.number(),
+    mentionRate: z42.number()
   }).nullable(),
-  chosenDeltaPP: z37.number().nullable()
+  chosenDeltaPP: z42.number().nullable()
 });
-var homeSummarySchema = z37.object({
-  hasAnyRuns: z37.boolean(),
-  lastSynthesisAt: z37.string().nullable(),
-  actions: cardResultSchema(z37.array(summaryActionSchema)),
+var homeSummarySchema = z42.object({
+  hasAnyRuns: z42.boolean(),
+  lastSynthesisAt: z42.string().nullable(),
+  actions: cardResultSchema(z42.array(summaryActionSchema)),
   visibility: cardResultSchema(
-    z37.object({
-      cards: z37.array(summaryVisibilityCardSchema),
-      marketsTotal: z37.number().int(),
-      promptCount: z37.number().int()
+    z42.object({
+      cards: z42.array(summaryVisibilityCardSchema),
+      marketsTotal: z42.number().int(),
+      promptCount: z42.number().int()
     })
   ),
   agentExperience: cardResultSchema(
-    z37.object({
-      cards: z37.array(summaryAeCardSchema),
-      total: z37.number().int(),
-      setCount: z37.number().int()
+    z42.object({
+      cards: z42.array(summaryAeCardSchema),
+      total: z42.number().int(),
+      setCount: z42.number().int()
     })
   ),
-  notableSessions: cardResultSchema(z37.array(z37.unknown()))
+  notableSessions: cardResultSchema(z42.array(z42.unknown()))
 });
 
 // ../packages/api-schemas/src/tokens.ts
-import { z as z38 } from "zod";
-var apiTokenSchema = z38.object({
-  id: z38.string(),
-  name: z38.string(),
+import { z as z43 } from "zod";
+var apiTokenSchema = z43.object({
+  id: z43.string(),
+  name: z43.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z38.string(),
-  expiresAt: z38.iso.datetime().nullable(),
-  lastUsedAt: z38.iso.datetime().nullable(),
-  createdAt: z38.iso.datetime(),
-  revokedAt: z38.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z38.object({
-  name: z38.string().min(1).max(100),
+  last4: z43.string(),
+  expiresAt: z43.iso.datetime().nullable(),
+  lastUsedAt: z43.iso.datetime().nullable(),
+  createdAt: z43.iso.datetime(),
+  revokedAt: z43.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z43.object({
+  name: z43.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z38.iso.datetime({ offset: true }).optional()
+  expiresAt: z43.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z38.string()
+  token: z43.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
 // ../packages/api-schemas/src/visibility.ts
-import { z as z39 } from "zod";
+import { z as z44 } from "zod";
 var VISIBILITY_PROMPT_KINDS = ["HEAD_TO_HEAD", "RECOMMEND"];
-var visibilityPromptKindSchema = z39.enum(VISIBILITY_PROMPT_KINDS);
+var visibilityPromptKindSchema = z44.enum(VISIBILITY_PROMPT_KINDS);
 var visibilityPromptSchema = visibilityPromptSettingsSchema.extend({
-  id: z39.string(),
-  name: z39.string(),
+  id: z44.string(),
+  name: z44.string(),
   kind: visibilityPromptKindSchema,
-  promptText: z39.string(),
+  promptText: z44.string(),
   /** HEAD_TO_HEAD is always branded; RECOMMEND may be either. */
-  branded: z39.boolean(),
-  brandA: z39.string().nullable(),
-  brandB: z39.string().nullable(),
-  market: z39.object({ id: z39.string(), slug: z39.string(), name: z39.string() }).nullable(),
-  position: z39.number().int(),
-  createdAt: z39.string(),
+  branded: z44.boolean(),
+  brandA: z44.string().nullable(),
+  brandB: z44.string().nullable(),
+  market: z44.object({ id: z44.string(), slug: z44.string(), name: z44.string() }).nullable(),
+  position: z44.number().int(),
+  createdAt: z44.string(),
   /** User tag names on the hidden backing prompt (Surface:* excluded). */
-  tags: z39.array(z39.string()),
-  runCount: z39.number().int(),
-  lastRunAt: z39.string().nullable(),
-  scenarios: z39.array(visibilityScenarioSchema)
+  tags: z44.array(z44.string()),
+  runCount: z44.number().int(),
+  lastRunAt: z44.string().nullable(),
+  scenarios: z44.array(visibilityScenarioSchema)
 });
-var listVisibilityPromptsResponseSchema = z39.object({
-  items: z39.array(visibilityPromptSchema)
+var listVisibilityPromptsResponseSchema = z44.object({
+  items: z44.array(visibilityPromptSchema)
 });
-var createVisibilityPromptBodySchema = z39.object({
-  name: z39.string().min(1),
-  promptText: z39.string().min(1),
+var createVisibilityPromptBodySchema = z44.object({
+  name: z44.string().min(1),
+  promptText: z44.string().min(1),
   kind: visibilityPromptKindSchema,
-  branded: z39.boolean().optional(),
+  branded: z44.boolean().optional(),
   /** Required pair for HEAD_TO_HEAD (order-independent). */
-  brandA: z39.string().nullish(),
-  brandB: z39.string().nullish(),
+  brandA: z44.string().nullish(),
+  brandB: z44.string().nullish(),
   /** Measured market id from the org's tracked set. */
-  marketId: z39.string().nullish(),
-  tags: z39.array(z39.string()).optional(),
+  marketId: z44.string().nullish(),
+  tags: z44.array(z44.string()).optional(),
   agents: visibilityPromptSettingsInputShape.agents.optional(),
   skillRefs: visibilityPromptSettingsInputShape.skillRefs,
   mcpRefs: visibilityPromptSettingsInputShape.mcpRefs,
   connectionIds: visibilityPromptSettingsInputShape.connectionIds,
   cadence: visibilityPromptSettingsInputShape.cadence,
   sampleCount: visibilityPromptSettingsInputShape.sampleCount,
-  scenarios: z39.array(visibilityScenarioInputSchema).optional().default([])
+  scenarios: z44.array(visibilityScenarioInputSchema).optional().default([])
 }).strict();
-var synthesizeResponseSchema = z39.object({
+var synthesizeResponseSchema = z44.object({
   /** False when the pre-check found no new evidence and nothing was queued. */
-  queued: z39.boolean()
-});
-var updateVisibilityPromptBodySchema = z39.object({
-  name: z39.string().min(1).optional(),
-  promptText: z39.string().min(1).optional(),
-  branded: z39.boolean().optional(),
-  brandA: z39.string().nullish(),
-  brandB: z39.string().nullish(),
-  marketId: z39.string().nullish(),
-  tags: z39.array(z39.string()).optional(),
+  queued: z44.boolean()
+});
+var updateVisibilityPromptBodySchema = z44.object({
+  name: z44.string().min(1).optional(),
+  promptText: z44.string().min(1).optional(),
+  branded: z44.boolean().optional(),
+  brandA: z44.string().nullish(),
+  brandB: z44.string().nullish(),
+  marketId: z44.string().nullish(),
+  tags: z44.array(z44.string()).optional(),
   ...visibilityPromptSettingsPatchShape,
   /** Replaces the whole scenario set when present. */
-  scenarios: z39.array(visibilityScenarioInputSchema).optional()
+  scenarios: z44.array(visibilityScenarioInputSchema).optional()
 }).strict();
-var runVisibilityPromptResponseSchema = z39.object({
-  batchIds: z39.array(z39.string()),
-  runIds: z39.array(z39.string())
+var runVisibilityPromptResponseSchema = z44.object({
+  batchIds: z44.array(z44.string()),
+  runIds: z44.array(z44.string())
 });
-var visibilityPromptRunSchema = z39.object({
-  id: z39.string(),
-  status: z39.string(),
+var visibilityPromptRunSchema = z44.object({
+  id: z44.string(),
+  status: z44.string(),
   agent: agentSchema,
-  model: z39.string().nullable(),
-  resolvedModel: z39.string().nullable(),
-  createdAt: z39.string(),
-  startedAt: z39.string().nullable(),
-  finishedAt: z39.string().nullable(),
-  failureReason: z39.string().nullable(),
-  verdict: z39.object({
-    status: z39.string(),
-    error: z39.string().nullable(),
-    payload: z39.unknown().nullable()
+  model: z44.string().nullable(),
+  resolvedModel: z44.string().nullable(),
+  createdAt: z44.string(),
+  startedAt: z44.string().nullable(),
+  finishedAt: z44.string().nullable(),
+  failureReason: z44.string().nullable(),
+  verdict: z44.object({
+    status: z44.string(),
+    error: z44.string().nullable(),
+    payload: z44.unknown().nullable()
   }).nullable()
 });
-var listVisibilityPromptRunsResponseSchema = z39.object({
-  items: z39.array(visibilityPromptRunSchema)
+var listVisibilityPromptRunsResponseSchema = z44.object({
+  items: z44.array(visibilityPromptRunSchema)
 });
-var orgMarketSchema = z39.object({
-  marketId: z39.string(),
-  slug: z39.string(),
-  name: z39.string(),
+var orgMarketSchema = z44.object({
+  marketId: z44.string(),
+  slug: z44.string(),
+  name: z44.string(),
   /** The one line saying what the market measures. */
-  capability: z39.string(),
+  capability: z44.string(),
   /** SUGGESTED (the matcher) | USER (a human picked it). */
-  source: z39.string()
+  source: z44.string()
 });
 var addableMarketSchema = orgMarketSchema.omit({ source: true });
-var listMarketsResponseSchema = z39.object({
-  tracked: z39.array(orgMarketSchema),
+var listMarketsResponseSchema = z44.object({
+  tracked: z44.array(orgMarketSchema),
   /** Published markets the org does not track yet (closed set — no free-text
    *  market creation). */
-  addable: z39.array(addableMarketSchema)
+  addable: z44.array(addableMarketSchema)
 });
-var addMarketBodySchema = z39.object({ marketId: z39.string().min(1) });
+var addMarketBodySchema = z44.object({ marketId: z44.string().min(1) });
 
 // src/version.ts
 import { createRequire } from "module";
@@ -3592,9 +4594,9 @@ function resolveToken() {
     return null;
   }
 }
-function saveToken(token) {
+function saveToken(token2) {
   mkdirSync2(configDir(), { recursive: true, mode: 448 });
-  writeFileSync2(credentialsPath(), `${token.trim()}
+  writeFileSync2(credentialsPath(), `${token2.trim()}
 `, {
     encoding: "utf8",
     mode: 384
@@ -3804,9 +4806,10 @@ function messageOf(error) {
 }
 
 // src/lib/context.ts
-function resolveOrg(command) {
+function resolveOrg(command, fileOrg) {
   const { org } = command.optsWithGlobals();
   if (org) return org;
+  if (fileOrg) return fileOrg;
   const { defaultOrg } = readConfig();
   if (defaultOrg) return defaultOrg;
   throw new CliError(
@@ -3908,7 +4911,7 @@ __export(apply_exports, {
   register: () => register2
 });
 import { readFileSync as readFileSync3 } from "fs";
-import { z as z40 } from "zod";
+import { z as z45 } from "zod";
 function assertRequiredExperiment(spec, required) {
   if (required.length === 0) {
     throw new CliError(
@@ -4060,7 +5063,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(z40.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z45.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -4172,7 +5175,7 @@ async function browserLogin() {
   const codeVerifier = randomBytes(32).toString("base64url");
   const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
   const server = createServer();
-  const codePromise = new Promise((resolve, reject) => {
+  const codePromise = new Promise((resolve2, reject) => {
     server.on("request", (req, res) => {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");
       if (url.pathname !== "/callback") {
@@ -4195,15 +5198,15 @@ async function browserLogin() {
         "content-type": "text/plain; charset=utf-8"
       });
       res.end("Authorized. Return to your terminal.");
-      resolve(code);
+      resolve2(code);
     });
     server.on(
       "error",
       (e) => reject(new CliError("network", `Loopback listener failed: ${e.message}`))
     );
   });
-  await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", resolve);
+  await new Promise((resolve2) => {
+    server.listen(0, "127.0.0.1", resolve2);
   });
   const address = server.address();
   if (!address || typeof address === "string") {
@@ -4254,9 +5257,9 @@ async function browserLogin() {
       );
     }
     const exchange = parsed.data;
-    const token = exchange.accessToken;
-    const me = await fetchMe(new ApiClient({ token }));
-    saveToken(token);
+    const token2 = exchange.accessToken;
+    const me = await fetchMe(new ApiClient({ token: token2 }));
+    saveToken(token2);
     console.log(`Token saved to ${credentialsPath()}`);
     printIdentity(me);
   } finally {
@@ -4360,10 +5363,10 @@ async function deviceLogin(opts) {
           "The sign-in request expired before it was approved. Re-run it to try again."
         );
       case "approved": {
-        const token = result.accessToken;
+        const token2 = result.accessToken;
         try {
-          const me = await fetchMe(new ApiClient({ token }));
-          return { token, me };
+          const me = await fetchMe(new ApiClient({ token: token2 }));
+          return { token: token2, me };
         } catch (e) {
           throw new CliError(
             "network",
@@ -4400,15 +5403,15 @@ async function withTokenLogin() {
   if (process.stdin.isTTY) {
     console.error("Paste your API token, then press Enter:");
   }
-  const token = (await readStdin()).trim();
-  if (!token.startsWith(TOKEN_PREFIX)) {
+  const token2 = (await readStdin()).trim();
+  if (!token2.startsWith(TOKEN_PREFIX)) {
     throw new CliError(
       "usage",
       `Expected a token starting with ${TOKEN_PREFIX} on stdin`
     );
   }
-  const me = await fetchMe(new ApiClient({ token }));
-  saveToken(token);
+  const me = await fetchMe(new ApiClient({ token: token2 }));
+  saveToken(token2);
   console.log(`Token saved to ${credentialsPath()}`);
   printIdentity(me);
 }
@@ -4476,8 +5479,8 @@ function register3(program2) {
         throw new CliError("usage", "--email requires --device.");
       }
       if (opts.device) {
-        const { token, me } = await deviceLogin({ email: opts.email });
-        saveToken(token);
+        const { token: token2, me } = await deviceLogin({ email: opts.email });
+        saveToken(token2);
         console.log(`Token saved to ${credentialsPath()}`);
         printIdentity(me);
       } else if (opts.withToken) {
@@ -4832,10 +5835,10 @@ function splitList(raw) {
   return raw.split(",").map((v) => v.trim()).filter(Boolean);
 }
 function parsePackage(raw) {
-  const sep2 = raw.lastIndexOf(":");
-  if (sep2 === -1) return { name: raw.trim(), ecosystem: null };
-  const name = raw.slice(0, sep2).trim();
-  const ecosystem = raw.slice(sep2 + 1).trim();
+  const sep3 = raw.lastIndexOf(":");
+  if (sep3 === -1) return { name: raw.trim(), ecosystem: null };
+  const name = raw.slice(0, sep3).trim();
+  const ecosystem = raw.slice(sep3 + 1).trim();
   if (!name) throw new CliError("usage", `Invalid package "${raw}"`);
   if (!ECOSYSTEMS.includes(ecosystem)) {
     throw new CliError(
@@ -4971,7 +5974,7 @@ async function waitForCanary(id) {
   while (true) {
     const canary = await client.get(`${path}/${id}`);
     if (terminal.has(canary.status)) return canary;
-    await new Promise((resolve) => setTimeout(resolve, 1e4));
+    await new Promise((resolve2) => setTimeout(resolve2, 1e4));
   }
 }
 function register7(program2, opts = {}) {
@@ -5204,7 +6207,7 @@ async function confirmOrAbort(question, yes) {
   }
   const rl = createInterface2({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
-    (resolve) => rl.question(`${question} [y/N] `, resolve)
+    (resolve2) => rl.question(`${question} [y/N] `, resolve2)
   );
   rl.close();
   if (!/^y(es)?$/i.test(answer.trim())) {
@@ -5212,11 +6215,6 @@ async function confirmOrAbort(question, yes) {
   }
 }
 
-// src/lib/staff.ts
-function staffCommandsVisible(config = readConfig()) {
-  return config.staff === true;
-}
-
 // src/lib/ownedConfig.ts
 function parseCadence(raw) {
   const cadence = (raw ?? "NONE").trim().toUpperCase();
@@ -5406,6 +6404,202 @@ function cadenceLabel(cadence) {
   return cadence === "NONE" ? "manual" : cadence.toLowerCase();
 }
 
+// src/lib/runDefinitionFiles.ts
+import { execFileSync } from "child_process";
+import { isAbsolute, relative, resolve, sep } from "path";
+
+// ../packages/api-schemas/src/compileRunDefinition.ts
+import { createHash as createHash2 } from "crypto";
+import { parseDocument } from "yaml";
+function utf8(bytes, path2) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error(`${path2} is not UTF-8 text`);
+  }
+}
+function markdownCase(path2, bytes) {
+  const source = utf8(bytes, path2);
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(source);
+  if (!match)
+    throw new Error(`${path2}: expected YAML frontmatter between --- lines`);
+  const document = parseDocument(match[1], { uniqueKeys: true });
+  if (document.errors.length)
+    throw new Error(
+      `${path2}: ${document.errors.map((error) => error.message).join("; ")}`
+    );
+  const parsed = runDefinitionFrontmatterSchema.safeParse(document.toJS());
+  if (!parsed.success) throw new Error(`${path2}: ${parsed.error.message}`);
+  const prompt = match[2].trim();
+  if (!prompt) throw new Error(`${path2}: Markdown body is empty`);
+  return { path: path2, prompt, ...parsed.data };
+}
+function compileRunDefinitionFromBlobs(input) {
+  if (!uncredentialedRepoUrlSchema.safeParse(input.repoUrl).success)
+    throw new Error("Git origin must not contain embedded credentials");
+  if (!/^[a-f0-9]{40}$/i.test(input.commit))
+    throw new Error("Expected a full Git commit SHA");
+  if (input.casePaths.length === 0)
+    throw new Error("At least one Markdown case is required");
+  if (new Set(input.casePaths).size !== input.casePaths.length)
+    throw new Error("Case paths must be unique");
+  const configBytes = input.blobs.get("gauge.json");
+  let config;
+  if (configBytes) {
+    try {
+      config = runDefinitionFileConfigSchema.parse(
+        JSON.parse(utf8(configBytes, "gauge.json"))
+      );
+    } catch (error) {
+      throw new Error(
+        `gauge.json: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+  const conventionalPrepare = input.blobs.has(".gauge/prepare.sh");
+  if (config?.product && conventionalPrepare)
+    throw new Error(
+      "gauge.json: product and .gauge/prepare.sh are alternatives"
+    );
+  const prepare = config?.prepare ?? (conventionalPrepare ? "bash .gauge/prepare.sh" : void 0);
+  const preparation = config?.product ?? (prepare ? { run: prepare } : void 0);
+  if (config?.install && !prepare)
+    throw new Error("gauge.json: install requires prepare");
+  if (preparation && !input.repoUrl.startsWith("https://"))
+    throw new Error("Project preparation requires a public HTTPS Git origin");
+  const cases = input.casePaths.map((path2) => {
+    const bytes = input.blobs.get(path2);
+    if (!path2.endsWith(".md") || !bytes)
+      throw new Error(`Missing committed Markdown case: ${path2}`);
+    return markdownCase(path2, bytes);
+  });
+  const hash = createHash2("sha256");
+  hash.update("gauge-run-definition-v1\0");
+  for (const [path2, bytes] of [...input.blobs.entries()].sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    hash.update(path2);
+    hash.update("\0");
+    hash.update(String(bytes.length));
+    hash.update("\0");
+    hash.update(bytes);
+    hash.update("\0");
+  }
+  const submission = runDefinitionSubmissionSchema.parse({
+    version: 1,
+    source: {
+      repoUrl: input.repoUrl,
+      commit: input.commit,
+      digest: `sha256:${hash.digest("hex")}`,
+      verification: input.verification
+    },
+    resources: preparation ? [
+      {
+        name: "project",
+        type: "prepared-directory",
+        source: {
+          type: "git-checkout",
+          repoUrl: input.repoUrl,
+          commit: input.commit
+        },
+        prepare: preparation,
+        ...config?.install ? { install: config.install } : {}
+      }
+    ] : [],
+    cases
+  });
+  return { definition: submission, org: config?.org, github: config?.github };
+}
+
+// src/lib/runDefinitionFiles.ts
+function git(cwd, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd,
+      encoding: "buffer",
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const detail = error && typeof error === "object" && "stderr" in error ? String(error.stderr).trim() : String(error);
+    throw new CliError("usage", `git ${args[0]} failed: ${detail}`);
+  }
+}
+function committedBlob(root, commit, path2) {
+  return git(root, ["show", `${commit}:${path2}`]);
+}
+function relativeGitPath(root, cwd, input) {
+  if (!input || input.includes("\0") || /[*?[\]{}]/.test(input))
+    throw new CliError("usage", `expected an explicit case path: ${input}`);
+  const absolute = resolve(cwd, input);
+  const path2 = relative(root, absolute);
+  if (!path2 || path2 === ".." || path2.startsWith(`..${sep}`) || isAbsolute(path2))
+    throw new CliError(
+      "usage",
+      `case path is outside this Git repository: ${input}`
+    );
+  const gitPath = path2.split(sep).join("/");
+  if (!gitPath.endsWith(".md"))
+    throw new CliError("usage", `case path must end in .md: ${input}`);
+  return gitPath;
+}
+function loadCommittedRunDefinitionWithContext(files, cwd = process.cwd()) {
+  if (files.length === 0)
+    throw new CliError("usage", "--files requires at least one Markdown path");
+  const root = git(cwd, ["rev-parse", "--show-toplevel"]).toString("utf8").trim();
+  const commit = git(root, ["rev-parse", "--verify", "HEAD^{commit}"]).toString("utf8").trim();
+  let repoUrl;
+  try {
+    repoUrl = git(root, ["remote", "get-url", "origin"]).toString("utf8").trim();
+  } catch {
+    throw new CliError(
+      "usage",
+      "Git origin is required to identify the committed definition repository"
+    );
+  }
+  if (!uncredentialedRepoUrlSchema.safeParse(repoUrl).success)
+    throw new CliError(
+      "usage",
+      "Git origin must be a repository URL without embedded credentials or query parameters"
+    );
+  const paths = files.map((file) => relativeGitPath(root, cwd, file));
+  if (new Set(paths).size !== paths.length)
+    throw new CliError("usage", "case paths must be unique");
+  const blobs = /* @__PURE__ */ new Map();
+  const hasConfig = git(root, ["ls-tree", "--name-only", commit, "--", "gauge.json"]).toString("utf8").trim() === "gauge.json";
+  if (hasConfig) {
+    blobs.set("gauge.json", committedBlob(root, commit, "gauge.json"));
+  }
+  const hasConventionalPrepare = git(root, ["ls-tree", "--name-only", commit, "--", ".gauge/prepare.sh"]).toString("utf8").trim() === ".gauge/prepare.sh";
+  if (hasConventionalPrepare) {
+    blobs.set(
+      ".gauge/prepare.sh",
+      committedBlob(root, commit, ".gauge/prepare.sh")
+    );
+  }
+  for (const path2 of paths) blobs.set(path2, committedBlob(root, commit, path2));
+  try {
+    const result = compileRunDefinitionFromBlobs({
+      repoUrl,
+      commit,
+      casePaths: paths,
+      blobs,
+      verification: "SUBMITTED_UNVERIFIED"
+    });
+    return { definition: result.definition, org: result.org };
+  } catch (error) {
+    throw new CliError(
+      "usage",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+
+// src/lib/staff.ts
+function staffCommandsVisible(config = readConfig()) {
+  return config.staff === true;
+}
+
 // src/commands/evals.ts
 function evalSetsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/eval-sets`;
@@ -5484,6 +6678,40 @@ function printDetail2(e) {
 }
 function register11(program2) {
   const group = program2.command("evals").description("Manage eval sets (judged agent-experience measurements)");
+  group.command("plan").description(
+    "Validate committed Markdown cases and preview a Git-native run"
+  ).requiredOption("--files <paths...>", "explicit committed Markdown paths").action(async (opts, cmd) => {
+    const { definition, org: fileOrg } = loadCommittedRunDefinitionWithContext(opts.files);
+    const org = resolveOrg(cmd, fileOrg);
+    const result = await createClient().post(
+      `/api/v1/orgs/${encodeURIComponent(org)}/run-definitions/plan`,
+      definition
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(result);
+      return;
+    }
+    console.log(
+      `Definition: ${result.source.commit} (${result.source.digest})`
+    );
+    console.log(
+      "Provenance: submitted by CLI; server has not verified Git bytes"
+    );
+    console.log(`Expected sessions: ${result.expectedRuns}`);
+    for (const item of result.cases)
+      console.log(
+        `  ${item.path}: ${item.expectedRuns} sessions, ${item.criteriaCount} criteria`
+      );
+    if (result.resources.length) {
+      console.log(
+        `Preparations: ${result.resources.map((r) => r.name).join(", ")}`
+      );
+      if (!result.canRun)
+        console.log(
+          "Resource-backed runs cannot launch until preparation is available."
+        );
+    }
+  });
   group.command("list").description("List the org's eval sets with pass-rate stats").option(
     "--agents <agents>",
     "filter stats to these agents, e.g. claude-code,codex"
@@ -5603,15 +6831,40 @@ function register11(program2) {
     );
     if (resolveOutput(cmd) !== "json") console.log(`Deleted eval set ${id}`);
   });
-  group.command("run <id>").description(
+  group.command("run [id]").description(
     staffCommandsVisible() ? "Run an eval set now with its stored configuration (superusers run without billing the org by default)" : "Run an eval set now with its stored configuration"
   ).addOption(
     new Option2(
       "--bill-to-org",
       "bill this run to the org's credits instead (superusers)"
     ).hideHelp(!staffCommandsVisible())
-  ).option("--yes", "skip the confirmation").action(
+  ).option("--files <paths...>", "explicit committed Markdown paths").option("--yes", "skip the confirmation").action(
     async (id, opts, cmd) => {
+      if (opts.files !== void 0) {
+        if (id !== void 0)
+          throw new CliError(
+            "usage",
+            "pass either an eval ID or --files, not both"
+          );
+        const { definition, org: fileOrg } = loadCommittedRunDefinitionWithContext(opts.files);
+        const org2 = resolveOrg(cmd, fileOrg);
+        await confirmOrAbort("Run these committed eval cases now?", opts.yes);
+        const result2 = await createClient().post(
+          `/api/v1/orgs/${encodeURIComponent(org2)}/run-definitions/run`,
+          definition,
+          opts.billToOrg ? { billToOrg: true } : void 0
+        );
+        if (resolveOutput(cmd) === "json") printJson(result2);
+        else {
+          console.log(
+            `Started ${result2.createdRuns}/${result2.requestedRuns} sessions in request ${result2.runRequestId}`
+          );
+          console.log(`Wait: gauge run-requests wait ${result2.runRequestId}`);
+        }
+        return;
+      }
+      if (id === void 0)
+        throw new CliError("usage", "pass an eval ID or --files <paths...>");
       const org = resolveOrg(cmd);
       await confirmOrAbort(
         "Run this eval's stored configuration now?",
@@ -5707,7 +6960,7 @@ function rewriteContentType(path2, explicit) {
   return REWRITE_FILE_CONTENT_TYPES[extname(path2).toLowerCase()];
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function toRow3(e) {
   return {
@@ -6716,10 +7969,11 @@ __export(optimizations_exports2, {
   readSkillDir: () => readSkillDir,
   register: () => register19,
   trialBodyFromOpts: () => trialBodyFromOpts,
-  trialTemplate: () => trialTemplate
+  trialTemplate: () => trialTemplate,
+  watchStops: () => watchStops
 });
 import { readdirSync, readFileSync as readFileSync9, statSync } from "fs";
-import { join as join4, relative, sep } from "path";
+import { join as join4, relative as relative2, sep as sep2 } from "path";
 var TERMINAL2 = /* @__PURE__ */ new Set(["DONE", "ARCHIVED"]);
 var EFFORTS = ["low", "medium", "high", "xhigh"];
 function basePath(org) {
@@ -6735,7 +7989,7 @@ function readText2(path2) {
   return readFileSync9(path2 === "-" ? 0 : path2, "utf8");
 }
 function sleep3(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function parseSubject(opts) {
   if (opts.eval && opts.preference)
@@ -6788,11 +8042,14 @@ var NEXT_ACTION_HINT = {
   LAUNCH_ROUND: "launch the saved round: `gauge optimizations launch <id>`",
   ADOPT: "adopt the winning trial: `gauge optimizations adopt <id> <trial>`",
   RESUME: "resume it: `gauge optimizations resume <id>`",
-  NONE: "finished"
+  NONE: "nothing to do in Gauge"
 };
 function awaitingInput(detail) {
   return detail.nextAction !== "WAIT" && detail.nextAction !== "NONE";
 }
+function watchStops(detail, follow) {
+  return TERMINAL2.has(detail.status) || detail.nextAction === "NONE" || !follow && awaitingInput(detail);
+}
 function readObject(path2) {
   let value;
   try {
@@ -6834,7 +8091,7 @@ function readSkillDir(dir, read = readText2, walk = listFiles) {
   if (!paths.length)
     throw new CliError("usage", `no files under ${dir} to send`);
   const files = paths.map((path2) => ({
-    path: relative(dir, path2).split(sep).join("/"),
+    path: relative2(dir, path2).split(sep2).join("/"),
     body: read(path2)
   }));
   if (!files.some((file) => file.path === "SKILL.md"))
@@ -7092,6 +8349,18 @@ function printChange(content) {
     console.log(doc.after || "(empty)");
   }
 }
+function printRoundPreview(preview) {
+  for (const trial of preview.trials) {
+    console.log(trial.title);
+    for (const change of trial.changes ?? []) {
+      console.log(`=== ${change.path}`);
+      console.log(change.hunks);
+    }
+    for (const path2 of trial.droppedFiles ?? [])
+      console.log(`  ${path2}: dropped`);
+  }
+  console.log(`previewDigest ${preview.previewDigest}`);
+}
 function printEstimate(e) {
   console.log(
     `plan:      ${e.sampleCount} session${e.sampleCount === 1 ? "" : "s"} per trial \xD7 up to ${e.maxRounds} rounds`
@@ -7467,14 +8736,14 @@ function register19(program2) {
       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} credits spent \xB7 ${trials2.filter((t) => t.status === "RUNNING").map((t) => t.key).join(",") || "idle"}`;
+        const trials2 = detail.rounds.flatMap((round2) => round2.trials);
+        const line = `${detail.status}${detail.stopReason ? ` (${detail.stopReason})` : ""} \xB7 round ${detail.round}/${detail.maxRounds} \xB7 ${pct(detail.before)} \u2192 ${pct(detail.after)} \xB7 ${detail.creditsSpent} credits spent \xB7 ${trials2.filter((t) => t.status === "RUNNING").map((t) => t.key).join(",") || "idle"}`;
         if (line !== last) {
           last = line;
           console.error(line);
         }
         const needsInput = awaitingInput(detail);
-        if (TERMINAL2.has(detail.status) || !opts.follow && needsInput) {
+        if (watchStops(detail, !!opts.follow)) {
           if (resolveOutput(cmd) === "json") printJson(detail);
           else printDetail4(detail);
           if (needsInput) process.exitCode = NEEDS_INPUT_EXIT;
@@ -7484,6 +8753,60 @@ function register19(program2) {
       }
     }
   );
+  group.command("authoring <id>").description(
+    "What the next round may change: kinds, CLI targets and commands, baseline invocations, revision"
+  ).action(async (id, _opts, cmd) => {
+    printJson(
+      await createClient().get(`${itemPath2(resolveOrg(cmd), id)}/authoring`)
+    );
+  });
+  group.command("invocation <id> <invocationId>").description(
+    "One baseline CLI invocation from `authoring`, with its recorded command evidence"
+  ).action(
+    async (id, invocationId, _opts, cmd) => {
+      printJson(
+        await createClient().get(
+          `${itemPath2(resolveOrg(cmd), id)}/authoring/target`,
+          { cliInvocationId: invocationId }
+        )
+      );
+    }
+  );
+  group.command("cli-change <id>").description(
+    "Build a CLI_INTERVENTION bundle from {targetId, commandId, selector, operations, shippingIntent}; use the output as intervention.after in a round file. Saves nothing"
+  ).requiredOption("--file <path>", "the change JSON; '-' for stdin").action(async (id, opts, cmd) => {
+    printJson(
+      await createClient().post(
+        `${itemPath2(resolveOrg(cmd), id)}/cli-changes`,
+        readObject(opts.file)
+      )
+    );
+  });
+  const round = group.command("round").description(
+    "Preview and save the round waiting to launch. A round file is {revision, trials: [{trial: {title, hypothesis, lever, intervention}, files?}]}; revision comes from `authoring`"
+  );
+  round.command("preview <id>").description("Validate a round file and print its diff and previewDigest").requiredOption("--file <path>", "the round JSON; '-' for stdin").action(async (id, opts, cmd) => {
+    const preview = await createClient().post(
+      `${itemPath2(resolveOrg(cmd), id)}/rounds/current/preview`,
+      readObject(opts.file)
+    );
+    if (resolveOutput(cmd) === "json") printJson(preview);
+    else printRoundPreview(preview);
+  });
+  round.command("save <id>").description(
+    "Save a previewed round as drafts, replacing every pending draft. Never launches"
+  ).requiredOption("--file <path>", "the round JSON you previewed").requiredOption("--digest <digest>", "previewDigest from `round preview`").action(
+    async (id, opts, cmd) => {
+      const result = await createClient().put(
+        `${itemPath2(resolveOrg(cmd), id)}/rounds/current`,
+        { ...readObject(opts.file), previewDigest: opts.digest }
+      );
+      if (resolveOutput(cmd) === "json") printJson(result);
+      else
+        for (const trial of result.trials)
+          console.log(`Saved ${trial.key} "${trial.title}"`);
+    }
+  );
   const trials = group.command("trials").description("List, author, and run trials");
   trials.command("list <id>").description("Every trial of an optimization with score and verdict").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -7555,6 +8878,16 @@ function register19(program2) {
         );
     }
   );
+  trials.command("remove <id> <trialId>").description("Drop one draft trial from the round waiting to launch").option("--yes", "skip the confirmation").action(
+    async (id, trialId, opts, cmd) => {
+      await confirmOrAbort(`Remove draft ${trialId} from ${id}?`, opts.yes);
+      const detail = await createClient().delete(
+        trialPath(resolveOrg(cmd), id, trialId)
+      );
+      if (resolveOutput(cmd) === "json") printJson(detail);
+      else console.log(`Removed ${trialId}.`);
+    }
+  );
   group.command("trial <id> <trialId>").description("One trial by id or key (B0, R1.1, \u2026) with its sessions").action(
     async (id, trialId, _opts, cmd) => {
       const org = resolveOrg(cmd);
@@ -8159,10 +9492,48 @@ function register24(program2) {
   });
 }
 
+// src/commands/runRequests.ts
+var runRequests_exports2 = {};
+__export(runRequests_exports2, {
+  register: () => register25
+});
+var pollIntervalMs = 5e3;
+function register25(program2) {
+  program2.command("run-requests").description("Read a durable launch and its aggregate verdict").command("wait <id>").description("Wait for all sessions and judging in a launch request").action(async (id, _opts, cmd) => {
+    const org = resolveOrg(cmd);
+    const path2 = `/api/v1/orgs/${encodeURIComponent(org)}/run-requests/${encodeURIComponent(id)}`;
+    const client = createClient();
+    let lastStatus = "";
+    while (true) {
+      const result = await client.get(path2);
+      if (resolveOutput(cmd) !== "json" && result.status !== lastStatus) {
+        console.error(`Run request ${id}: ${result.status}`);
+        lastStatus = result.status;
+      }
+      if (result.settled) {
+        if (resolveOutput(cmd) === "json") printJson(result);
+        else {
+          console.log(
+            `${result.result}: ${result.counts.passedRuns}/${result.counts.createdRuns} passed sessions (${result.counts.judgedRuns} judged)`
+          );
+          console.log(`Request: ${result.id}`);
+        }
+        if (result.result !== "PASSED")
+          throw new CliError(
+            "internal",
+            `Run request ${id}: ${result.result}`
+          );
+        return;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    }
+  });
+}
+
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register25
+  register: () => register26
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -8422,7 +9793,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register25(program2) {
+function register26(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) => {
@@ -8561,7 +9932,7 @@ function register25(program2) {
 var skills_exports2 = {};
 __export(skills_exports2, {
   buildSkillEditBody: () => buildSkillEditBody,
-  register: () => register26
+  register: () => register27
 });
 function skillsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/skills`;
@@ -8623,7 +9994,7 @@ async function buildSkillEditBody(opts, fetchCurrentSource) {
     throw new CliError("usage", "nothing to change");
   return body;
 }
-function register26(program2) {
+function register27(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);
@@ -8764,7 +10135,7 @@ function register26(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register27
+  register: () => register28
 });
 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)");
@@ -8847,7 +10218,7 @@ var domainRow = (r) => ({
   rate: pct3(r.rate),
   requests: r.requests
 });
-function register27(program2) {
+function register28(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -8879,7 +10250,7 @@ function register27(program2) {
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
-  register: () => register28
+  register: () => register29
 });
 function pct4(rate) {
   return rate == null ? "\u2014" : `${Math.round(rate * 100)}%`;
@@ -8889,7 +10260,7 @@ function delta2(pp) {
   const rounded = Math.round(pp);
   return rounded === 0 ? "" : ` (${rounded > 0 ? "+" : ""}${rounded}pp)`;
 }
-function register28(program2) {
+function register29(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(
@@ -8951,12 +10322,12 @@ function register28(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register29
+  register: () => register30
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register29(program2) {
+function register30(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -8999,9 +10370,9 @@ function register29(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register30
+  register: () => register31
 });
-function register30(program2) {
+function register31(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);
@@ -9048,7 +10419,7 @@ function register30(program2) {
 // src/commands/visibility.ts
 var visibility_exports2 = {};
 __export(visibility_exports2, {
-  register: () => register31,
+  register: () => register32,
   visibilityPath: () => visibilityPath
 });
 import { Option as Option3 } from "commander";
@@ -9404,7 +10775,7 @@ function registerPreferenceGroup(group) {
     );
   });
 }
-function register31(program2) {
+function register32(program2) {
   const preference = program2.command("preference").description("Manage Agent Preference prompts and measured markets");
   registerPreferenceGroup(preference);
   const legacy = program2.command("visibility", { hidden: true });
@@ -9438,6 +10809,7 @@ for (const group of [
   connections_exports2,
   repos_exports2,
   runs_exports2,
+  runRequests_exports2,
   optimizations_exports2,
   experiments_exports2,
   apply_exports,