@moda-ai/cli 1.55.26 → 1.55.28

package/dist/{production-intelligence-7n83c701.js → production-intelligence-wvsgjxth.js}

@@ -1,6 +1,12 @@
 import {
-  INTELLIGENCE_SCHEMA_VERSION
-} from "./cli-bb7133m7.js";
+  INTELLIGENCE_SCHEMA_VERSION,
+  asNumber,
+  asRecord,
+  asString,
+  contextTarget,
+  frustrationAnchorIndex,
+  frustrationsFromEmotions
+} from "./cli-fwpqghgc.js";
 import {
   renderMarkdownForTerminal,
   shouldColorTerminalOutput,
@@ -10,26 +16,23 @@ import {
 import {
   callControlAPI,
   callDataAPI
-} from "./cli-jtyvbd8d.js";
+} from "./cli-e23g9ywa.js";
 import {
-  CliAuthError,
-  CliInputError,
   EXIT_DEGRADED,
   EXIT_OK,
-  apiErrorStatus,
   apiKeyHeaders,
-  asNumber,
-  asRecord,
-  asString,
-  contextTarget,
-  frustrationAnchorIndex,
-  frustrationsFromEmotions,
   recordApiRequest,
   resolveApiKey,
   resolveModaBaseUrl,
   safeWriteStderr,
-  shellWord
-} from "./cli-sqsjd08w.js";
+  shellArg
+} from "./cli-99p2jh28.js";
+import {
+  CliAuthError,
+  CliInputError,
+  apiErrorStatus
+} from "./cli-k4tqwah4.js";
+import"./cli-ns5fcnkz.js";
 import"./cli-0v6na3yp.js";
 
 // src/production-intelligence.ts
@@ -538,7 +541,7 @@ async function investigateProduction(options) {
     warnings.push(`No failures found for tool "${options.toolName}" in the last ${options.daysBack} day(s) — the tool may have no failures in this window, or the name may not exist in this tenant. ` + "Run `moda detections tools` to list tools with recorded failures, or widen --days-back.");
   }
   if (options.conversationId) {
-    warnings.push(`Scoped to trace ${options.conversationId} for frustration evidence only; overview and tool failures are tenant-wide. ` + `Open the trace itself with \`moda traces spans ${options.conversationId}\`.`);
+    warnings.push(`Scoped to trace ${options.conversationId} for frustration evidence only; overview and tool failures are tenant-wide. ` + `Open the trace itself with \`moda traces spans ${shellArg(options.conversationId)}\`.`);
   }
   const evidenceRefs = [];
   const findings = [];
@@ -872,7 +875,7 @@ function toolFailureFindings(data, daysBack, hints, evidenceRefs, scopedTool) {
         id: `action_tool_detail_${slug(name)}`,
         title: `Inspect ${name} failure examples.`,
         rationale: "Examples include trace anchors and error subtypes.",
-        command: `moda detections tools ${name} --days-back=${daysBack} --include-window`,
+        command: `moda detections tools ${shellArg(name)} --days-back=${daysBack} --include-window`,
         mutability: "read",
         requiresApproval: false
       }]
@@ -918,7 +921,7 @@ function frustrationFindings(data, daysBack, evidenceRefs) {
       id: "action_frustration_window",
       title: "Read the frustration window.",
       rationale: "The user quote and nearby turns reveal what confused or blocked the user.",
-      command: conversationId ? `moda traces get ${shellWord(contextTarget(conversationId))}${anchorIndex !== null ? ` --msg-index=${anchorIndex}` : ""} --window=3` : `moda detections list --family=frustration --days-back=${daysBack} --include-window`,
+      command: conversationId ? `moda traces get ${shellArg(contextTarget(conversationId))}${anchorIndex !== null ? ` --msg-index=${anchorIndex}` : ""} --window=3` : `moda detections list --family=frustration --days-back=${daysBack} --include-window`,
       mutability: "read",
       requiresApproval: false
     }]
