@moda-ai/cli 1.55.44 → 1.55.46

package/dist/cli-8pksf2x7.js

@@ -1,754 +0,0 @@
-import {
-  assertReplayablePrompt,
-  discoverPrompts,
-  parsePromptFileForAb,
-  readPromptLock,
-  runPromptSync
-} from "./cli-wwbr5caw.js";
-import {
-  DEFAULT_POLL_INTERVAL_MS,
-  DEFAULT_WAIT_TIMEOUT_MS,
-  fetchLatestRun
-} from "./cli-4pc0a18x.js";
-import {
-  UUID_RE
-} from "./cli-tztzrh6b.js";
-import {
-  callControlAPI,
-  callDataAPI
-} from "./cli-dmm9jm9m.js";
-import {
-  EXIT_ERROR,
-  EXIT_OK,
-  resolveApiTenantId,
-  setPlatformTenantOverride,
-  shellArg,
-  validateConfig
-} from "./cli-e24fjyrb.js";
-import {
-  CliInputError
-} from "./cli-k4tqwah4.js";
-
-// src/prompts-ab.ts
-import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-var DEFAULT_SEEDS_PER_CASE = 3;
-var DEFAULT_AUTO_GENERATE_CASES = 5;
-var MAX_AUTO_GENERATE_CASES = 100;
-var MAX_REPLAY_TRACES = 100;
-var DEFAULT_PROBLEM_MAX_CASES = 10;
-var PROBLEM_PAGE_LIMIT = 50;
-var PROBLEM_MAX_PAGES = 4;
-var PLAYOUT_CONFIRM_THRESHOLD = 200;
-var REPLAY_MODEL_ALLOWLIST = [
-  "openai/gpt-5.6-luna",
-  "openai/gpt-4o-mini",
-  "openai/gpt-4o",
-  "anthropic/claude-sonnet-4-5",
-  "anthropic/claude-haiku-4-5",
-  "google/gemini-2.5-flash",
-  "google/gemini-2.5-pro"
-];
-var TERMINAL_RUN_STATUSES = new Set(["completed", "skipped", "error"]);
-var FALLBACK_SUCCESS_CRITERIA = [
-  "The agent understands the user request",
-  "The agent uses tools appropriately when needed",
-  "The agent provides a helpful final answer"
-];
-async function runPromptAb(flags, profileOptions, context) {
-  validateConfig();
-  const tenantId = flags["tenant-id"] || resolveApiTenantId(profileOptions);
-  if (!tenantId) {
-    throw new Error("Missing tenant id. Run `moda init` or pass --tenant-id=<id>.");
-  }
-  setPlatformTenantOverride(tenantId);
-  const baselineSource = flags.baseline || flags["baseline-file"] || flags["baseline-key"];
-  const candidateSource = flags.candidate || flags["candidate-file"] || flags["candidate-key"];
-  if (!baselineSource || !candidateSource) {
-    throw new Error("Usage: moda prompts ab --baseline=<file|key> --candidate=<file|key> [--auto-generate [--cases=1-100]|--set-id=ID|--traces=id1,id2[@msg_index] (max 100)|--problem=<problem_id> [--max-cases=1-100]] [--seeds=1-10] [--model=<slug>] [--yes] (legacy alias: --conversations=)");
-  }
-  await assertArmSourceShape(baselineSource, "baseline");
-  await assertArmSourceShape(candidateSource, "candidate");
-  const seedsPerCase = parsePositiveInt(flags.seeds ?? flags["seeds-per-case"], DEFAULT_SEEDS_PER_CASE, 10, flags.seeds !== undefined ? "--seeds" : "--seeds-per-case");
-  parsePositiveInt(flags["lookback-days"], 30, 365, "--lookback-days");
-  const timeoutMs = parsePositiveInt(flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, 24 * 60 * 60 * 1000, "--timeout");
-  const pollIntervalMs = parsePositiveInt(flags["poll-interval"], DEFAULT_POLL_INTERVAL_MS, 120000, "--poll-interval");
-  const assistantModel = assertAllowedModel(flags.model ?? flags["assistant-model"], flags, "--model");
-  const plan = await planReplaySet(flags, tenantId, profileOptions);
-  const problemCases = plan.kind === "traces" ? plan.problem : undefined;
-  if (problemCases && context.outputMode === "human") {
-    process.stderr.write(describeProblemCases(problemCases));
-  }
-  const plannedPlayouts = plan.cases === null ? null : plan.cases * seedsPerCase * 2;
-  assertPlayoutBudget(plannedPlayouts, { seedsPerCase, cases: plan.cases }, context.yes, rerunWithYes("prompts ab", [], flags));
-  if (context.outputMode === "human") {
-    process.stderr.write(`${describePlayouts(plannedPlayouts, plan.cases, seedsPerCase)}
-`);
-  }
-  if (flags.sync === "true") {
-    for (const [source, label] of [[baselineSource, "baseline"], [candidateSource, "candidate"]]) {
-      try {
-        await resolvePromptArmSpec(source, label);
-      } catch (error) {
-        if (!(error instanceof UnresolvedPromptError))
-          throw error;
-      }
-    }
-    await runPromptSync({ ...flags, watch: "false" }, profileOptions);
-  }
-  const promptArms = {
-    prod: await resolvePromptArmSpec(baselineSource, "baseline"),
-    proposed: await resolvePromptArmSpec(candidateSource, "candidate")
-  };
-  const { setId: replaySetId, caseSources, warnings } = await ensureReplaySet(plan, flags, tenantId, profileOptions);
-  if (context.outputMode === "human") {
-    for (const warning of warnings)
-      process.stderr.write(`Warning: ${warning}
-`);
-  }
-  const writeOptions = warnings.length ? { warnings } : undefined;
-  try {
-    const enqueue = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(replaySetId)}/run`, {
-      method: "POST",
-      body: JSON.stringify({
-        promptArms,
-        seedsPerCase,
-        assistantModel: assistantModel || undefined,
-        promotePrimary: flags.promote === "true" && flags["no-promote"] !== "true",
-        ...plan.kind === "existing" ? replayCasePin(plan.caseIds) : {}
-      })
-    }, profileOptions, { timeoutMs: 120000, retries: 0 });
-    if (context.outputMode === "human")
-      warnIfQueued(enqueue);
-    const noWait = flags.wait === "false" || flags["no-wait"] === "true";
-    if (noWait) {
-      context.output.writeData({
-        replaySetId,
-        ...problemCases ? { problemCases } : {},
-        ...caseSources ? { caseSources } : {},
-        ...warnings.length ? { warnings } : {},
-        runId: enqueue.runId,
-        status: enqueue.status,
-        message: enqueue.message ?? "Replay comparison queued",
-        plannedPlayouts
-      }, writeOptions);
-      return EXIT_OK;
-    }
-    const deadline = Date.now() + timeoutMs;
-    let latest = null;
-    while (Date.now() < deadline) {
-      latest = await fetchLatestRun(tenantId, replaySetId, enqueue.runId, profileOptions);
-      const status = latest.run?.status ?? "";
-      const runId = latest.run?.runId ?? "";
-      if (TERMINAL_RUN_STATUSES.has(status) && runId === enqueue.runId) {
-        break;
-      }
-      if (context.outputMode === "human") {
-        process.stderr.write(`Waiting for replay run (${waitLabel(latest.run)})...
-`);
-      }
-      await sleep(pollIntervalMs);
-    }
-    if (!latest?.run || latest.run.runId !== enqueue.runId || !TERMINAL_RUN_STATUSES.has(latest.run.status)) {
-      throw new Error(`Timed out after ${timeoutMs}ms waiting for replay run ${enqueue.runId} to finish`);
-    }
-    const result = {
-      replaySetId,
-      ...problemCases ? { problemCases } : {},
-      ...caseSources ? { caseSources } : {},
-      ...warnings.length ? { warnings } : {},
-      plannedPlayouts,
-      runId: latest.run.runId,
-      status: latest.run.status,
-      verdict: formatVerdict(latest),
-      run: { ...latest.run },
-      cases: latest.cases.map((row) => ({ ...row }))
-    };
-    if (context.outputMode === "human") {
-      printHumanVerdict(result);
-    }
-    const failed = result.status === "error";
-    context.output.writeData(result, { ...writeOptions, ...failed ? { status: "error" } : {} });
-    return failed ? EXIT_ERROR : EXIT_OK;
-  } catch (error) {
-    if (warnings.length && error && typeof error === "object") {
-      Object.assign(error, { warnings });
-    }
-    throw error;
-  }
-}
-function warnIfQueued(enqueue) {
-  const { runsAhead, maxActiveRuns } = enqueue;
-  if (typeof runsAhead !== "number" || typeof maxActiveRuns !== "number")
-    return;
-  if (runsAhead < maxActiveRuns)
-    return;
-  process.stderr.write(`Note: ${runsAhead} replay runs for this tenant are already running or queued ` + `(${maxActiveRuns} at a time); run ${enqueue.runId} waits in the queue until a slot frees.
-`);
-}
-function waitLabel(run) {
-  if (!run?.status)
-    return "pending";
-  if (run.status === "accepted") {
-    return typeof run.runsAhead === "number" ? `queued, ${run.runsAhead} run${run.runsAhead === 1 ? "" : "s"} ahead` : "queued";
-  }
-  return run.status;
-}
-var FILE_ARM_RE = /[\\/]|\.(?:md|txt|json|ya?ml|jinja2?|j2|hbs|tmpl|prompt|[cm]?[jt]sx?|py)$/i;
-var PROMPT_KEY_RE = /^[^\s"'`\x00-\x1f\x7f]+$/;
-async function assertArmSourceShape(source, label) {
-  const trimmed = source.trim();
-  if (!trimmed) {
-    throw new CliInputError(`Empty prompt source for ${label}, so nothing was sent.`);
-  }
-  const absPath = isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
-  const exists = existsSync(absPath);
-  if (!exists && FILE_ARM_RE.test(trimmed)) {
-    if (await isDiscoveredKey(trimmed))
-      return;
-    throw new CliInputError(`--${label} file not found: ${trimmed}, so nothing was sent.`);
-  }
-  if (exists) {
-    if (!statSync(absPath).isFile()) {
-      throw new CliInputError(`--${label} is not a file: ${trimmed}, so nothing was sent.`);
-    }
-    try {
-      accessSync(absPath, fsConstants.R_OK);
-    } catch {
-      throw new CliInputError(`--${label} file is not readable: ${trimmed}, so nothing was sent.`);
-    }
-    if (/\.(?:[cm]?[jt]sx?|py)$/i.test(absPath)) {
-      throw new CliInputError(`--${label}=${trimmed} is a source module; source modules cannot be replayed as instructions, so nothing was sent.`, "Use the registered prompt key for this code source.");
-    }
-    return;
-  }
-  if (!PROMPT_KEY_RE.test(trimmed)) {
-    throw new CliInputError(`--${label}=${JSON.stringify(trimmed)} is neither an existing prompt file nor a valid prompt key, so nothing was sent.`, "Pass a .prompt.md path or a prompt key (no spaces or quotes).");
-  }
-}
-async function isDiscoveredKey(key) {
-  try {
-    return (await discoverPrompts()).some((prompt) => prompt.key === key);
-  } catch {
-    return false;
-  }
-}
-
-class UnresolvedPromptError extends Error {
-}
-async function resolvePromptArmSpec(source, label, opts = {}) {
-  const trimmed = source.trim();
-  if (!trimmed) {
-    throw new Error(`Empty prompt source for ${label}`);
-  }
-  const fromDiscovery = async () => {
-    const discovered = await discoverPrompts();
-    const matches = discovered.filter((prompt) => prompt.key === trimmed || prompt.sourcePath === trimmed);
-    if (matches.length > 1)
-      throw new Error(`Multiple prompts use '${trimmed}'; select a stable prompt key.`);
-    const match = matches[0];
-    if (match)
-      assertReplayablePrompt(match);
-    return match ? { key: match.key, content: match.content } : null;
-  };
-  const absPath = isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
-  let key;
-  let content;
-  const preferred = opts.preferKey ? await fromDiscovery() : null;
-  if (preferred) {
-    key = preferred.key;
-    content = preferred.content;
-  } else if (opts.preferKey) {
-    throw new Error(`Could not resolve prompt key '${trimmed}' — no discovered prompt matched this key`);
-  } else if (existsSync(absPath)) {
-    if (/\.(?:[cm]?[jt]sx?|py)$/.test(absPath))
-      throw new Error("Use a registered prompt key for code sources; source modules cannot be replayed as instructions.");
-    const parsed = parsePromptFileForAb(absPath);
-    key = parsed.key;
-    content = parsed.content;
-  } else {
-    const match = await fromDiscovery();
-    if (!match) {
-      throw new UnresolvedPromptError(`Could not resolve prompt '${trimmed}' — pass a .prompt.md path or a discovered prompt key`);
-    }
-    key = match.key;
-    content = match.content;
-  }
-  const locked = readPromptLock()?.prompts[key];
-  return {
-    content,
-    prompt_version_id: locked?.versionId ?? "",
-    prompt_id: locked?.promptId ?? "",
-    prompt_label: label
-  };
-}
-async function planReplaySet(flags, tenantId, profileOptions) {
-  const problemPlan = await planProblemCases(flags);
-  if (problemPlan)
-    return problemPlan;
-  const existingSetId = (flags["set-id"] || flags["replay-set-id"] || "").trim();
-  if (existingSetId) {
-    const snapshot = await fetchReplaySetCases(tenantId, existingSetId, profileOptions);
-    return { kind: "existing", setId: existingSetId, cases: snapshot?.ids.length ?? null, caseIds: snapshot?.ids };
-  }
-  const conversations = [...new Set(parseCsv(flags.traces ?? flags.conversations ?? flags["conversation-ids"]))];
-  if (conversations.length > MAX_REPLAY_TRACES) {
-    throw new CliInputError(`--traces has ${conversations.length} ids; the limit is ${MAX_REPLAY_TRACES} per replay set, so nothing was sent.`, "Split the traces across several runs, or use --auto-generate.");
-  }
-  if (conversations.length) {
-    return { kind: "traces", traces: conversations, cases: conversations.length };
-  }
-  if (flags["auto-generate"] === "false") {
-    throw new Error("Provide --set-id=, --traces= (legacy alias: --conversations=), or allow --auto-generate (default)");
-  }
-  return {
-    kind: "auto-generate",
-    cases: parseCappedInt(flags.cases ?? flags["case-count"], DEFAULT_AUTO_GENERATE_CASES, MAX_AUTO_GENERATE_CASES, "--cases")
-  };
-}
-var PROBLEM_CASE_CONFLICTS = [
-  ["traces", "--traces"],
-  ["conversations", "--conversations"],
-  ["conversation-ids", "--conversation-ids"],
-  ["set-id", "--set-id"],
-  ["replay-set-id", "--replay-set-id"],
-  ["cases", "--cases"],
-  ["case-count", "--case-count"]
-];
-async function planProblemCases(flags) {
-  const raw = flags.problem;
-  if (raw === undefined) {
-    if (flags["max-cases"] !== undefined) {
-      throw new CliInputError("--max-cases applies only with --problem, so nothing was sent.", "Use --cases=N with --auto-generate, or pass --problem=<problem_id>.");
-    }
-    return null;
-  }
-  const problemId = raw.trim();
-  const conflicts = PROBLEM_CASE_CONFLICTS.filter(([key]) => flags[key] !== undefined).map(([, name]) => name);
-  if (flags["auto-generate"] === "true")
-    conflicts.push("--auto-generate");
-  if (conflicts.length) {
-    throw new CliInputError(`--problem cannot be combined with ${conflicts.join(", ")}: each picks the replay cases, so nothing was sent.`, "Pass one of --problem=<problem_id> [--max-cases=N], --traces=<ids>, --set-id=<id>, or --auto-generate [--cases=N].");
-  }
-  if (!UUID_RE.test(problemId)) {
-    throw new CliInputError(`--problem needs a canonical problem UUID; got "${problemId}", so nothing was sent.`, "Run `moda problems` to find the problem_id.");
-  }
-  const maxCases = parsePositiveInt(flags["max-cases"], DEFAULT_PROBLEM_MAX_CASES, MAX_REPLAY_TRACES, "--max-cases");
-  const selection = await fetchProblemCases(problemId, maxCases);
-  if (!selection.traces.length) {
-    throw new CliInputError(`Problem ${problemId} has no affected traces to replay, so nothing was sent.`, `Check the id with \`moda problems get ${problemId}\`, or pass --traces=<ids>.`);
-  }
-  return {
-    kind: "traces",
-    traces: selection.traces.map((c) => c.msg_index === null ? c.conversation_id : `${c.conversation_id}@${c.msg_index}`),
-    cases: selection.traces.length,
-    problem: selection
-  };
-}
-async function readProblemPages(problemId, view, enough, drain = false) {
-  const rows = [];
-  let enoughAt = null;
-  let cursor = null;
-  let resolvedId = null;
-  let hasMore = false;
-  for (let page = 0;page < PROBLEM_MAX_PAGES; page++) {
-    const query = new URLSearchParams({ limit: String(PROBLEM_PAGE_LIMIT) });
-    if (cursor)
-      query.set("cursor", cursor);
-    const data = await callDataAPI(`/problems/${encodeURIComponent(problemId)}/${view}?${query.toString()}`);
-    if (typeof data?.problem_id === "string" && data.problem_id)
-      resolvedId = data.problem_id;
-    const pageRows = data?.[view];
-    if (Array.isArray(pageRows))
-      rows.push(...pageRows);
-    const next = data?.pagination?.next_cursor;
-    hasMore = data?.pagination?.has_more === true && typeof next === "string" && next !== "";
-    if (enoughAt === null && enough(rows))
-      enoughAt = rows.length;
-    if (!hasMore || enoughAt !== null && !drain)
-      break;
-    cursor = next;
-  }
-  return { rows, enoughAt, resolvedId, hasMore };
-}
-async function fetchProblemCases(problemId, maxCases) {
-  const anchored = (evidenceRows, traceRows2) => selectProblemCases(evidenceRows, traceRows2, MAX_REPLAY_TRACES).traces.filter((c) => c.msg_index !== null).length;
-  const evidence = await readProblemPages(problemId, "evidence", (rows) => anchored(rows, []) >= maxCases, true);
-  const choiceRows = evidence.enoughAt === null ? evidence.rows : evidence.rows.slice(0, evidence.enoughAt);
-  let traceRows = [];
-  let tracesHaveMore = false;
-  let resolvedId = evidence.resolvedId;
-  if (anchored(choiceRows, []) < maxCases) {
-    const traces2 = await readProblemPages(problemId, "conversations", (rows) => anchored(evidence.rows, rows) >= maxCases);
-    traceRows = traces2.rows;
-    tracesHaveMore = traces2.hasMore;
-    resolvedId ??= traces2.resolvedId;
-  }
-  const selected = selectProblemCases(choiceRows, traceRows, maxCases);
-  const all = selectProblemCases(evidence.rows, traceRows, Number.MAX_SAFE_INTEGER);
-  const earliestByTrace = new Map(all.traces.map((c) => [c.conversation_id, c]));
-  const traces = selected.traces.map((c) => {
-    const first = earliestByTrace.get(c.conversation_id);
-    return first && first.msg_index !== null && (c.msg_index === null || first.msg_index < c.msg_index) ? first : c;
-  });
-  const found = all.found;
-  const resolved = resolvedId ?? problemId;
-  return {
-    problemId: resolved,
-    ...resolved !== problemId ? { requestedProblemId: problemId } : {},
-    maxCases,
-    traces,
-    found,
-    moreAvailable: found > traces.length || evidence.hasMore || tracesHaveMore
-  };
-}
-function anchorIndex(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-function selectProblemCases(evidenceRows, traceRows, maxCases) {
-  const byTrace = new Map;
-  const consider = (conversationId, msgIndex, source, family) => {
-    if (typeof conversationId !== "string" || !conversationId.trim())
-      return;
-    const id = conversationId.trim();
-    const existing = byTrace.get(id);
-    const signalFamily = typeof family === "string" && family ? family : undefined;
-    if (existing && (msgIndex === null || existing.msg_index !== null && existing.msg_index <= msgIndex))
-      return;
-    byTrace.set(id, {
-      conversation_id: id,
-      msg_index: msgIndex,
-      source,
-      ...signalFamily ? { signal_family: signalFamily } : {}
-    });
-  };
-  for (const row of evidenceRows) {
-    const r = row ?? {};
-    consider(r.conversation_id, anchorIndex(r.anchor_msg_index), "evidence", r.signal_family);
-  }
-  for (const row of traceRows) {
-    const r = row ?? {};
-    const anchor = r.latest_anchor ?? {};
-    consider(r.conversation_id, anchorIndex(anchor.anchor_msg_index), "trace", undefined);
-  }
-  const all = [...byTrace.values()];
-  const ordered = [...all.filter((c) => c.msg_index !== null), ...all.filter((c) => c.msg_index === null)];
-  return { traces: ordered.slice(0, maxCases), found: all.length };
-}
-function describeProblemCases(selection) {
-  const requested = selection.requestedProblemId ? ` (requested ${selection.requestedProblemId})` : "";
-  const lines = [
-    `Replaying ${selection.traces.length} trace(s) from Problem ${selection.problemId}${requested}, each from its evidence anchor:`
-  ];
-  for (const c of selection.traces) {
-    const where = c.msg_index === null ? " (no anchor: replays from the first message)" : ` @ msg ${c.msg_index}`;
-    lines.push(`  ${c.conversation_id}${where}${c.signal_family ? ` [${c.signal_family}]` : ""}`);
-  }
-  if (selection.moreAvailable) {
-    lines.push(`Capped at --max-cases=${selection.maxCases}; the Problem has more affected traces.`);
-  }
-  return `${lines.join(`
-`)}
-`;
-}
-async function fetchReplaySetCases(tenantId, setId, profileOptions) {
-  try {
-    const set = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(setId)}`, { method: "GET" }, profileOptions);
-    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}`))
-    };
-  } catch (error) {
-    if (error?.statusCode === 404) {
-      throw new CliInputError(`Replay set '${setId}' not found for tenant ${tenantId}, so nothing was sent.`, "Check --set-id (list sets in the dashboard, or omit it to auto-generate).");
-    }
-    return null;
-  }
-}
-function replayCasePin(caseIds) {
-  if (!caseIds)
-    return {};
-  return caseIds.length <= REPLAY_CASE_IDS_PIN_MAX ? { caseIds, expectedCases: caseIds.length } : { expectedCases: caseIds.length };
-}
-var REPLAY_CASE_IDS_PIN_MAX = 500;
-function describePlayouts(planned, cases, seeds) {
-  return planned === null ? `Planned replay playouts: unknown (case count unavailable) × ${seeds} seeds × 2 arms` : `Planned replay playouts: ${planned} (${cases} cases × ${seeds} seeds × 2 arms)`;
-}
-function assertPlayoutBudget(planned, shape, yes, rerun) {
-  if (yes)
-    return;
-  if (planned !== null && planned <= PLAYOUT_CONFIRM_THRESHOLD)
-    return;
-  const what = planned === null ? "an unknown number of replay playouts (the replay set's case count could not be read)" : `${planned} replay playouts (${shape.cases} cases × ${shape.seedsPerCase} seeds × 2 arms)`;
-  throw new CliInputError(`This would run ${what}, above the ${PLAYOUT_CONFIRM_THRESHOLD}-playout limit that needs confirmation. Nothing was sent.`, `Re-run with --yes to confirm: ${rerun}`);
-}
-function assertAllowedModel(raw, flags, flagName) {
-  const model = (raw ?? "").trim();
-  if (!model || flags["allow-any-model"] === "true")
-    return model;
-  if (REPLAY_MODEL_ALLOWLIST.includes(model))
-    return model;
-  throw new CliInputError(`${flagName}=${model} is not in the replay model allowlist, so nothing was sent.`, `Allowed: ${REPLAY_MODEL_ALLOWLIST.join(", ")}. Pass --allow-any-model to use another OpenRouter slug.`);
-}
-function rerunWithYes(command, positionals, flags) {
-  const parts = ["moda", ...command.split(" "), ...positionals.map(shellArg)];
-  for (const [key, value] of Object.entries(flags)) {
-    if (key === "yes")
-      continue;
-    parts.push(value === "true" ? `--${key}` : `--${key}=${shellArg(value)}`);
-  }
-  parts.push("--yes");
-  return parts.join(" ");
-}
-async function ensureReplaySet(plan, flags, tenantId, profileOptions) {
-  if (plan.kind === "existing")
-    return { setId: plan.setId, warnings: [] };
-  if (plan.kind === "traces") {
-    const defaultName = plan.problem ? `Prompt A/B problem ${plan.problem.problemId.slice(0, 8)} (${plan.traces.length} trace(s))` : undefined;
-    return createSetFromTraces(plan.traces, flags, tenantId, profileOptions, defaultName);
-  }
-  const caseCount = plan.cases;
-  const lookbackDays = parsePositiveInt(flags["lookback-days"], 30, 365, "--lookback-days");
-  const name = (flags.name ?? flags["set-name"] ?? `Prompt A/B ${new Date().toISOString().slice(0, 10)}`).trim();
-  const generated = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/auto-generate`, {
-    method: "POST",
-    body: JSON.stringify({ name, caseCount, lookbackDays })
-  }, profileOptions, { timeoutMs: 300000, retries: 0 });
-  if (!generated?.id) {
-    throw new Error("Auto-generate did not return a replay set id");
-  }
-  return { setId: generated.id, warnings: [] };
-}
-function parseTraceRef(ref) {
-  const match = /^(.+)@(\d+)$/.exec(ref.trim());
-  if (!match)
-    return { conversationId: ref.trim() };
-  return { conversationId: match[1], startMsgIndex: Number(match[2]) };
-}
-async function createSetFromTraces(conversationIds, flags, tenantId, profileOptions, defaultName) {
-  const refs = [...new Set(conversationIds)].map(parseTraceRef);
-  const traces = [...new Set(refs.map((ref) => ref.conversationId))];
-  const startByConversation = new Map;
-  for (const ref of refs) {
-    if (ref.startMsgIndex !== undefined)
-      startByConversation.set(ref.conversationId, ref.startMsgIndex);
-  }
-  const name = (flags.name ?? flags["set-name"] ?? defaultName ?? `Prompt A/B ${traces.length} trace(s)`).trim();
-  const base = `/tenants/${encodeURIComponent(tenantId)}/replay-sets`;
-  const traceAnchors = traces.filter((id) => startByConversation.has(id)).map((id) => ({ conversationId: id, msgIndex: startByConversation.get(id) }));
-  let set = null;
-  let unavailable = null;
-  try {
-    set = await callControlAPI(`${base}/auto-generate`, {
-      method: "POST",
-      body: JSON.stringify({ name, conversationIds: traces, ...traceAnchors.length ? { traceAnchors } : {} })
-    }, profileOptions, { timeoutMs: 300000, retries: 0 });
-    if (!set?.id)
-      throw new Error("Auto-generate did not return a replay set id");
-  } catch (error) {
-    const status = error?.statusCode;
-    if (status === 401 || status === 403)
-      throw error;
-    unavailable = error instanceof Error ? error.message : String(error);
-    set = null;
-  }
-  const distilledIds = new Set((set?.cases ?? []).map((c) => String(c?.sourceConversationId ?? "")).filter(Boolean));
-  const distilled = traces.filter((id) => distilledIds.has(id));
-  const fallback = traces.filter((id) => !distilledIds.has(id));
-  if (!set) {
-    set = await callControlAPI(base, { method: "POST", body: JSON.stringify({ name, description: "Created by moda prompts ab" }) }, profileOptions);
-  }
-  const requestedIndex = new Map(traces.map((id, index) => [id, index]));
-  for (const existing of set.cases ?? []) {
-    const conversationId = String(existing?.sourceConversationId ?? "");
-    const index = requestedIndex.get(conversationId);
-    const startMsgIndex = startByConversation.get(conversationId);
-    const update = {};
-    if (fallback.length && index !== undefined && existing.position !== index)
-      update.position = index;
-    if (startMsgIndex !== undefined && existing.sourceStartMsgIndex !== startMsgIndex) {
-      update.sourceStartMsgIndex = startMsgIndex;
-    }
-    if (!Object.keys(update).length)
-      continue;
-    await callControlAPI(`${base}/${encodeURIComponent(set.id)}/cases/${encodeURIComponent(existing.id)}`, { method: "PUT", body: JSON.stringify(update) }, profileOptions);
-  }
-  for (const conversationId of fallback) {
-    const scenario = await loadScenarioFromConversation(conversationId, startByConversation.get(conversationId));
-    await callControlAPI(`${base}/${encodeURIComponent(set.id)}/cases`, {
-      method: "POST",
-      body: JSON.stringify({
-        title: conversationId,
-        scenario,
-        sourceConversationId: conversationId,
-        ...startByConversation.has(conversationId) ? { sourceStartMsgIndex: startByConversation.get(conversationId) } : {},
-        successCriteria: FALLBACK_SUCCESS_CRITERIA,
-        position: requestedIndex.get(conversationId)
-      })
-    }, profileOptions);
-  }
-  const warnings = [];
-  if (fallback.length) {
-    const why = unavailable ? `Moda could not distill these traces (${unavailable.slice(0, 600)})` : "Moda could not distill a scenario for these traces";
-    warnings.push(`${why}, so ${fallback.length} of ${traces.length} case(s) use only the opening user message and three generic ` + `success criteria, which long traces pass easily: ${fallback.slice(0, 10).join(", ")}${fallback.length > 10 ? ", …" : ""}. ` + "Edit their scenario/criteria in the dashboard, or pass --set-id with a curated set.");
-  }
-  return { setId: set.id, caseSources: { distilled, fallback }, warnings };
-}
-var ANCHOR_REQUEST_MAX_READS = 20;
-var CONTEXT_WINDOW = 10;
-async function loadScenarioFromConversation(conversationId, startMsgIndex) {
-  const anchored = startMsgIndex !== undefined && startMsgIndex > 0;
-  const userRequest = (messages, atOrBefore) => messages.filter((message) => message.role === "user" && String(message.content ?? "").trim() && (atOrBefore === undefined || typeof message.index === "number" && message.index <= atOrBefore));
-  const readContext = async (msgIndex, window) => {
-    const data = await callDataAPI(`/conversations/${encodeURIComponent(conversationId)}/context?msg_index=${msgIndex}&window=${window}`);
-    return data.context?.messages ?? data.messages ?? [];
-  };
-  try {
-    if (anchored) {
-      let center = startMsgIndex;
-      for (let read = 0;read < ANCHOR_REQUEST_MAX_READS; read++) {
-        const lead = userRequest(await readContext(center, CONTEXT_WINDOW), startMsgIndex).pop();
-        const request = String(lead?.content ?? "").trim();
-        if (request) {
-          return `Earlier in the conversation the user and the agent already talked; the replay keeps those turns as history. ` + `Now the user says: "${request}"
-
-Help them with this request using the available tools.`;
-        }
-        if (center - CONTEXT_WINDOW <= 0)
-          break;
-        center = Math.max(0, center - (2 * CONTEXT_WINDOW + 1));
-      }
-    } else {
-      const request = String(userRequest(await readContext(0, 5))[0]?.content ?? "").trim();
-      if (request) {
-        return `The user says: "${request}"
-
-Replay the conversation faithfully and help them accomplish their goal.`;
-      }
-    }
-  } catch {}
-  return anchored ? `Replay conversation ${conversationId} from message ${startMsgIndex}: help the user with their request at that point using the available tools.` : `Replay conversation ${conversationId}: help the user accomplish their original goal using the available tools.`;
-}
-function candidateOutcome(payload) {
-  const run = payload.run;
-  if (!run || run.status !== "completed")
-    return "no-run";
-  const delta = run.proposedPassCount - run.prodPassCount;
-  if (delta > 0)
-    return "candidate";
-  if (delta < 0)
-    return "baseline";
-  return "tie";
-}
-function formatVerdict(payload) {
-  const run = payload.run;
-  if (!run)
-    return "no run";
-  if (run.status === "skipped")
-    return `skipped: ${run.notes || "no reason"}`;
-  if (run.status === "error")
-    return `error: ${run.notes || "unknown error"}`;
-  if (run.status !== "completed")
-    return `status=${run.status}`;
-  const delta = run.proposedPassCount - run.prodPassCount;
-  const winner = delta > 0 ? "candidate wins" : delta < 0 ? "baseline wins" : "tie on case passes";
-  const rates = `baseline ${run.prodPassCount}/${run.caseCount} (${pct(run.prodPassRate)}), candidate ${run.proposedPassCount}/${run.caseCount} (${pct(run.proposedPassRate)})`;
-  const notes = run.notes?.trim();
-  return `${winner}; ${rates}${notes ? `; ${notes}` : ""}`;
-}
-function printHumanVerdict(result) {
-  process.stderr.write(`
-Prompt A/B replay verdict
-`);
-  process.stderr.write(`-------------------------
-`);
-  process.stderr.write(`Replay set: ${result.replaySetId}
-`);
-  process.stderr.write(`Run id:     ${result.runId}
-`);
-  process.stderr.write(`Status:     ${result.status}
-`);
-  process.stderr.write(`Verdict:    ${result.verdict}
-`);
-  if (result.cases.length) {
-    process.stderr.write(`
-Per-case:
-`);
-    for (const row of result.cases) {
-      const caseId = String(row.caseId ?? "");
-      const prod = formatPass(row.prodPass);
-      const proposed = formatPass(row.proposedPass);
-      process.stderr.write(`  ${caseId}: baseline=${prod} candidate=${proposed}
-`);
-    }
-  }
-  process.stderr.write(`
-`);
-}
-function formatPass(value) {
-  if (value === null || value === undefined)
-    return "abstained";
-  return value ? "pass" : "fail";
-}
-function pct(rate) {
-  return `${Math.round(Math.max(0, Math.min(1, rate)) * 100)}%`;
-}
-async function enqueueAndPollComparison(args, profileOptions) {
-  const enqueue = await callControlAPI(`/tenants/${encodeURIComponent(args.tenantId)}/replay-sets/${encodeURIComponent(args.replaySetId)}/run`, {
-    method: "POST",
-    body: JSON.stringify({
-      promptArms: args.promptArms,
-      seedsPerCase: args.seedsPerCase ?? DEFAULT_SEEDS_PER_CASE,
-      assistantModel: args.assistantModel || undefined,
-      promotePrimary: args.promotePrimary ?? false,
-      ...replayCasePin(args.caseIds)
-    })
-  }, profileOptions, { timeoutMs: 120000, retries: 0 });
-  if (args.onWaiting)
-    warnIfQueued(enqueue);
-  const timeoutMs = args.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const deadline = Date.now() + timeoutMs;
-  let latest = null;
-  while (Date.now() < deadline) {
-    latest = await fetchLatestRun(args.tenantId, args.replaySetId, enqueue.runId, profileOptions);
-    const status = latest.run?.status ?? "";
-    const runId = latest.run?.runId ?? "";
-    if (TERMINAL_RUN_STATUSES.has(status) && runId === enqueue.runId) {
-      return latest;
-    }
-    args.onWaiting?.(waitLabel(latest.run));
-    await sleep(pollIntervalMs);
-  }
-  if (!latest?.run || latest.run.runId !== enqueue.runId || !TERMINAL_RUN_STATUSES.has(latest.run.status)) {
-    throw new Error(`Timed out after ${timeoutMs}ms waiting for replay run ${enqueue.runId} to finish`);
-  }
-  return latest;
-}
-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;
-}
-function parseCappedInt(raw, fallback, max, flagName) {
-  return parsePositiveInt(raw, fallback, max, flagName);
-}
-function parseCsv(raw) {
-  if (!raw?.trim())
-    return [];
-  return raw.split(",").map((part) => part.trim()).filter(Boolean);
-}
-function sleep(ms) {
-  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
-}
-
-export { MAX_AUTO_GENERATE_CASES, MAX_REPLAY_TRACES, DEFAULT_PROBLEM_MAX_CASES, PLAYOUT_CONFIRM_THRESHOLD, REPLAY_MODEL_ALLOWLIST, TERMINAL_RUN_STATUSES, runPromptAb, waitLabel, assertArmSourceShape, resolvePromptArmSpec, planReplaySet, fetchProblemCases, selectProblemCases, describeProblemCases, fetchReplaySetCases, replayCasePin, describePlayouts, assertPlayoutBudget, assertAllowedModel, rerunWithYes, parseTraceRef, candidateOutcome, formatVerdict, enqueueAndPollComparison };