@moda-ai/cli 1.55.27 → 1.55.28

package/dist/{cli-q9nsvqqg.js → cli-3retgh64.js}

@@ -2,38 +2,24 @@ import {
   computePromptContentHash,
   stableJson
 } from "./cli-mm48br00.js";
-import {
-  $isSeq,
-  $parseDocument,
-  $stringify,
-  backfillPromptSource,
-  inventoryFiles,
-  normalizeHarnessReport,
-  require_typescript,
-  resolvePromptSource,
-  safePromptEvidencePath
-} from "./cli-qwgct6x7.js";
 import {
   createCommandContext
-} from "./cli-v8q7sd7g.js";
+} from "./cli-dr6x0zv7.js";
 import {
-  UUID_RE,
   assertFlags,
   assertPositionals
-} from "./cli-wzds257x.js";
+} from "./cli-n2hng3gv.js";
+import {
+  callControlAPI
+} from "./cli-e23g9ywa.js";
 import {
-  callControlAPI,
-  callDataAPI
-} from "./cli-pg5qfmqc.js";
+  CliInputError
+} from "./cli-k4tqwah4.js";
 import {
-  CliInputError,
-  EXIT_ERROR,
-  EXIT_OK,
-  resolveApiTenantId,
-  setPlatformTenantOverride,
-  shellArg,
-  validateConfig
-} from "./cli-r5pp7qny.js";
+  $isSeq,
+  $parseDocument,
+  $stringify
+} from "./cli-9kfxkxmk.js";
 import {
   __commonJS,
   __require,
@@ -5545,1093 +5531,21 @@ var import_fast_glob = __toESM(require_out4(), 1);
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
-  existsSync as existsSync2,
+  existsSync,
   lstatSync,
   mkdirSync,
   readFileSync,
   realpathSync,
   renameSync,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync
 } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join, relative, resolve as resolve4 } from "node:path";