@@ -994,7 +997,7 @@ function problemFindings(data, daysBack, evidenceRefs) {
         id: `action_problem_${slug(problem.id)}`,
         title: `Open the Problem dossier for ${problem.name}.`,
         rationale: "The dossier has the cause, evidence, affected traces and verification state.",
-        command: `moda problems get ${problem.id}`,
+        command: `moda problems get ${shellArg(problem.id)}`,
         mutability: "read",
         requiresApproval: false
       }]

package/dist/{profile-commands-ct2t0bfr.js → profile-commands-h8evz9x0.js}

@@ -2,7 +2,7 @@ import {
   probeApiKey,
   redactApiKey,
   resolveApiKeyCredential
-} from "./cli-1mbb0ct0.js";
+} from "./cli-97jew729.js";
 import {
   authFetch,
   clearAuthSession,
@@ -10,9 +10,8 @@ import {
   loadAuthSession,
   login,
   revokeCliSessionToken
-} from "./cli-q6f6vrrr.js";
+} from "./cli-9bgnvth2.js";
 import {
-  CliInputError,
   DEFAULT_INGEST_URL,
   EXIT_AUTH_REQUIRED,
   EXIT_DEGRADED,
@@ -34,8 +33,13 @@ import {
   saveCliConfig,
   secretFilePathFromRef,
   setActiveProfile,
+  shellArg,
   upsertProfile
-} from "./cli-sqsjd08w.js";
+} from "./cli-99p2jh28.js";
+import {
+  CliInputError
+} from "./cli-k4tqwah4.js";
+import"./cli-ns5fcnkz.js";
 import"./cli-0v6na3yp.js";
 
 // src/profile-commands.ts