-
-// 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 DEFAULT_POLL_INTERVAL_MS = 15000;
-var DEFAULT_WAIT_TIMEOUT_MS = 2 * 60 * 60 * 1000;
-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=)");
-  }
-  assertArmSourceShape(baselineSource, "baseline");
-  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 {
-        resolvePromptArmSpec(source, label);
-      } catch (error) {
-        if (!(error instanceof UnresolvedPromptError))
-          throw error;
-      }
-    }
-    await runPromptSync({ ...flags, watch: "false" }, profileOptions);
-  }
-  const promptArms = {
-    prod: resolvePromptArmSpec(baselineSource, "baseline"),
-    proposed: 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]+$/;
-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 (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).");
-  }
-}
-function isDiscoveredKey(key) {
-  try {
-    return discoverPrompts().some((prompt) => prompt.key === key);
-  } catch {
-    return false;
-  }
-}
-
-class UnresolvedPromptError extends Error {
-}
-function resolvePromptArmSpec(source, label, opts = {}) {
-  const trimmed = source.trim();
-  if (!trimmed) {
-    throw new Error(`Empty prompt source for ${label}`);
-  }
-  const fromDiscovery = () => {
-    const discovered = 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 ? 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 = 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, window2) => {
-    const data = await callDataAPI(`/conversations/${encodeURIComponent(conversationId)}/context?msg_index=${msgIndex}&window=${window2}`);
-    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.`;
-}
-async function fetchLatestRun(tenantId, replaySetId, runId, profileOptions) {
-  return callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(replaySetId)}/runs/latest?runId=${encodeURIComponent(runId)}`, { method: "GET" }, profileOptions, { timeoutMs: 60000, retries: 2 });
-}
-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));
-}
-
-// src/prompts-propose.ts
-import { writeFileSync } from "node:fs";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } 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 = parsePositiveInt2(flags["max-dossiers"], 8, 16, "--max-dossiers");
-  parsePositiveInt2(flags["gate-timeout"] ?? flags.timeout, 2 * 60 * 60 * 1000, 24 * 60 * 60 * 1000, flags["gate-timeout"] !== undefined ? "--gate-timeout" : "--timeout");
-  parsePositiveInt2(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 = parsePositiveInt2(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 = isAbsolute2(flags.out) ? flags.out : resolve2(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 = resolvePromptArmSpec(promptKey, "baseline", { preferKey: true });
-  const proposedArm = {
-    content: result.content ?? "",
-    prompt_version_id: result.versionId ?? "",
-    prompt_id: "",
-    prompt_label: "candidate"
-  };
-  const timeoutMs = parsePositiveInt2(flags["gate-timeout"] ?? flags.timeout, 2 * 60 * 60 * 1000, 24 * 60 * 60 * 1000, flags["gate-timeout"] !== undefined ? "--gate-timeout" : "--timeout");
-  const pollIntervalMs = parsePositiveInt2(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 parsePositiveInt2(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;
-}
-
-// src/prompt-attribution.ts
-var import_typescript = __toESM(require_typescript(), 1);
-import { dirname, extname, resolve as resolve3 } from "node:path";
-function checkPromptAttribution(rootDir, keys) {
-  const result = { references: [], coverage: "partial", issues: [] };
-  const known = new Set(keys), lock = resolve3(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(".") && resolve3(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(".") && resolve3(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;
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var promptSourcesModule;
+async function loadPromptSources() {
+  promptSourcesModule ??= await import("./prompt-sources-07tczyqa.js");
+  return promptSourcesModule;
 }
-
-// src/prompts.ts
 var MODA_DIR = ".moda";
 var MANIFEST_PATH = join(MODA_DIR, "prompts.yml");
 var LOCK_PATH = join(MODA_DIR, "prompts.lock.json");
@@ -6737,7 +5651,7 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
     assertFlags(`prompts ${subcommand}`, flags, writeFlags);
   switch (subcommand) {
     case "init": {
-      const imported = flags["from-harness"] ? importHarnessPromptSources(flags["from-harness"]) : undefined;
+      const imported = flags["from-harness"] ? await importHarnessPromptSources(flags["from-harness"]) : undefined;
       const init = await initPrompts({ silent: true });
       context.output.writeData({
         manifest: MANIFEST_PATH,
@@ -6786,7 +5700,7 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
     case "diff": {
       const status = await getPromptStatus();
       const differing = status.prompts.filter((row) => row.state !== "unchanged");
-      const tracked = existsSync2(MANIFEST_PATH);
+      const tracked = existsSync(MANIFEST_PATH);
       const diffWarnings = tracked ? promptManifestWarnings(status) : [
         `No ${MANIFEST_PATH} here, so diff has no last sync to compare against: it only covers prompts tracked by \`moda prompts sync\`${differing.length > 0 ? ", and every discovered prompt file lists as new" : ""}. For a registry manifest, preview with \`moda registry push --dry-run\`.`
       ];
@@ -6811,9 +5725,9 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
       await promotePrompt(positionals, flags, profileOptions, context);
       break;
     case "ab":
-      return runPromptAb(flags, profileOptions, context);
+      return (await import("./prompts-ab-ezrd63sk.js")).runPromptAb(flags, profileOptions, context);
     case "propose":
-      await runPromptPropose(positionals, flags, profileOptions, context);
+      await (await import("./prompts-propose-2k3enm2q.js")).runPromptPropose(positionals, flags, profileOptions, context);
       break;
     case "list":
     case "show":
@@ -6830,16 +5744,16 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
 }
 async function initPrompts(options = {}) {
   const cwd = process.cwd();
-  const manifestPath = resolve4(cwd, MANIFEST_PATH);
-  const lockPath = resolve4(cwd, LOCK_PATH);
-  if (existsSync2(MODA_DIR) && lstatSync(MODA_DIR).isSymbolicLink())
+  const manifestPath = resolve(cwd, MANIFEST_PATH);
+  const lockPath = resolve(cwd, LOCK_PATH);
+  if (existsSync(MODA_DIR) && lstatSync(MODA_DIR).isSymbolicLink())
     throw new CliInputError(".moda must not be a symlink.");
   mkdirSync(MODA_DIR, { recursive: true });
   let created = false;
-  if (!existsSync2(MANIFEST_PATH)) {
+  if (!existsSync(MANIFEST_PATH)) {
     assertContainedSource(cwd, MODA_DIR);
     try {
-      writeFileSync2(manifestPath, ["version: 2", "prompt_paths:", ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`), "sources: []", ""].join(`
+      writeFileSync(manifestPath, ["version: 2", "prompt_paths:", ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`), "sources: []", ""].join(`
 `), { flag: "wx" });
       created = true;
     } catch (error) {
@@ -6847,7 +5761,7 @@ async function initPrompts(options = {}) {
         throw error;
     }
   }
-  if (!existsSync2(manifestPath)) {
+  if (!existsSync(manifestPath)) {
     throw new Error(`Could not write ${manifestPath}: the file is missing after init. Check directory permissions and available disk space.`);
   }
   const result = {
@@ -6880,8 +5794,8 @@ async function syncPrompts(flags, profileOptions, context) {
 async function runPromptSync(flags, profileOptions, options = {}) {
   if (flags["dry-run"] === "true")
     return runPromptSyncExclusive(flags, profileOptions, options);
-  mkdirSync(dirname2(MANIFEST_PATH), { recursive: true });
-  const syncLock = resolve4(dirname2(MANIFEST_PATH), "prompts.sync.lock");
+  mkdirSync(dirname(MANIFEST_PATH), { recursive: true });
+  const syncLock = resolve(dirname(MANIFEST_PATH), "prompts.sync.lock");
   try {
     mkdirSync(syncLock);
   } catch (error) {
@@ -6899,24 +5813,24 @@ async function runPromptSync(flags, profileOptions, options = {}) {
 async function runPromptSyncExclusive(flags, profileOptions, options) {
   let harnessImport;
   if (flags["from-harness"] && flags["dry-run"] !== "true")
-    harnessImport = importHarnessPromptSources(flags["from-harness"]);
+    harnessImport = await importHarnessPromptSources(flags["from-harness"]);
   if (flags["dry-run"] !== "true")
     await initPrompts({ silent: true });
   const manifest = readManifest();
   const originalManifestHash = hashFile(MANIFEST_PATH);
   let extraSources = [];
   if (flags["from-harness"] && flags["dry-run"] === "true") {
-    const read = readHarnessSources(flags["from-harness"]);
+    const read = await readHarnessSources(flags["from-harness"]);
     extraSources = read.sources;
     harnessImport = read.result;
   }
   mergePromptSources(manifest.sources, extraSources);
-  const established = discoverPrompts(extraSources);
+  const established = await discoverPrompts(extraSources);
   let discovery;
   const analyzedDefinitions = new Map;
   if (flags["no-analyze"] !== "true") {
     options.onProgress?.("Analyzing prompt sources before sync.");
-    const { analyzeHarnessPrompts } = await import("./harness-a7tb9a23.js");
+    const { analyzeHarnessPrompts } = await import("./harness-7azmzytc.js");
     const result = await analyzeHarnessPrompts({
       rootDir: process.cwd(),
       existing: established.flatMap((prompt) => prompt.sourceDefinition ? [prompt.sourceDefinition.source] : []),
@@ -6925,10 +5839,10 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
       dryRun: flags["dry-run"] === "true",
       onProgress: options.onProgress
     });
-    const legacyPaths = new Set(established.filter((prompt) => !prompt.sourceDefinition).map((prompt) => resolve4(prompt.sourcePath)));
+    const legacyPaths = new Set(established.filter((prompt) => !prompt.sourceDefinition).map((prompt) => resolve(prompt.sourcePath)));
     const exclusions = manifest.promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
-    const excludedPaths = new Set(exclusions.length ? import_fast_glob.default.sync(exclusions, { cwd: process.cwd(), onlyFiles: true, dot: true, followSymbolicLinks: false }).map((path) => resolve4(path)) : []);
-    const found = result.sources.filter((source) => !legacyPaths.has(resolve4(source.path)) && !excludedPaths.has(resolve4(source.path)));
+    const excludedPaths = new Set(exclusions.length ? import_fast_glob.default.sync(exclusions, { cwd: process.cwd(), onlyFiles: true, dot: true, followSymbolicLinks: false }).map((path) => resolve(path)) : []);
+    const found = result.sources.filter((source) => !legacyPaths.has(resolve(source.path)) && !excludedPaths.has(resolve(source.path)));
     for (const source of found) {
       const analyzed = result.resolved.find((item) => item.key === source.key);
       if (!analyzed)
@@ -6943,7 +5857,8 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
     throw new Error("Prompt manifest changed during analysis. Retry with a stable checkout.");
   const mergedSources = mergePromptSources(manifest.sources, extraSources);
   const manifestUpdate = stableJson(mergedSources) === stableJson(mergePromptSources(manifest.sources, [])) ? undefined : $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: mergedSources });
-  const prompts = discoverPrompts(extraSources);
+  const prompts = await discoverPrompts(extraSources);
+  const { checkPromptAttribution } = await import("./prompt-attribution-1nytc9wj.js");
   const attribution = checkPromptAttribution(process.cwd(), prompts.map((prompt) => prompt.key));
   const brokenAttribution = attribution.references.filter((reference) => reference.status === "missing");
   if (brokenAttribution.length) {
@@ -6982,7 +5897,7 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
       dryRun
     })
   }, profileOptions);
-  if (signature !== stableJson(discoverPrompts(extraSources)) || originalManifestHash !== hashFile(MANIFEST_PATH)) {
+  if (signature !== stableJson(await discoverPrompts(extraSources)) || originalManifestHash !== hashFile(MANIFEST_PATH)) {
     throw new Error("Prompt sources changed during sync. Remote writes may have completed; the prior lockfile was preserved. Retry with a stable checkout.");
   }
   const synced = response.synced;
@@ -7045,7 +5960,7 @@ async function watchPromptSync(flags, profileOptions) {
         await syncPromptsOnce({ ...flags, watch: "false", "no-analyze": "true" }, profileOptions);
       }
     }
-    await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
 }
 async function promotePrompt(positionals, flags, profileOptions, context) {
@@ -7065,7 +5980,7 @@ async function promotePrompt(positionals, flags, profileOptions, context) {
   context.output.writeData(response);
 }
 async function getPromptStatus() {
-  const prompts = discoverPrompts();
+  const prompts = await discoverPrompts();
   const lock = readLock();
   const rows = prompts.map((prompt) => {
     const locked = lock?.prompts[prompt.key];
@@ -7108,16 +6023,17 @@ async function getPromptStatus() {
     prompts: rows
   };
 }
-function discoverPrompts(extraSources = []) {
+async function discoverPrompts(extraSources = []) {
   return discoverManifestPrompts(readManifest(), extraSources);
 }
-function discoverManifestPrompts(manifest, extraSources = []) {
+var NATIVE_PROMPT_FILE_RE = /\.prompt\.(md|json)$/i;
+async function discoverManifestPrompts(manifest, extraSources = []) {
   const root = process.cwd();
   for (const pattern of manifest.promptPaths) {
     const positive = pattern.startsWith("!") ? pattern.slice(1) : pattern;
-    if (isAbsolute3(positive) || positive.split(/[\\/]/).includes(".."))
+    if (isAbsolute(positive) || positive.split(/[\\/]/).includes(".."))
       throw new CliInputError(`Prompt pattern must stay inside the repository: ${pattern}`);
-    if (!pattern.startsWith("!") && !import_fast_glob.default.isDynamicPattern(pattern) && !existsSync2(resolve4(root, pattern))) {
+    if (!pattern.startsWith("!") && !import_fast_glob.default.isDynamicPattern(pattern) && !existsSync(resolve(root, pattern))) {
       throw new CliInputError(`Configured prompt file is missing: ${pattern}`);
     }
   }
@@ -7132,15 +6048,17 @@ function discoverManifestPrompts(manifest, extraSources = []) {
   const sources = new Map(manifest.sources.map((source) => [source.key, source]));
   for (const source of extraSources)
     sources.set(source.key, source);
-  const selectedPaths = new Set([...sources.values()].map((source) => resolve4(root, source.path)));
-  const prompts = paths.filter((path) => !selectedPaths.has(resolve4(root, path))).map((path) => {
+  const selectedPaths = new Set([...sources.values()].map((source) => resolve(root, source.path)));
+  const owned = paths.filter((path) => !selectedPaths.has(resolve(root, path)));
+  const resolver = sources.size > 0 || owned.some((path) => !NATIVE_PROMPT_FILE_RE.test(path)) ? (await loadPromptSources()).resolvePromptSource : undefined;
+  const prompts = owned.map((path) => {
     assertContainedSource(root, path);
-    if (/\.prompt\.(md|json)$/i.test(path))
-      return parsePromptFile(resolve4(root, path));
-    return normalizePrompt(resolvePromptSource(root, { key: keyFromPath(path), path }));
+    if (NATIVE_PROMPT_FILE_RE.test(path))
+      return parsePromptFile(resolve(root, path));
+    return normalizePrompt(resolver(root, { key: keyFromPath(path), path }));
   });
   for (const source of sources.values())
-    prompts.push(normalizePrompt(resolvePromptSource(root, source)));
+    prompts.push(normalizePrompt(resolver(root, source)));
   const seen = new Set;
   for (const prompt of prompts) {
     if (seen.has(prompt.key))
@@ -7151,7 +6069,7 @@ function discoverManifestPrompts(manifest, extraSources = []) {
 }
 var LEGACY_PROMPT_SUFFIXES = [".prompt.md", ".prompt.json", ".prompt.yaml", ".prompt.yml"];
 function repoPath(root, path) {
-  return relative(root, resolve4(root, path)).replaceAll("\\", "/");
+  return relative(root, resolve(root, path)).replaceAll("\\", "/");
 }
 function globPromptFiles(root, patterns, ignore = []) {
   if (patterns.length === 0)
@@ -7167,7 +6085,7 @@ function globPromptFiles(root, patterns, ignore = []) {
 }
 function inspectPromptManifest(root = process.cwd()) {
   const manifest = readManifest(root);
-  const safe = (pattern) => !isAbsolute3(pattern) && !pattern.split(/[\\/]/).includes("..");
+  const safe = (pattern) => !isAbsolute(pattern) && !pattern.split(/[\\/]/).includes("..");
   const positives = manifest.promptPaths.filter((pattern) => !pattern.startsWith("!") && safe(pattern));
   const negations = manifest.promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
   const patterns = manifest.promptPaths.filter((pattern) => !pattern.startsWith("!")).map((pattern) => ({
@@ -7192,8 +6110,8 @@ function inspectPromptManifest(root = process.cwd()) {
   };
 }
 function lockedSourcePaths(root) {
-  const lockPath = resolve4(root, LOCK_PATH);
-  if (!existsSync2(lockPath))
+  const lockPath = resolve(root, LOCK_PATH);
+  if (!existsSync(lockPath))
     return new Set;
   try {
     const lock = JSON.parse(readFileSync(lockPath, "utf8"));
@@ -7232,8 +6150,8 @@ function migrateWarnings(result) {
 }
 async function migratePromptManifest(options = {}) {
   const root = process.cwd();
-  const manifestPath = resolve4(root, MANIFEST_PATH);
-  if (!existsSync2(manifestPath)) {
+  const manifestPath = resolve(root, MANIFEST_PATH);
+  if (!existsSync(manifestPath)) {
     throw new CliInputError(`No ${MANIFEST_PATH} to migrate in ${root}.`, "Run `moda prompts init` to create a version 2 manifest.");
   }
   const original = readFileSync(manifestPath, "utf8");
@@ -7246,7 +6164,7 @@ async function migratePromptManifest(options = {}) {
   let addedSources = [];
   let pendingSources = [];
   if (options.discover) {
-    const { analyzeHarnessPrompts } = await import("./harness-a7tb9a23.js");
+    const { analyzeHarnessPrompts } = await import("./harness-7azmzytc.js");
     const result = await analyzeHarnessPrompts({
       rootDir: root,
       existing: manifest.sources,
@@ -7271,7 +6189,7 @@ async function migratePromptManifest(options = {}) {
     })).sort((a, b) => a.key.localeCompare(b.key));
   }
   try {
-    discoverManifestPrompts({ version: 2, promptPaths, sources });
+    await discoverManifestPrompts({ version: 2, promptPaths, sources });
   } catch (error) {
     throw new CliInputError(`Cannot migrate ${MANIFEST_PATH}: ${error instanceof Error ? error.message : String(error)}`, `Give the conflicting prompt a unique \`key:\` (frontmatter or ${MANIFEST_PATH} sources), then rerun \`moda prompts migrate --dry-run\`. Nothing was written.`);
   }
@@ -7329,15 +6247,15 @@ async function migratePromptManifest(options = {}) {
   };
 }
 function assertContainedSource(root, path) {
-  const abs = resolve4(root, path);
+  const abs = resolve(root, path);
   const rel = relative(realpathSync(root), realpathSync(abs));
-  if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute3(rel))
+  if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel))
     throw new CliInputError(`Prompt source escapes repository: ${path}`);
   let cursor = abs;
-  while (cursor !== resolve4(root)) {
+  while (cursor !== resolve(root)) {
     if (lstatSync(cursor).isSymbolicLink())
       throw new CliInputError(`Prompt source uses a symlink: ${path}`);
-    const next = dirname2(cursor);
+    const next = dirname(cursor);
     if (next === cursor)
       throw new CliInputError(`Prompt source escapes repository: ${path}`);
     cursor = next;
@@ -7404,10 +6322,10 @@ function normalizePrompt(prompt) {
   };
 }
 function readManifest(root = process.cwd()) {
-  if (!existsSync2(resolve4(root, MANIFEST_PATH)))
+  if (!existsSync(resolve(root, MANIFEST_PATH)))
     return { version: null, promptPaths: DEFAULT_PROMPT_PATHS, sources: [] };
   assertContainedSource(root, MANIFEST_PATH);
-  const doc = $parseDocument(readFileSync(resolve4(root, MANIFEST_PATH), "utf8"), { uniqueKeys: true });
+  const doc = $parseDocument(readFileSync(resolve(root, MANIFEST_PATH), "utf8"), { uniqueKeys: true });
   if (doc.errors.length)
     throw new CliInputError(`Invalid ${MANIFEST_PATH}: ${doc.errors[0].message}`);
   const parsed = doc.toJS({ maxAliasCount: 20 });
@@ -7431,12 +6349,12 @@ function readManifest(root = process.cwd()) {
   return { version: parsed.version, promptPaths: parsed.prompt_paths ?? (parsed.version === 1 ? DEFAULT_PROMPT_PATHS : []), sources };
 }
 var HARNESS_REANALYZE_COMMAND = "moda harness analyze --experimental --concern=prompts";
-function readHarnessSources(reportPath) {
+async function readHarnessSources(reportPath) {
   const selected = reportPath === "true" ? ".moda/harness-report.json" : reportPath;
   assertContainedSource(process.cwd(), selected);
   let raw;
   try {
-    raw = JSON.parse(readFileSync(resolve4(selected), "utf8"));
+    raw = JSON.parse(readFileSync(resolve(selected), "utf8"));
   } catch (error) {
     throw new CliInputError(`Could not read harness report ${selected}: ${error instanceof Error ? error.message : String(error)}.`, `Regenerate it with \`${HARNESS_REANALYZE_COMMAND}\`.`);
   }
@@ -7447,6 +6365,8 @@ function readHarnessSources(reportPath) {
   if (!graph) {
     throw new CliInputError(`${selected} is not a harness report with a graph (schema: ${schemaLabel}). Regenerate it with \`${HARNESS_REANALYZE_COMMAND}\`.`);
   }
+  const { normalizeHarnessReport } = await import("./harness-report-rd9c4e9v.js");
+  const { backfillPromptSource, resolvePromptSource } = await loadPromptSources();
   const report = normalizeHarnessReport(raw);
   const artifacts = (report.graph.artifacts ?? []).filter((artifact) => artifact.type === "prompt");
   const sources = [];
@@ -7481,7 +6401,7 @@ function readHarnessSources(reportPath) {
         let key = ownedKey ?? keyFromPath(path);
         try {
           if (ownedKey === undefined && nativeFile)
-            key = parsePromptFile(resolve4(root, path)).key;
+            key = parsePromptFile(resolve(root, path)).key;
         } catch {}
         tracked.push({ artifact: label, key, path });
         continue;
@@ -7511,11 +6431,11 @@ function readHarnessSources(reportPath) {
 function harnessSkipWarning(result) {
   return `${result.skipped.length} harness prompt(s) skipped (registered ${result.registered.length}): ${result.skipped.slice(0, 3).map((skip) => `'${skip.artifact}' (${skip.reason})`).join("; ")}${result.skipped.length > 3 ? "; ..." : ""}. See harnessImport.skipped; regenerate the report with \`${HARNESS_REANALYZE_COMMAND}\` to map them.`;
 }
-function importHarnessPromptSources(reportPath = ".moda/harness-report.json") {
-  const { sources, result } = readHarnessSources(reportPath);
+async function importHarnessPromptSources(reportPath = ".moda/harness-report.json") {
+  const { sources, result } = await readHarnessSources(reportPath);
   const manifest = readManifest();
   const merged = mergePromptSources(manifest.sources, sources);
-  discoverPrompts(sources);
+  await discoverPrompts(sources);
   atomicWrite(MANIFEST_PATH, $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: merged }));
   return result;
 }
@@ -7531,13 +6451,13 @@ function mergePromptSources(existingSources, sources) {
   return [...merged.values()].sort((a, b) => a.key.localeCompare(b.key));
 }
 function atomicWrite(path, content) {
-  mkdirSync(dirname2(path), { recursive: true });
-  assertContainedSource(process.cwd(), dirname2(path));
-  if (existsSync2(path) && lstatSync(path).isSymbolicLink())
+  mkdirSync(dirname(path), { recursive: true });
+  assertContainedSource(process.cwd(), dirname(path));
+  if (existsSync(path) && lstatSync(path).isSymbolicLink())
     throw new CliInputError(`Refusing to overwrite symlink: ${path}`);
   const temp = `${path}.${process.pid}.tmp`;
   try {
-    writeFileSync2(temp, content, { flag: "wx" });
+    writeFileSync(temp, content, { flag: "wx" });
     renameSync(temp, path);
   } finally {
     rmSync(temp, { force: true });
@@ -7552,7 +6472,7 @@ function parsePromptFileForAb(absPath) {
   return { key: parsed.key, content: parsed.content };
 }
 function readLock() {
-  if (!existsSync2(LOCK_PATH))
+  if (!existsSync(LOCK_PATH))
     return null;
   assertContainedSource(process.cwd(), LOCK_PATH);
   return JSON.parse(readFileSync(LOCK_PATH, "utf8"));
@@ -7573,7 +6493,7 @@ function writeLock(prompts, synced) {
       }];
     }))
   };
-  mkdirSync(dirname2(LOCK_PATH), { recursive: true });
+  mkdirSync(dirname(LOCK_PATH), { recursive: true });
   atomicWrite(LOCK_PATH, `${JSON.stringify(lock, null, 2)}
 `);
 }
@@ -7598,7 +6518,7 @@ function keyFromPath(path) {
   return path.replace(/^prompts\//, "").replace(/(?:\.prompt)?\.(md|txt|json|ya?ml|jinja2?|j2|hbs|tmpl|prompt)$/i, "").replace(/[\\/]/g, ".");
 }
 function hashFile(path) {
-  return existsSync2(path) ? sha256(readFileSync(path, "utf8")) : "";
+  return existsSync(path) ? sha256(readFileSync(path, "utf8")) : "";
 }
 function getGitCommit() {
   try {
@@ -7691,4 +6611,4 @@ function asRecordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
-export { DEFAULT_POLL_INTERVAL_MS, DEFAULT_WAIT_TIMEOUT_MS, fetchLatestRun, runPromptsCommand, initPrompts, runPromptSync, writePromptSyncProgress, discoverPrompts, inspectPromptManifest, promptManifestWarnings, migratePromptManifest, importHarnessPromptSources, readPromptLock, parsePromptFileForAb, assertReplayablePrompt };
+export { runPromptsCommand, initPrompts, runPromptSync, writePromptSyncProgress, discoverPrompts, inspectPromptManifest, promptManifestWarnings, migratePromptManifest, importHarnessPromptSources, readPromptLock, parsePromptFileForAb, assertReplayablePrompt };