@@ -326,7 +330,7 @@ async function runProfilesCommand(context) {
         default_profile: config.active_profile,
         profiles: Object.values(config.profiles).map((profile) => serializeProfile(profile, effective)),
         migrations: config.migrations
-      }, missing ? { warnings: [`The active profile '${effective}' (from ${source}) does not exist. Create it with \`moda profiles create ${effective}\` or select an existing profile.`] } : undefined);
+      }, missing ? { warnings: [`The active profile '${effective}' (from ${source}) does not exist. Create it with \`moda profiles create ${shellArg(effective)}\` or select an existing profile.`] } : undefined);
       return { exitCode: 0 };
     }
     case "use": {

package/dist/prompt-attribution-1nytc9wj.js

@@ -0,0 +1,148 @@
+import {
+  inventoryFiles,
+  safePromptEvidencePath
+} from "./cli-3n0gz4d0.js";
+import"./cli-xq45etg1.js";
+import"./cli-97fnztpy.js";
+import"./cli-cesds766.js";
+import {
+  require_typescript
+} from "./cli-qpq84eee.js";
+import"./cli-dr6x0zv7.js";
+import"./cli-n2hng3gv.js";
+import"./cli-e23g9ywa.js";
+import"./cli-99p2jh28.js";
+import"./cli-k4tqwah4.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/prompt-attribution.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import { dirname, extname, resolve } from "node:path";
+function checkPromptAttribution(rootDir, keys) {
+  const result = { references: [], coverage: "partial", issues: [] };
+  const known = new Set(keys), lock = resolve(rootDir, ".moda/prompts.lock.json");
+  let files;
+  try {
+    files = inventoryFiles(rootDir, []);
+  } catch (error) {
+    result.issues.push({ path: ".", reason: `Attribution scan incomplete: ${error instanceof Error ? error.message : String(error)}` });
+    return result;
+  }
+  for (const file of files) {
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(extname(file.path)) || !file.text?.includes("prompts.lock.json"))
+      continue;
+    if (/(^|\/)(?:tests?|__tests__|fixtures?)(\/|$)|\.(?:test|spec)\.[^.]+$/.test(file.path))
+      continue;
+    try {
+      const absolute = safePromptEvidencePath(rootDir, file.path);
+      const program = import_typescript.default.createProgram([absolute], { noResolve: true, noLib: true, types: [], allowJs: true });
+      const sf = program.getSourceFile(absolute);
+      if (!sf || program.getSyntacticDiagnostics(sf).length) {
+        result.issues.push({ path: file.path, reason: "Attribution source could not be parsed" });
+        continue;
+      }
+      const checker = program.getTypeChecker();
+      const declaration = (node) => {
+        const all = checker.getSymbolAtLocation(node)?.declarations;
+        return all?.length === 1 ? all[0] : undefined;
+      };
+      const imported = (node) => {
+        if (import_typescript.default.isImportSpecifier(node) && node.isTypeOnly)
+          return false;
+        let parent = node;
+        while (parent && !import_typescript.default.isImportDeclaration(parent))
+          parent = parent.parent;
+        return !!parent && import_typescript.default.isImportDeclaration(parent) && !parent.importClause?.isTypeOnly && import_typescript.default.isStringLiteral(parent.moduleSpecifier) && parent.moduleSpecifier.text.startsWith(".") && resolve(dirname(absolute), parent.moduleSpecifier.text) === lock;
+      };
+      const initializer = (node) => {
+        const decl = declaration(node);
+        return decl && import_typescript.default.isVariableDeclaration(decl) && import_typescript.default.isVariableDeclarationList(decl.parent) && !!(decl.parent.flags & import_typescript.default.NodeFlags.Const) ? decl.initializer : undefined;
+      };
+      const unwrap = (node) => {
+        while (import_typescript.default.isParenthesizedExpression(node) || import_typescript.default.isAsExpression(node) || import_typescript.default.isTypeAssertionExpression(node) || import_typescript.default.isNonNullExpression(node))
+          node = node.expression;
+        return node;
+      };
+      const literal = (expression, seen = new Set) => {
+        const node = unwrap(expression);
+        if (seen.has(node))
+          return;
+        seen.add(node);
+        if (import_typescript.default.isStringLiteral(node) || import_typescript.default.isNoSubstitutionTemplateLiteral(node))
+          return node.text;
+        if (import_typescript.default.isIdentifier(node)) {
+          const init = initializer(node);
+          return init ? literal(init, seen) : undefined;
+        }
+        if (import_typescript.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript.default.SyntaxKind.PlusToken) {
+          const a = literal(node.left, new Set(seen)), b = literal(node.right, new Set(seen));
+          return a !== undefined && b !== undefined ? a + b : undefined;
+        }
+      };
+      const lockPath = (node) => import_typescript.default.isStringLiteral(node) && node.text.startsWith(".") && resolve(dirname(absolute), node.text) === lock;
+      const isConstBinding = (node) => import_typescript.default.isVariableDeclarationList(node.parent) && !!(node.parent.flags & import_typescript.default.NodeFlags.Const);
+      const isLock = (expression, seen = new Set) => {
+        const node = unwrap(expression);
+        if (seen.has(node))
+          return false;
+        seen.add(node);
+        if (import_typescript.default.isCallExpression(node) && import_typescript.default.isIdentifier(node.expression) && node.expression.text === "require" && !declaration(node.expression) && node.arguments.length === 1)
+          return lockPath(node.arguments[0]);
+        if (!import_typescript.default.isIdentifier(node))
+          return false;
+        const decl = declaration(node);
+        if (decl && (import_typescript.default.isImportClause(decl) || import_typescript.default.isNamespaceImport(decl)))
+          return imported(decl);
+        const init = initializer(node);
+        return !!init && isLock(init, seen);
+      };
+      const isTable = (expression, seen = new Set) => {
+        const node = unwrap(expression);
+        if (seen.has(node))
+          return false;
+        seen.add(node);
+        if (import_typescript.default.isPropertyAccessExpression(node))
+          return node.name.text === "prompts" && isLock(node.expression);
+        if (import_typescript.default.isElementAccessExpression(node))
+          return literal(node.argumentExpression) === "prompts" && isLock(node.expression);
+        if (import_typescript.default.isIdentifier(node)) {
+          const decl = declaration(node);
+          if (decl && import_typescript.default.isBindingElement(decl) && import_typescript.default.isObjectBindingPattern(decl.parent) && import_typescript.default.isVariableDeclaration(decl.parent.parent)) {
+            const owner = decl.parent.parent;
+            const name = decl.propertyName ?? decl.name;
+            if (!decl.dotDotDotToken && !decl.initializer && (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name)) && name.text === "prompts" && isConstBinding(owner) && owner.initializer)
+              return isLock(owner.initializer);
+          }
+          if (decl && import_typescript.default.isImportSpecifier(decl))
+            return (decl.propertyName?.text ?? decl.name.text) === "prompts" && imported(decl);
+          const init = initializer(node);
+          return !!init && isTable(init, seen);
+        }
+        return false;
+      };
+      const visit = (node) => {
+        if ((import_typescript.default.isElementAccessExpression(node) || import_typescript.default.isPropertyAccessExpression(node)) && isTable(node.expression)) {
+          const key = import_typescript.default.isElementAccessExpression(node) ? literal(node.argumentExpression) : node.name.text;
+          result.references.push({
+            path: file.path,
+            line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+            key,
+            status: key === undefined ? "unresolved" : known.has(key) ? "mapped" : "missing"
+          });
+        }
+        import_typescript.default.forEachChild(node, visit);
+      };
+      visit(sf);
+    } catch (error) {
+      result.issues.push({ path: file.path, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return result;
+}
+export {
+  checkPromptAttribution
+};

package/dist/prompt-source-mcp.js

@@ -2,15 +2,22 @@
 import {
   checkPromptMapping,
   discoverHarnessPromptSources,
-  inspectCodeSelectors,
-  inspectPythonSelectors,
   safePromptEvidencePath
-} from "./cli-d577kq6h.js";
+} from "./cli-3n0gz4d0.js";
+import"./cli-xq45etg1.js";
 import"./cli-97fnztpy.js";
-import"./cli-cdrvjva5.js";
-import"./cli-jgfm7w1r.js";
-import"./cli-jtyvbd8d.js";
-import"./cli-sqsjd08w.js";
+import"./cli-cesds766.js";
+import {
+  inspectCodeSelectors,
+  inspectPythonSelectors
+} from "./cli-qpq84eee.js";
+import"./cli-dr6x0zv7.js";
+import"./cli-n2hng3gv.js";
+import"./cli-e23g9ywa.js";
+import"./cli-99p2jh28.js";
+import"./cli-k4tqwah4.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
 import {
   __commonJS,
   __toESM

package/dist/prompt-sources-07tczyqa.js

@@ -0,0 +1,19 @@
+import {
+  backfillPromptSource,
+  discoverCodePromptCandidates,
+  discoverCodePromptSources,
+  discoverStructuredPromptSources,
+  resolvePromptSource,
+  validatePromptSource
+} from "./cli-qpq84eee.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
+import"./cli-0v6na3yp.js";
+export {
+  validatePromptSource,
+  resolvePromptSource,
+  discoverStructuredPromptSources,
+  discoverCodePromptSources,
+  discoverCodePromptCandidates,
+  backfillPromptSource
+};

package/dist/{prompts-92aqqb2k.js → prompts-6y9wfq5z.js}

@@ -11,16 +11,17 @@ import {
   runPromptSync,
   runPromptsCommand,
   writePromptSyncProgress
-} from "./cli-b4740tnv.js";
+} from "./cli-3retgh64.js";
 import {
   promptSourceHashPayload
 } from "./cli-mm48br00.js";
-import"./cli-d577kq6h.js";
-import"./cli-97fnztpy.js";
-import"./cli-cdrvjva5.js";
-import"./cli-jgfm7w1r.js";
-import"./cli-jtyvbd8d.js";
-import"./cli-sqsjd08w.js";
+import"./cli-dr6x0zv7.js";
+import"./cli-n2hng3gv.js";
+import"./cli-e23g9ywa.js";
+import"./cli-99p2jh28.js";
+import"./cli-k4tqwah4.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
 import"./cli-0v6na3yp.js";
 export {
   writePromptSyncProgress,

package/dist/prompts-ab-ezrd63sk.js

@@ -0,0 +1,70 @@
+import {
+  DEFAULT_PROBLEM_MAX_CASES,
+  MAX_AUTO_GENERATE_CASES,
+  MAX_REPLAY_TRACES,
+  PLAYOUT_CONFIRM_THRESHOLD,
+  REPLAY_MODEL_ALLOWLIST,
+  TERMINAL_RUN_STATUSES,
+  assertAllowedModel,
+  assertArmSourceShape,
+  assertPlayoutBudget,
+  candidateOutcome,
+  describePlayouts,
+  describeProblemCases,
+  enqueueAndPollComparison,
+  fetchProblemCases,
+  fetchReplaySetCases,
+  formatVerdict,
+  parseTraceRef,
+  planReplaySet,
+  replayCasePin,
+  rerunWithYes,
+  resolvePromptArmSpec,
+  runPromptAb,
+  selectProblemCases,
+  waitLabel
+} from "./cli-yf39avhh.js";
+import {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_WAIT_TIMEOUT_MS,
+  fetchLatestRun
+} from "./cli-yz8xcpyk.js";
+import"./cli-3retgh64.js";
+import"./cli-mm48br00.js";
+import"./cli-dr6x0zv7.js";
+import"./cli-n2hng3gv.js";
+import"./cli-e23g9ywa.js";
+import"./cli-99p2jh28.js";
+import"./cli-k4tqwah4.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
+import"./cli-0v6na3yp.js";
+export {
+  waitLabel,
+  selectProblemCases,
+  runPromptAb,
+  resolvePromptArmSpec,
+  rerunWithYes,
+  replayCasePin,
+  planReplaySet,
+  parseTraceRef,
+  formatVerdict,
+  fetchReplaySetCases,
+  fetchProblemCases,
+  fetchLatestRun,
+  enqueueAndPollComparison,
+  describeProblemCases,
+  describePlayouts,
+  candidateOutcome,
+  assertPlayoutBudget,
+  assertArmSourceShape,
+  assertAllowedModel,
+  TERMINAL_RUN_STATUSES,
+  REPLAY_MODEL_ALLOWLIST,
+  PLAYOUT_CONFIRM_THRESHOLD,
+  MAX_REPLAY_TRACES,
+  MAX_AUTO_GENERATE_CASES,
+  DEFAULT_WAIT_TIMEOUT_MS,
+  DEFAULT_PROBLEM_MAX_CASES,
+  DEFAULT_POLL_INTERVAL_MS
+};

package/dist/prompts-propose-2k3enm2q.js

@@ -0,0 +1,255 @@
+import {
+  assertAllowedModel,
+  assertPlayoutBudget,
+  candidateOutcome,
+  describePlayouts,
+  enqueueAndPollComparison,
+  formatVerdict,
+  rerunWithYes,
+  resolvePromptArmSpec
+} from "./cli-yf39avhh.js";
+import"./cli-yz8xcpyk.js";
+import"./cli-3retgh64.js";
+import"./cli-mm48br00.js";
+import"./cli-dr6x0zv7.js";
+import"./cli-n2hng3gv.js";
+import {
+  callControlAPI
+} from "./cli-e23g9ywa.js";
+import {
+  resolveApiTenantId,
+  shellArg,
+  validateConfig
+} from "./cli-99p2jh28.js";
+import {
+  CliInputError
+} from "./cli-k4tqwah4.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-ns5fcnkz.js";
+import"./cli-0v6na3yp.js";
+
+// src/prompts-propose.ts
+import { writeFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+var PROPOSE_TIMEOUT_MS = 300000;
+async function runPromptPropose(positionals, flags, profileOptions, context) {
+  validateConfig();
+  const promptKey = flags["prompt-key"] || positionals[1];
+  const fromRunId = flags["from-run"] || flags["from-run-id"] || flags["run-id"];
+  const replaySetId = flags["set-id"] || flags["replay-set-id"];
+  if (!promptKey || !fromRunId || !replaySetId) {
+    throw new Error("Usage: moda prompts propose --prompt-key=<key> --from-run=<run_id> --set-id=<replay_set_id> [--max-dossiers=8] [--model=<slug>] [--out=path.prompt.md] [--gate [--seeds=1-10] [--assistant-model=<slug>] [--yes]] [--promote-on-win] [--allow-any-model]");
+  }
+  const maxDossiers = parsePositiveInt(flags["max-dossiers"], 8, 16, "--max-dossiers");
+  parsePositiveInt(flags["gate-timeout"] ?? flags.timeout, 2 * 60 * 60 * 1000, 24 * 60 * 60 * 1000, flags["gate-timeout"] !== undefined ? "--gate-timeout" : "--timeout");
+  parsePositiveInt(flags["poll-interval"], 15000, 120000, "--poll-interval");
+  const model = assertAllowedModel(flags.model ?? flags["revise-model"], flags, "--model");
+  const wantGate = flags.gate === "true";
+  let gatePlan;
+  if (wantGate) {
+    const tenantId = flags["tenant-id"] || resolveApiTenantId(profileOptions);
+    if (!tenantId) {
+      throw new Error("Missing tenant id for --gate. Run `moda init` or pass --tenant-id=<id>.");
+    }
+    const seedsPerCase = parsePositiveInt(flags.seeds ?? flags["seeds-per-case"], 3, 10, flags.seeds !== undefined ? "--seeds" : "--seeds-per-case");
+    const assistantModel = assertAllowedModel(flags["assistant-model"], flags, "--assistant-model");
+    const snapshot = await fetchGateSetCases(tenantId, replaySetId, profileOptions);
+    const cases = snapshot?.ids.length ?? null;
+    const plannedPlayouts = cases === null ? null : cases * seedsPerCase * 2;
+    assertPlayoutBudget(plannedPlayouts, { seedsPerCase, cases }, context.yes, rerunWithYes("prompts propose", positionals.slice(1), flags));
+    if (context.outputMode === "human") {
+      process.stderr.write(`Gate: ${describePlayouts(plannedPlayouts, cases, seedsPerCase)}
+`);
+    }
+    gatePlan = { tenantId, seedsPerCase, assistantModel, plannedPlayouts, cases, caseIds: snapshot?.ids };
+  }
+  const result = await callControlAPI(`/prompts/${encodeURIComponent(promptKey)}/propose`, {
+    method: "POST",
+    body: JSON.stringify({ fromRunId, replaySetId, maxDossiers, model: model || undefined })
+  }, profileOptions, { timeoutMs: PROPOSE_TIMEOUT_MS, retries: 0 });
+  let outPath;
+  if (result.status === "proposed" && result.content && flags.out) {
+    outPath = isAbsolute(flags.out) ? flags.out : resolve(process.cwd(), flags.out);
+    writeFileSync(outPath, result.content, "utf8");
+  }
+  const promoteOnWin = flags["promote-on-win"] === "true";
+  let gate;
+  if (gatePlan) {
+    if (result.status !== "proposed" || !result.content) {
+      gate = {
+        ran: false,
+        scope: "full-set",
+        scopeNote: `no candidate to gate (${result.status})`,
+        verdict: "skipped",
+        outcome: "no-run",
+        runId: null,
+        promoted: false,
+        plannedPlayouts: gatePlan.plannedPlayouts
+      };
+    } else {
+      gate = await runGate({
+        result,
+        promptKey,
+        replaySetId,
+        flags,
+        plan: gatePlan,
+        promoteOnWin,
+        profileOptions,
+        context
+      });
+    }
+  }
+  if (context.outputMode === "human") {
+    printHuman(result, outPath, gate);
+  }
+  context.output.writeData({
+    ...result,
+    ...outPath ? { outPath } : {},
+    ...gate ? { gate } : {}
+  });
+}
+async function fetchGateSetCases(tenantId, replaySetId, profileOptions) {
+  let set;
+  try {
+    set = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(replaySetId)}`, { method: "GET" }, profileOptions);
+  } catch (error) {
+    if (error?.statusCode === 404) {
+      throw new CliInputError(`Replay set '${replaySetId}' not found for tenant ${tenantId}, so nothing was sent.`, "Check --set-id: use the replay set the --from-run run was scored on (see `moda prompts replay-runs <key>`).");
+    }
+    return null;
+  }
+  if (!Array.isArray(set?.cases))
+    return null;
+  return {
+    ids: set.cases.filter((c) => String(c?.scenario ?? "").trim()).map((c, index) => String(c?.id ?? `case_${index}`))
+  };
+}
+async function runGate(args) {
+  const { result, promptKey, replaySetId, flags, plan, promoteOnWin, profileOptions, context } = args;
+  const { tenantId, seedsPerCase, assistantModel } = plan;
+  const prodArm = await resolvePromptArmSpec(promptKey, "baseline", { preferKey: true });
+  const proposedArm = {
+    content: result.content ?? "",
+    prompt_version_id: result.versionId ?? "",
+    prompt_id: "",
+    prompt_label: "candidate"
+  };
+  const timeoutMs = parsePositiveInt(flags["gate-timeout"] ?? flags.timeout, 2 * 60 * 60 * 1000, 24 * 60 * 60 * 1000, flags["gate-timeout"] !== undefined ? "--gate-timeout" : "--timeout");
+  const pollIntervalMs = parsePositiveInt(flags["poll-interval"], 15000, 120000, "--poll-interval");
+  const scopeNote = result.holdoutCaseIds.length ? `gated over the FULL replay set (${result.holdoutCaseIds.length} holdout case(s) could not be isolated — the run endpoint scores every case)` : "gated over the FULL replay set";
+  if (context.outputMode === "human") {
+    process.stderr.write(`
+Gating candidate for '${promptKey}' — ${scopeNote}...
+`);
+  }
+  const payload = await enqueueAndPollComparison({
+    tenantId,
+    replaySetId,
+    promptArms: { prod: prodArm, proposed: proposedArm },
+    seedsPerCase,
+    assistantModel: assistantModel || undefined,
+    promotePrimary: false,
+    caseIds: plan.caseIds,
+    timeoutMs,
+    pollIntervalMs,
+    onWaiting: context.outputMode === "human" ? (status) => process.stderr.write(`Waiting for gate run (${status})...
+`) : undefined
+  }, profileOptions);
+  const outcome = candidateOutcome(payload);
+  const gate = {
+    ran: true,
+    scope: "full-set",
+    scopeNote,
+    verdict: formatVerdict(payload),
+    outcome,
+    runId: payload.run?.runId ?? null,
+    promoted: false,
+    plannedPlayouts: plan.plannedPlayouts
+  };
+  if (promoteOnWin) {
+    if (outcome === "candidate" && result.versionId) {
+      await callControlAPI(`/prompts/${encodeURIComponent(promptKey)}/labels`, { method: "POST", body: JSON.stringify({ label: "prod", versionId: result.versionId }) }, profileOptions);
+      gate.promoted = true;
+    } else {
+      gate.promoteSkippedReason = outcome === "candidate" ? "no candidate versionId to promote" : `candidate did not strictly win (${outcome})`;
+    }
+  }
+  return gate;
+}
+function printHuman(result, outPath, gate) {
+  const w = (s) => process.stderr.write(s + `
+`);
+  if (result.status !== "proposed") {
+    w(`No candidate produced (${result.status}): ${result.note}`);
+    return;
+  }
+  w(`Proposed candidate for '${result.promptKey}'`);
+  w(`  new version:  ${result.versionId}  (unlabeled — not promoted)`);
+  w(`  base version: ${result.baseVersionId ?? "(none)"}`);
+  w(`  from run:     built from ${result.dossierCount} failure dossier(s)`);
+  if (result.changelog)
+    w(`  changelog:    ${result.changelog}`);
+  if (result.risks.length)
+    w(`  risks:        ${result.risks.map((r) => `- ${r}`).join(`
+                `)}`);
+  if (outPath)
+    w(`  written to:   ${outPath}`);
+  if (result.lowN) {
+    w("");
+    w(`  ⚠ low sample: ${result.lowN}`);
+  }
+  w("");
+  if (gate?.ran) {
+    w("Gate (automatic A/B of candidate vs baseline):");
+    w(`  scope:    ${gate.scopeNote}`);
+    w(`  verdict:  ${gate.verdict}`);
+    if (gate.plannedPlayouts !== undefined)
+      w(`  playouts: ${gate.plannedPlayouts ?? "unknown"} planned`);
+    if (gate.runId)
+      w(`  run id:   ${gate.runId}`);
+    if (gate.promoted) {
+      w(`  promoted: candidate won — promoted version ${result.versionId} to label 'prod'`);
+    } else if (gate.promoteSkippedReason) {
+      w(`  promote:  skipped (${gate.promoteSkippedReason})`);
+    }
+    w("");
+    if (!gate.promoted) {
+      w(`  moda prompts promote ${shellArg(result.promptKey)} --label=prod --version=${result.versionId ? shellArg(result.versionId) : "<version_id>"}`);
+    }
+    return;
+  }
+  if (gate && !gate.ran) {
+    w(`Gate not run: ${gate.scopeNote}`);
+    w("");
+  }
+  w("Next — gate on holdout cases the revision never saw, then promote if it wins:");
+  if (result.holdoutCaseIds.length) {
+    w(`  holdout cases (${result.holdoutCaseIds.length}): ${result.holdoutCaseIds.join(", ")}`);
+  } else {
+    w("  (too few failures to reserve a holdout — gate on a fresh --auto-generate set)");
+  }
+  if (outPath) {
+    w(`  moda prompts ab --baseline-key=${shellArg(result.promptKey)} --candidate=${shellArg(outPath)} --auto-generate`);
+  } else {
+    w(`  # re-run with --out=<path.prompt.md> to materialize the candidate, then:`);
+    w(`  moda prompts ab --baseline-key=${shellArg(result.promptKey)} --candidate=<path.prompt.md> --auto-generate`);
+  }
+  w(`  # or: moda prompts propose ... --gate --promote-on-win  (auto-A/B, promote on a strict win)`);
+  w(`  moda prompts promote ${shellArg(result.promptKey)} --label=prod --version=${result.versionId ? shellArg(result.versionId) : "<version_id>"}`);
+}
+function parsePositiveInt(raw, fallback, max, flagName) {
+  if (raw === undefined)
+    return fallback;
+  const text = String(raw).trim();
+  const parsed = Number(text);
+  if (!/^\d+$/.test(text) || !Number.isSafeInteger(parsed) || parsed < 1) {
+    throw new CliInputError(`${flagName}=${raw} must be a whole number of at least 1, so nothing was sent.`, `Use ${flagName}=N with 1 <= N <= ${max}.`);
+  }
+  if (parsed > max) {
+    throw new CliInputError(`${flagName}=${parsed} is above the maximum of ${max}, so nothing was sent.`, `Use ${flagName}=${max} or less.`);
+  }
+  return parsed;
+}
+export {
+  runPromptPropose
+};