@moda-ai/cli 1.55.44 → 1.55.46

package/dist/fix-nk5xffz8.js

@@ -1,1440 +0,0 @@
-import {
-  DEFAULT_POLL_INTERVAL_MS,
-  DEFAULT_WAIT_TIMEOUT_MS,
-  fetchLatestRun
-} from "./cli-4pc0a18x.js";
-import {
-  assertFlags
-} from "./cli-tztzrh6b.js";
-import {
-  callControlAPI
-} from "./cli-dmm9jm9m.js";
-import {
-  EXIT_DEGRADED,
-  EXIT_ERROR,
-  EXIT_OK,
-  getModaPaths,
-  resolveApiTenantId,
-  shellArg,
-  validateConfig
-} from "./cli-e24fjyrb.js";
-import {
-  CliInputError
-} from "./cli-k4tqwah4.js";
-import"./cli-ns5fcnkz.js";
-import"./cli-0v6na3yp.js";
-
-// src/fix.ts
-import {
-  closeSync,
-  constants as fsConstants,
-  existsSync,
-  fstatSync,
-  ftruncateSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  writeFileSync,
-  writeSync
-} from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-var O_NOFOLLOW = fsConstants.O_NOFOLLOW ?? 0;
-var ADVANCE_TIMEOUT_MS = 300000;
-var STEP_DELAY_MS = 2000;
-var MAX_WAIT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
-var MAX_POLL_INTERVAL_MS = 120000;
-var PER_CASE_FINDINGS_CAP = 50;
-var DRIVE_PASS_INTERVAL_MS = 20000;
-var DRIVE_LIST_LIMIT = 100;
-var DRIVE_LIST_MAX_PAGES = 10;
-var DRAFT_BATCH_LIMIT_MAX = 25;
-var DRAFT_BATCH_LIMIT_DEFAULT = 5;
-var DRIVE_MAX_FIXES_DEFAULT = 3;
-var DRIVE_MAX_FIXES_MAX = 10;
-var VERIFY_COOLDOWN_MS = 10 * 60 * 1000;
-var REGATE_COOLDOWN_STATUSES = new Set(["VERIFIED", "GATE_FAILED", "GATE_INCONCLUSIVE"]);
-var DRAFT_BATCH_TIMEOUT_MS = 300000;
-var ADVANCING_STATUSES = new Set(["DRAFT", "SCOPING", "PROPOSING", "PROPOSED", "GATING"]);
-var FIX_USAGE = [
-  "Usage: moda fixes [--status=S] [--limit=N] [--cursor=TOKEN]",
-  "       moda fixes draft-batch [--limit=N]           (N is 1-25, default 5)",
-  "       moda fixes drive [--status=S] [--max-fixes=N] [--timeout=ms] [--pass-interval=ms]  (N is 1-10, default 3)",
-  "       moda fix <fix_id> [--packet] [--wait]",
-  "       moda fix start <problem_id> [--type=auto|prompt] [--wait] [--timeout=ms]",
-  "       moda fix verify <fix_id> [--prompt-file=PATH] [--no-wait] [--timeout=ms] [--yes]",
-  "       moda fix checkout <fix_id>",
-  "       moda fix submit <fix_id> --pr | --local-ref=<branch>",
-  "       moda fix mark-applied <fix_id> [--note=TEXT]",
-  "       moda fix dismiss <fix_id> --reason=TEXT"
-].join(`
-`);
-var FIXES_SUBCOMMAND_FLAGS = {
-  list: ["cursor", "limit", "status"],
-  "draft-batch": ["limit"],
-  drive: ["status", "timeout", "pass-interval", "max-fixes"]
-};
-var FIX_SUBCOMMAND_FLAGS = {
-  detail: ["packet", "timeout", "wait", "poll-interval"],
-  start: ["timeout", "type", "wait", "poll-interval", "problem-id"],
-  verify: ["timeout", "wait", "fix-id", "no-wait", "poll-interval", "prompt-file"],
-  checkout: ["fix-id"],
-  submit: ["pr", "fix-id", "local-ref"],
-  "mark-applied": ["note", "fix-id"],
-  dismiss: ["reason", "fix-id"]
-};
-function assertWaitFlags(flags) {
-  const maxByFlag = {
-    timeout: MAX_WAIT_TIMEOUT_MS,
-    "poll-interval": MAX_POLL_INTERVAL_MS,
-    "pass-interval": MAX_POLL_INTERVAL_MS
-  };
-  for (const [name, max] of Object.entries(maxByFlag)) {
-    const raw = flags[name];
-    if (raw === undefined)
-      continue;
-    const value = Number(raw);
-    if (!/^\d+$/.test(raw.trim()) || !Number.isSafeInteger(value) || value < 1 || value > max) {
-      throw new CliInputError(`--${name}=${raw} must be a whole number of milliseconds between 1 and ${max}, so nothing was sent.`, FIX_USAGE);
-    }
-  }
-}
-async function runFixesCommand(context) {
-  const fixesSub = context.positional && FIXES_SUBCOMMAND_FLAGS[context.positional] ? context.positional : "list";
-  assertFlags(fixesSub === "list" ? "fixes" : `fixes ${fixesSub}`, context.flags, [...FIXES_SUBCOMMAND_FLAGS[fixesSub], "tenant-id"]);
-  assertWaitFlags(context.flags);
-  validateConfig();
-  const profileOptions = profileOptionsFor(context);
-  const tenantId = requireTenantId(context.flags, profileOptions);
-  switch (context.positional) {
-    case "draft-batch":
-      return runFixesDraftBatch(context, profileOptions, tenantId);
-    case "drive":
-      return runFixesDrive(context, profileOptions, tenantId);
-    case undefined:
-      break;
-    default:
-      throw new CliInputError(`Unknown fixes subcommand '${context.positional}'`, FIX_USAGE);
-  }
-  const query = new URLSearchParams;
-  const status = (context.flags.status ?? "").trim().toUpperCase();
-  if (context.flags.status !== undefined && !status) {
-    throw new CliInputError("--status must name a fix status.", FIX_USAGE);
-  }
-  if (status)
-    query.set("status", status);
-  if (context.flags.limit) {
-    const limit = Number(context.flags.limit);
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-      throw new CliInputError(`--limit must be an integer between 1 and 100 (got ${context.flags.limit})`, FIX_USAGE);
-    }
-    query.set("limit", String(limit));
-  }
-  if (context.flags.cursor)
-    query.set("cursor", context.flags.cursor);
-  const suffix = query.toString() ? `?${query.toString()}` : "";
-  const data = await callControlAPI(`${fixesBase(tenantId)}${suffix}`, { method: "GET" }, profileOptions);
-  const fixes = data.fixes ?? [];
-  if (context.outputMode === "human") {
-    if (fixes.length === 0) {
-      process.stderr.write("No fixes in the queue. Draft one with `moda fix start <problem_id> --wait`.\n");
-    } else {
-      for (const fix of fixes) {
-        process.stderr.write(`MODA-FIX-${fix.shortRef}	${fix.status}	${fix.fixType}	${fix.id}	${fix.statusReason ?? ""}
-`);
-      }
-    }
-  }
-  context.output.writeData(data, {
-    summary: {
-      text: `${fixes.length} fix(es)${context.flags.status ? ` with status ${context.flags.status}` : ""} in the ranked queue.`,
-      confidence: "high"
-    },
-    nextCommands: fixes.slice(0, 1).map((fix) => ({
-      command: `moda fix ${shellArg(fix.id)}`,
-      purpose: "Open the top-ranked fix (status, gate result, next actions).",
-      mutability: "read",
-      requires_approval: false
-    }))
-  });
-  return EXIT_OK;
-}
-async function runFixesDraftBatch(context, profileOptions, tenantId) {
-  const usage = "Usage: moda fixes draft-batch [--limit=N]  (N is 1-25, default 5)";
-  let limit = DRAFT_BATCH_LIMIT_DEFAULT;
-  if (context.flags.limit) {
-    const parsed = Number(context.flags.limit);
-    if (!Number.isInteger(parsed) || parsed < 1 || parsed > DRAFT_BATCH_LIMIT_MAX) {
-      throw new CliInputError(`--limit must be an integer between 1 and ${DRAFT_BATCH_LIMIT_MAX} (got ${context.flags.limit}) — batches cap at ${DRAFT_BATCH_LIMIT_MAX} (LLM spend guard)`, usage);
-    }
-    limit = parsed;
-  }
-  const result = await callControlAPI(`${fixesBase(tenantId)}/draft-batch`, { method: "POST", body: JSON.stringify({ limit }) }, profileOptions, { timeoutMs: DRAFT_BATCH_TIMEOUT_MS, retries: 0 });
-  const drafted = result.drafted ?? [];
-  const skipped = result.skipped ?? [];
-  if (context.outputMode === "human") {
-    const w = (line) => process.stderr.write(`${line}
-`);
-    w(`Drafted ${drafted.length} fix(es) (batch cap ${DRAFT_BATCH_LIMIT_MAX} — LLM spend guard):`);
-    for (const fix of drafted) {
-      w(`  MODA-FIX-${fix.shortRef}	${fix.status}	problem ${fix.problemId}`);
-    }
-    if (skipped.length > 0) {
-      w(`Skipped ${skipped.length} problem(s):`);
-      for (const skip of skipped) {
-        w(`  ${skip.problemId}: ${skip.reason}`);
-      }
-    }
-    if (drafted.length > 0) {
-      w("Next: moda fixes drive");
-    }
-  }
-  context.output.writeData({
-    drafted: drafted.map((fix) => ({
-      fixId: fix.id,
-      shortRef: fix.shortRef,
-      problemId: fix.problemId,
-      status: fix.status,
-      problemRank: fix.problemRank ?? null
-    })),
-    skipped
-  }, {
-    summary: {
-      text: `Drafted ${drafted.length} fix(es) for the top-ranked problems; skipped ${skipped.length} (reasons in data.skipped). Batches cap at ${DRAFT_BATCH_LIMIT_MAX} — an LLM spend guard; run another batch after this one lands.`,
-      confidence: "high"
-    },
-    nextCommands: drafted.length > 0 ? [
-      {
-        command: "moda fixes drive",
-        purpose: "Round-robin advance every drafted fix (scope → propose → gate) until all rest.",
-        mutability: "write",
-        requires_approval: false
-      }
-    ] : []
-  });
-  return EXIT_OK;
-}
-function driveStatePath(tenantId, profileOptions) {
-  const safeTenant = tenantId.replace(/[^A-Za-z0-9_-]/g, "_");
-  return join(getModaPaths(profileOptions).dir, `fixes-drive-last.${safeTenant}.json`);
-}
-function lastDrivenTimes(tenantId, profileOptions) {
-  try {
-    const raw = JSON.parse(readFileSync(driveStatePath(tenantId, profileOptions), "utf8"));
-    if (Array.isArray(raw)) {
-      return new Map(raw.filter((id) => typeof id === "string").map((id) => [id, Date.now()]));
-    }
-    const out = new Map;
-    for (const [id, at] of Object.entries(raw ?? {})) {
-      if (typeof at === "number" && Number.isFinite(at))
-        out.set(id, at);
-    }
-    return out;
-  } catch {
-    return new Map;
-  }
-}
-function recordDrivenFixIds(tenantId, ids, previous, profileOptions) {
-  try {
-    const now = Date.now();
-    const merged = new Map(previous);
-    for (const id of ids)
-      merged.set(id, now);
-    const entries = [...merged.entries()].sort((left, right) => right[1] - left[1]).slice(0, 500);
-    const path = driveStatePath(tenantId, profileOptions);
-    mkdirSync(dirname(path), { recursive: true });
-    const tmp = `${path}.${process.pid}.${now}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify(Object.fromEntries(entries))}
-`, { mode: 384 });
-    renameSync(tmp, path);
-  } catch {}
-}
-async function runFixesDrive(context, profileOptions, tenantId) {
-  const timeoutMs = parsePositiveInt(context.flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, MAX_WAIT_TIMEOUT_MS);
-  const passIntervalMs = parsePositiveInt(context.flags["pass-interval"], DRIVE_PASS_INTERVAL_MS, MAX_POLL_INTERVAL_MS);
-  const deadline = Date.now() + timeoutMs;
-  let maxFixes = DRIVE_MAX_FIXES_DEFAULT;
-  if (context.flags["max-fixes"] !== undefined) {
-    const parsed = Number(context.flags["max-fixes"]);
-    if (!Number.isInteger(parsed) || parsed < 1 || parsed > DRIVE_MAX_FIXES_MAX) {
-      throw new CliInputError(`--max-fixes must be an integer between 1 and ${DRIVE_MAX_FIXES_MAX} (got ${context.flags["max-fixes"]}) — each driven fix can run hundreds of replay playouts`, FIX_USAGE);
-    }
-    maxFixes = parsed;
-  }
-  const statusFilter = (context.flags.status ?? "").trim().toUpperCase();
-  if (statusFilter && !ADVANCING_STATUSES.has(statusFilter)) {
-    throw new CliInputError(`--status must be one of the advancing statuses (${[...ADVANCING_STATUSES].join(", ")}) — a resting fix has nothing to drive (got ${context.flags.status})`, FIX_USAGE);
-  }
-  const statusParam = statusFilter ? `&status=${encodeURIComponent(statusFilter)}` : "";
-  const snapshot = [];
-  const snapshotWarnings = [];
-  let coverageTruncated = false;
-  const seenIds = new Set;
-  let reorderDetected = false;
-  let multiPage = false;
-  let scanTruncated = false;
-  let cursor = null;
-  for (let page = 0;page < DRIVE_LIST_MAX_PAGES; page++) {
-    const data = await callControlAPI(`${fixesBase(tenantId)}?limit=${DRIVE_LIST_LIMIT}${statusParam}` + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""), { method: "GET" }, profileOptions);
-    for (const fix of data.fixes ?? []) {
-      if (seenIds.has(fix.id)) {
-        if (!reorderDetected) {
-          reorderDetected = true;
-          coverageTruncated = true;
-          snapshotWarnings.push("The fix queue was re-ranked while paging (a page repeated a fix), so rows may have shifted past the page boundary and been skipped — coverage is not guaranteed. Re-run `moda fixes drive` to pick up anything missed.");
-        }
-        continue;
-      }
-      seenIds.add(fix.id);
-      snapshot.push(fix);
-    }
-    if (data.pagination?.scan_truncated) {
-      coverageTruncated = true;
-      scanTruncated = true;
-      snapshotWarnings.push(statusFilter ? `Status ${statusFilter} alone exceeds the backend list scan window — driving the newest ${snapshot.length}; older ${statusFilter} fixes are not reachable through drive, advance them directly with \`moda fix <id> --wait\`.` : "Fix queue exceeds the backend list scan window — driving the newest fixes only. Re-running unfiltered rescans the same rows; drive each advancing status separately (`moda fixes drive --status SCOPING`, `--status PROPOSED`, …) — a status filter narrows the server-side scan window and reaches older fixes.");
-    }
-    cursor = data.pagination?.has_more ? data.pagination?.next_cursor ?? null : null;
-    if (!cursor)
-      break;
-    if (!multiPage) {
-      multiPage = true;
-      coverageTruncated = true;
-      snapshotWarnings.push("The queue needed more than one page, and the backend re-ranks it per request — rows can shift across a page boundary and be skipped without any visible duplicate, so this drive cannot prove it covered every advancing fix. Re-run `moda fixes drive` until it exits 0 (single page = provably complete).");
-    }
-    if (page === DRIVE_LIST_MAX_PAGES - 1) {
-      coverageTruncated = true;
-      scanTruncated = true;
-      snapshotWarnings.push(`Fix queue exceeds ${DRIVE_LIST_LIMIT * DRIVE_LIST_MAX_PAGES} rows — driving the first ${snapshot.length}; narrow with \`moda fixes drive --status <ADVANCING_STATUS>\` to reach the rest (a plain re-run pages the same rank order).`);
-    }
-  }
-  const tracked = new Map;
-  const skipped = [];
-  const advancing = snapshot.filter((fix) => ADVANCING_STATUSES.has(fix.status) && !isRestingProposed(fix));
-  const drivenAt = lastDrivenTimes(tenantId, profileOptions);
-  const rankOf = new Map(advancing.map((fix, index) => [fix.id, index]));
-  const byLeastRecent = [...advancing].sort((left, right) => {
-    const leftAt = drivenAt.get(left.id) ?? -1;
-    const rightAt = drivenAt.get(right.id) ?? -1;
-    return leftAt !== rightAt ? leftAt - rightAt : (rankOf.get(left.id) ?? 0) - (rankOf.get(right.id) ?? 0);
-  });
-  const picked = new Set(byLeastRecent.slice(0, maxFixes).map((fix) => fix.id));
-  for (const fix of advancing) {
-    if (picked.has(fix.id))
-      tracked.set(fix.id, fix);
-    else
-      skipped.push(fix);
-  }
-  recordDrivenFixIds(tenantId, [...picked], drivenAt, profileOptions);
-  const gatingCount = [...tracked.values()].filter((fix) => fix.status === "GATING").length;
-  if (skipped.length > 0) {
-    coverageTruncated = true;
-    snapshotWarnings.push(`Drove ${tracked.size} fix(es) (--max-fixes=${maxFixes}; ${gatingCount} already gating; least-recently-driven first); skipped ${skipped.length} advancing fix(es): ${skipped.map((fix) => `MODA-FIX-${fix.shortRef}`).join(", ")}. Re-run \`moda fixes drive\` to drive the next ones.`);
-  }
-  if (tracked.size === 0) {
-    context.output.writeData({
-      fixes: [],
-      passes: 0,
-      rested: 0,
-      stragglers: [],
-      timedOut: false,
-      coverageTruncated
-    }, {
-      ...coverageTruncated ? { status: "degraded" } : {},
-      summary: {
-        text: coverageTruncated ? "Nothing advancing inside the scanned window, but the queue scan was truncated — fixes outside it may still be advancing (see warnings)." : "No fixes in an advancing status — nothing to drive.",
-        confidence: coverageTruncated ? "medium" : "high"
-      },
-      ...snapshotWarnings.length > 0 ? { warnings: snapshotWarnings } : {},
-      nextCommands: [
-        {
-          command: "moda fixes draft-batch",
-          purpose: "Batch-draft fixes for the top-ranked problems (cap 25 — LLM spend guard).",
-          mutability: "write",
-          requires_approval: true
-        }
-      ]
-    });
-    return coverageTruncated ? EXIT_DEGRADED : EXIT_OK;
-  }
-  const isRested = (fix) => !ADVANCING_STATUSES.has(fix.status) || isRestingProposed(fix);
-  const activeIds = () => [...tracked.values()].filter((fix) => !isRested(fix)).map((fix) => fix.id);
-  const lastAnnounced = new Map;
-  const announce = (row) => {
-    if (lastAnnounced.get(row.id) === row.status)
-      return;
-    lastAnnounced.set(row.id, row.status);
-    announceFixTransition(context, row);
-  };
-  for (const fix of tracked.values())
-    announce(fix);
-  const errors = new Map;
-  let errorCount = 0;
-  let passes = 0;
-  let timedOut = false;
-  while (activeIds().length > 0) {
-    if (Date.now() >= deadline) {
-      timedOut = true;
-      break;
-    }
-    passes += 1;
-    for (const fixId of activeIds()) {
-      if (Date.now() >= deadline) {
-        timedOut = true;
-        break;
-      }
-      try {
-        const next = await advanceFix(tenantId, fixId, profileOptions);
-        tracked.set(fixId, next);
-        errors.delete(fixId);
-        announce(next);
-      } catch (err) {
-        errorCount += 1;
-        const message = err instanceof Error ? err.message : String(err);
-        errors.set(fixId, message);
-        if (context.outputMode === "human") {
-          const known = tracked.get(fixId);
-          process.stderr.write(`fix MODA-FIX-${known?.shortRef ?? fixId}: advance failed — ${message}
-`);
-        }
-      }
-    }
-    if (timedOut || activeIds().length === 0)
-      break;
-    await sleep(passIntervalMs);
-  }
-  const landings = [...tracked.values()].map((fix) => ({
-    shortRef: fix.shortRef,
-    status: fix.status,
-    fixType: fix.fixType,
-    statusReason: fix.statusReason ?? null
-  }));
-  const stragglers = [...tracked.values()].filter((fix) => !isRested(fix));
-  const skippedRefs = skipped.map((fix) => fix.shortRef);
-  const warnings = [
-    ...snapshotWarnings,
-    ...[...errors.entries()].map(([fixId, message]) => {
-      const fix = tracked.get(fixId);
-      return `advance failed for MODA-FIX-${fix?.shortRef ?? fixId}: ${message}`;
-    })
-  ];
-  if (errorCount > errors.size) {
-    warnings.push(`${errorCount} advance error(s) total across ${passes} pass(es) — each was retried on the next pass.`);
-  }
-  const degraded = timedOut || coverageTruncated;
-  const restedCount = tracked.size - stragglers.length;
-  const coverageNote = coverageTruncated ? " Coverage was incomplete: the queue scan was truncated, so fixes outside the scanned window were never driven (see warnings)." : "";
-  if (context.outputMode === "human") {
-    process.stderr.write(timedOut ? `
-Timed out after ${timeoutMs}ms with ${stragglers.length} of ${tracked.size} fix(es) still advancing.${coverageNote}
-` : `
-${coverageTruncated ? `Rested all ${tracked.size} scanned fix(es)` : `All ${tracked.size} fix(es) rested`} after ${passes} pass(es).${coverageNote}
-`);
-  }
-  context.output.writeData({
-    fixes: landings,
-    passes,
-    rested: restedCount,
-    stragglers: stragglers.map((fix) => fix.shortRef),
-    timedOut,
-    coverageTruncated,
-    maxFixes,
-    skipped: skippedRefs
-  }, {
-    ...degraded ? { status: "degraded" } : {},
-    summary: {
-      text: timedOut ? `Drive timed out after ${timeoutMs}ms: ${stragglers.length} of ${tracked.size} fix(es) still advancing (${stragglers.map((fix) => `MODA-FIX-${fix.shortRef}`).join(", ")}). Re-run \`moda fixes drive\` to resume.${coverageNote}` : coverageTruncated ? `Rested all ${tracked.size} scanned fix(es) after ${passes} pass(es), but the queue was NOT swept.${coverageNote}` : `All ${tracked.size} fix(es) rested after ${passes} pass(es).`,
-      confidence: "high"
-    },
-    ...warnings.length > 0 ? { warnings } : {},
-    nextCommands: [
-      ...timedOut ? [{
-        command: "moda fixes drive",
-        purpose: "Resume driving the stragglers — advance-on-poll picks up where it left off.",
-        mutability: "write",
-        requires_approval: false
-      }] : coverageTruncated ? [
-        ...skipped.length > 0 || !scanTruncated ? [{
-          command: "moda fixes drive",
-          purpose: skipped.length > 0 ? `Drive the next ${Math.min(skipped.length, maxFixes)} of the ${skipped.length} skipped fix(es) (--max-fixes spend cap).` : "The queue was re-ranked mid-page — re-run to pick up any fix that shifted past the boundary.",
-          mutability: "write",
-          requires_approval: false
-        }] : [],
-        ...scanTruncated ? [{
-          command: statusFilter ? "moda fix <fix_id> --wait" : "moda fixes drive --status=SCOPING",
-          purpose: statusFilter ? `Status ${statusFilter} overflows the scan window — advance the older fixes individually.` : "Drive each advancing status separately to reach fixes outside the unfiltered scan window.",
-          mutability: "write",
-          requires_approval: false
-        }] : []
-      ] : [{
-        command: "moda fixes",
-        purpose: "Review where every fix landed (VERIFIED fixes are ready to deliver).",
-        mutability: "read",
-        requires_approval: false
-      }]
-    ]
-  });
-  return degraded ? EXIT_DEGRADED : EXIT_OK;
-}
-async function runFixCommand(context) {
-  const fixSub = context.positional && FIX_SUBCOMMAND_FLAGS[context.positional] ? context.positional : "detail";
-  assertFlags(fixSub === "detail" ? "fix" : `fix ${fixSub}`, context.flags, [...FIX_SUBCOMMAND_FLAGS[fixSub], "tenant-id"]);
-  assertWaitFlags(context.flags);
-  validateConfig();
-  const profileOptions = profileOptionsFor(context);
-  const tenantId = requireTenantId(context.flags, profileOptions);
-  const sub = context.positional;
-  if (!sub) {
-    throw new CliInputError("A fix id or subcommand is required", FIX_USAGE);
-  }
-  switch (sub) {
-    case "start":
-      return runFixStart(context, profileOptions, tenantId);
-    case "verify":
-      return runFixVerify(context, profileOptions, tenantId);
-    case "checkout":
-      return runFixCheckout(context, profileOptions, tenantId);
-    case "submit":
-      return runFixSubmit(context, profileOptions, tenantId);
-    case "mark-applied":
-      return runFixMarkApplied(context, profileOptions, tenantId);
-    case "dismiss":
-      return runFixDismiss(context, profileOptions, tenantId);
-    default:
-      return runFixDetail(context, profileOptions, tenantId, sub);
-  }
-}
-async function runFixStart(context, profileOptions, tenantId) {
-  const problemId = (context.positionals[1] || context.flags["problem-id"] || "").trim();
-  if (!problemId) {
-    throw new CliInputError("<problem_id> is required", "Usage: moda fix start <problem_id> [--type=auto|prompt] [--wait] [--timeout=ms] [--poll-interval=ms]");
-  }
-  const fixType = context.flags.type;
-  if (fixType !== undefined && fixType !== "auto" && fixType !== "prompt") {
-    throw new CliInputError(`--type must be 'auto' or 'prompt'; got '${fixType}'`);
-  }
-  const created = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/problems/${encodeURIComponent(problemId)}/fixes`, { method: "POST", body: JSON.stringify(fixType ? { fixType } : {}) }, profileOptions, { timeoutMs: 120000, retries: 0 });
-  if (context.flags.wait !== "true") {
-    if (context.outputMode === "human") {
-      process.stderr.write(`Fix MODA-FIX-${created.shortRef} (${created.id}) drafted for problem ${created.problemId} — status ${created.status}.
-`);
-    }
-    context.output.writeData(created, {
-      summary: {
-        text: `Fix MODA-FIX-${created.shortRef} drafted (status ${created.status}). Re-run with --wait to drive the pipeline.`,
-        confidence: "high"
-      },
-      nextCommands: [
-        {
-          command: `moda fix start ${shellArg(problemId)} --wait`,
-          purpose: "Drive the pipeline (scope → propose → gate) to a resting status.",
-          mutability: "write",
-          requires_approval: false
-        },
-        {
-          command: `moda fix ${shellArg(created.id)}`,
-          purpose: "Inspect the fix status and gate result.",
-          mutability: "read",
-          requires_approval: false
-        }
-      ]
-    });
-    return EXIT_OK;
-  }
-  const timeoutMs = parsePositiveInt(context.flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, MAX_WAIT_TIMEOUT_MS);
-  const pollIntervalMs = parsePositiveInt(context.flags["poll-interval"], DEFAULT_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS);
-  const fix = await driveAdvance({
-    tenantId,
-    fixId: created.id,
-    initial: created,
-    timeoutMs,
-    pollIntervalMs,
-    profileOptions,
-    context
-  });
-  const packet = await fetchPacketFailSoft(tenantId, created.id, profileOptions);
-  const fidelityCopy = fixVerifiedFidelityCopy(fix);
-  if (context.outputMode === "human") {
-    process.stderr.write(`
-Fix MODA-FIX-${fix.shortRef} rested at ${fix.status}${fidelityCopy ? ` — ${fidelityCopy}` : ""}${fix.statusReason ? ` — ${fix.statusReason}` : ""}
-`);
-  }
-  context.output.writeData({ fix, ...packet ? { packet } : {} }, {
-    summary: {
-      text: `Fix MODA-FIX-${fix.shortRef} reached ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.${fidelityCopy ? ` ${fidelityCopy}.` : ""}`,
-      confidence: "high"
-    },
-    findings: gateFindings(fix),
-    nextCommands: nextCommandsFor(fix)
-  });
-  return EXIT_OK;
-}
-async function runFixVerify(context, profileOptions, tenantId) {
-  const usage = "Usage: moda fix verify <fix_id> [--prompt-file=PATH] [--no-wait] [--timeout=ms] [--poll-interval=ms]";
-  const fixId = (context.positionals[1] || context.flags["fix-id"] || "").trim();
-  if (!fixId) {
-    throw new CliInputError("<fix_id> is required", usage);
-  }
-  let candidateContent;
-  const promptFile = context.flags["prompt-file"];
-  if (promptFile) {
-    const absPath = isAbsolute(promptFile) ? promptFile : resolve(process.cwd(), promptFile);
-    if (!existsSync(absPath)) {
-      throw new CliInputError(`--prompt-file not found: ${promptFile}`, usage);
-    }
-    candidateContent = readFileSync(absPath, "utf8");
-    if (candidateContent.trim().length < 40) {
-      throw new CliInputError("--prompt-file content is shorter than 40 characters — refusing to gate a truncated candidate");
-    }
-  }
-  const candidateHash = candidateContent === undefined ? undefined : sha256(candidateContent.trim());
-  if (!context.yes) {
-    await assertRegateCooldown(tenantId, fixId, context, profileOptions, candidateHash);
-  }
-  const enqueue = await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/verify`, { method: "POST", body: JSON.stringify(candidateContent ? { candidateContent } : {}) }, profileOptions, { timeoutMs: 120000, retries: 0 });
-  const noWait = context.flags.wait === "false" || context.flags["no-wait"] === "true";
-  if (noWait) {
-    context.output.writeData({ fixId, gateRunId: enqueue.gateRunId, status: "GATING" }, {
-      summary: {
-        text: `Gate + control runs enqueued (gate run ${enqueue.gateRunId}). Resume with \`moda fix ${shellArg(fixId)} --wait\`.`,
-        confidence: "high"
-      },
-      nextCommands: [
-        {
-          command: `moda fix ${shellArg(fixId)} --wait`,
-          purpose: "Drive the advance-on-poll gate to a verdict.",
-          mutability: "write",
-          requires_approval: false
-        }
-      ]
-    });
-    return EXIT_OK;
-  }
-  const timeoutMs = parsePositiveInt(context.flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, MAX_WAIT_TIMEOUT_MS);
-  const pollIntervalMs = parsePositiveInt(context.flags["poll-interval"], DEFAULT_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS);
-  const deadline = Date.now() + timeoutMs;
-  let fix = await advanceFix(tenantId, fixId, profileOptions);
-  while (fix.status === "GATING") {
-    if (Date.now() >= deadline) {
-      throw new Error(`Timed out after ${timeoutMs}ms waiting for gate run ${enqueue.gateRunId} to finish`);
-    }
-    if (context.outputMode === "human") {
-      process.stderr.write(`Waiting for gate run (${fix.statusReason || "running"})...
-`);
-    }
-    await sleep(pollIntervalMs);
-    fix = await advanceFix(tenantId, fixId, profileOptions);
-  }
-  const warnings = [];
-  if (fix.gateRunId && fix.gateRunId !== enqueue.gateRunId) {
-    warnings.push(`The reported verdict is for gate run ${fix.gateRunId}, not the one this command enqueued (${enqueue.gateRunId}) — a concurrent verify superseded it.`);
-  }
-  const gateResult = fix.gateResult ?? null;
-  const verdict = gateResult?.verdict ?? "";
-  let exitCode;
-  let envelopeStatus;
-  if (fix.status === "VERIFIED" && verdict === "pass") {
-    exitCode = EXIT_OK;
-    envelopeStatus = "success";
-  } else if (fix.status === "GATE_FAILED" || verdict === "fail") {
-    exitCode = EXIT_ERROR;
-    envelopeStatus = "error";
-  } else {
-    exitCode = EXIT_DEGRADED;
-    envelopeStatus = "degraded";
-  }
-  let cases = [];
-  if (exitCode === EXIT_ERROR && fix.replaySetId) {
-    try {
-      const payload = await fetchLatestRun(tenantId, String(fix.replaySetId), enqueue.gateRunId, profileOptions);
-      if (payload.run?.runId === enqueue.gateRunId) {
-        cases = payload.cases;
-      }
-    } catch {
-      warnings.push("Could not load per-case gate results — see the replay run in the dashboard.");
-    }
-  }
-  if (context.outputMode === "human") {
-    printHumanGateVerdict(fix, enqueue.gateRunId, gateResult, cases);
-  }
-  const findings = gateFindings(fix);
-  for (const row of cases.slice(0, PER_CASE_FINDINGS_CAP)) {
-    const baseline = passLabel(row.prodPass);
-    const candidate = passLabel(row.proposedPass);
-    findings.push({
-      id: `case:${row.caseId}`,
-      title: `${row.caseId}: baseline=${baseline} candidate=${candidate}`,
-      status: candidate,
-      severity: baseline === "pass" && candidate === "fail" ? "error" : candidate === "fail" ? "warning" : "info"
-    });
-  }
-  const fidelityCopy = verifiedFidelityCopy(gateResult);
-  context.output.writeData({
-    fixId: fix.id,
-    shortRef: fix.shortRef,
-    status: fix.status,
-    gateRunId: enqueue.gateRunId,
-    verdict: verdict || null,
-    gateResult,
-    ...gateResult?.baselineFidelity ? { baselineFidelity: gateResult.baselineFidelity } : {},
-    ...gateResult?.counterfactual ? { counterfactual: gateResult.counterfactual } : {},
-    ...cases.length > 0 ? { cases } : {}
-  }, {
-    status: envelopeStatus,
-    summary: {
-      text: verdict === "pass" ? `${fidelityCopy ? `${fidelityCopy}. ` : ""}Gate passed on the frozen holdout: ${gateResult?.reason ?? ""}`.trim() : verdict === "fail" ? `Gate failed: ${gateResult?.reason ?? fix.statusReason ?? "candidate did not beat baseline"}` : `Gate degraded (${fix.status}): ${gateResult?.reason ?? fix.statusReason ?? "no verdict"}`,
-      confidence: "high"
-    },
-    findings,
-    warnings,
-    nextCommands: nextCommandsFor(fix)
-  });
-  return exitCode;
-}
-async function runFixCheckout(context, profileOptions, tenantId) {
-  const fixId = (context.positionals[1] || context.flags["fix-id"] || "").trim();
-  if (!fixId) {
-    throw new CliInputError("<fix_id> is required", "Usage: moda fix checkout <fix_id>");
-  }
-  const fix = await getFix(tenantId, fixId, profileOptions);
-  if (isArtifactFix(fix)) {
-    throw new CliInputError(`Fix MODA-FIX-${fix.shortRef} is a ${fix.fixType} fix — its candidate is applied in your own stack, not checked out. Run \`moda fix ${shellArg(fixId)} --packet\` for the candidate (written as local artifacts), apply it, then confirm with \`moda fix mark-applied ${shellArg(fixId)}\`.`);
-  }
-  if (!fix.targetSourcePath) {
-    throw new CliInputError(`Fix MODA-FIX-${fix.shortRef} has no target source path — ${fix.fixType} fixes are packet-only. Run \`moda fix ${shellArg(fixId)} --packet\` for the diagnosis packet.`);
-  }
-  const candidateVersionId = fix.candidateRef?.promptVersionId ?? "";
-  if (!candidateVersionId) {
-    throw new CliInputError(`Fix MODA-FIX-${fix.shortRef} has no registered candidate version yet (status ${fix.status}). Run \`moda fix start ${shellArg(fix.problemId)} --wait\` to propose one, or edit the target locally and gate it with \`moda fix verify ${shellArg(fixId)} --prompt-file=<path>\`.`);
-  }
-  if (!fix.promptId) {
-    throw new CliInputError(`Fix MODA-FIX-${fix.shortRef} has no routed prompt — the candidate content cannot be resolved.`);
-  }
-  const prompt = await callControlAPI(`/prompts/${encodeURIComponent(String(fix.promptId))}`, { method: "GET" }, profileOptions);
-  const version = (prompt.versions ?? []).find((row) => row.id === candidateVersionId);
-  if (!version || typeof version.content !== "string" || !version.content) {
-    throw new Error(`Candidate prompt version ${candidateVersionId} not found in the registry`);
-  }
-  const relPath = safeTargetSourcePath(String(fix.targetSourcePath));
-  const absPath = join(process.cwd(), relPath);
-  assertRealpathContained(absPath, relPath);
-  const writeStatus = writeContainedFile(absPath, relPath, version.content);
-  const branch = `moda/fix/${String(fix.shortRef).toLowerCase()}`;
-  const magicWord = `Fixes MODA-FIX-${fix.shortRef}`;
-  if (context.outputMode === "human") {
-    process.stderr.write([
-      `${writeStatus} ${relPath} (candidate ${candidateVersionId})`,
-      "",
-      "Next steps (the CLI never runs git — branching and committing are yours):",
-      `  1. git checkout -b ${branch}`,
-      `  2. Review the diff. Re-gate any edits: moda fix verify ${shellArg(fix.id)} --prompt-file=${shellArg(relPath)}`,
-      `  3. Hand back: moda fix submit ${shellArg(fix.id)} --pr   (or --local-ref=${shellArg(branch)})`,
-      `     A hand-authored PR body must end with the magic word: ${magicWord}`,
-      ""
-    ].join(`
-`));
-  }
-  context.output.writeData({
-    fixId: fix.id,
-    shortRef: fix.shortRef,
-    path: relPath,
-    writeStatus,
-    branch,
-    magicWord,
-    candidateVersionId
-  }, {
-    summary: {
-      text: `Candidate for MODA-FIX-${fix.shortRef} ${writeStatus === "unchanged" ? "already matches" : "written to"} ${relPath}. Create branch ${branch} yourself — the CLI never runs git.`,
-      confidence: "high"
-    },
-    artifacts: [
-      {
-        kind: "fix_candidate",
-        path: relPath,
-        description: `Candidate content for fix MODA-FIX-${fix.shortRef} (prompt version ${candidateVersionId}).`
-      }
-    ],
-    nextCommands: [
-      {
-        command: `moda fix verify ${shellArg(fix.id)} --prompt-file=${shellArg(relPath)}`,
-        purpose: "Re-gate the (possibly edited) local candidate on the frozen holdout.",
-        mutability: "write",
-        requires_approval: false
-      },
-      {
-        command: `moda fix submit ${shellArg(fix.id)} --pr`,
-        purpose: `Open the draft fix PR (branch ${branch}, magic word "${magicWord}").`,
-        mutability: "write",
-        requires_approval: true
-      }
-    ]
-  });
-  return EXIT_OK;
-}
-async function runFixSubmit(context, profileOptions, tenantId) {
-  const usage = "Usage: moda fix submit <fix_id> --pr | --local-ref=<branch>";
-  const fixId = (context.positionals[1] || context.flags["fix-id"] || "").trim();
-  if (!fixId) {
-    throw new CliInputError("<fix_id> is required", usage);
-  }
-  const wantPr = context.flags.pr === "true";
-  const localRef = (context.flags["local-ref"] ?? "").trim();
-  if (wantPr === (localRef !== "")) {
-    throw new CliInputError("Pass exactly one of --pr or --local-ref=<branch>", usage);
-  }
-  const result = await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/submit`, {
-    method: "POST",
-    body: JSON.stringify(wantPr ? { channel: "pr" } : { channel: "local_ref", localRef })
-  }, profileOptions, { timeoutMs: 120000, retries: 0 });
-  if (context.outputMode === "human") {
-    process.stderr.write(result.prUrl ? `Draft PR open: ${result.prUrl} (${result.prBranch ?? ""}) — merging it confirms the fix.
-` : `Fix recorded as ${result.status}${result.prBranch ? ` on ${result.prBranch}` : ""}.
-`);
-  }
-  context.output.writeData({ fixId, ...result }, {
-    summary: {
-      text: result.prUrl ? `Draft fix PR open at ${result.prUrl}. Merging with the magic word confirms the fix and starts monitoring.` : `Fix ${fixId} recorded as ${result.status}${result.prBranch ? ` on branch ${result.prBranch}` : ""}. Land the branch with the magic word in the PR body to confirm the fix.`,
-      confidence: "high"
-    },
-    nextCommands: [
-      {
-        command: `moda fix ${shellArg(fixId)}`,
-        purpose: "Track delivery and confirmation status.",
-        mutability: "read",
-        requires_approval: false
-      }
-    ]
-  });
-  return EXIT_OK;
-}
-async function runFixMarkApplied(context, profileOptions, tenantId) {
-  const usage = "Usage: moda fix mark-applied <fix_id> [--note=TEXT]";
-  const fixId = (context.positionals[1] || context.flags["fix-id"] || "").trim();
-  if (!fixId) {
-    throw new CliInputError("<fix_id> is required", usage);
-  }
-  const note = (context.flags.note ?? "").trim();
-  if (note.length > 600) {
-    throw new CliInputError(`--note must be 600 characters or fewer (got ${note.length})`, usage);
-  }
-  const fix = await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/mark-applied`, { method: "POST", body: JSON.stringify(note ? { note } : {}) }, profileOptions, { timeoutMs: 60000, retries: 0 });
-  if (context.outputMode === "human") {
-    process.stderr.write(fix.duplicate === true ? `Fix MODA-FIX-${fix.shortRef} was already confirmed (${fix.status}) — duplicate no-op; the mark_fixed feedback was re-posted.
-` : `Fix MODA-FIX-${fix.shortRef} marked applied (${fix.status}) — mark_fixed feedback posted, monitoring for recurrence.
-`);
-  }
-  context.output.writeData(fix, {
-    summary: {
-      text: fix.duplicate === true ? `Fix MODA-FIX-${fix.shortRef} was already confirmed (${fix.status}); mark-applied was a duplicate no-op.` : `Fix MODA-FIX-${fix.shortRef} marked applied — status ${fix.status}; the problem enters fixed-monitoring.`,
-      confidence: "high"
-    },
-    nextCommands: [
-      {
-        command: `moda fix ${shellArg(fix.id)}`,
-        purpose: "Track confirmation monitoring (HELD after 14 clean days; REGRESSED on reopen).",
-        mutability: "read",
-        requires_approval: false
-      }
-    ]
-  });
-  return EXIT_OK;
-}
-async function runFixDismiss(context, profileOptions, tenantId) {
-  const usage = "Usage: moda fix dismiss <fix_id> --reason=TEXT";
-  const fixId = (context.positionals[1] || context.flags["fix-id"] || "").trim();
-  if (!fixId) {
-    throw new CliInputError("<fix_id> is required", usage);
-  }
-  const reason = context.flags.reason;
-  if (!reason || !reason.trim()) {
-    throw new CliInputError("--reason=TEXT is required (it feeds problem feedback)", usage);
-  }
-  const fix = await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/dismiss`, { method: "POST", body: JSON.stringify({ reason }) }, profileOptions, { timeoutMs: 60000, retries: 0 });
-  if (context.outputMode === "human") {
-    process.stderr.write(`Fix MODA-FIX-${fix.shortRef} dismissed (${fix.status}).
-`);
-  }
-  context.output.writeData(fix, {
-    summary: {
-      text: `Fix MODA-FIX-${fix.shortRef} dismissed — the reason was recorded as problem feedback.`,
-      confidence: "high"
-    }
-  });
-  return EXIT_OK;
-}
-async function runFixDetail(context, profileOptions, tenantId, fixId) {
-  if (context.flags.packet === "true") {
-    const packet = await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/packet`, { method: "GET" }, profileOptions);
-    const extras = materializePacketCandidates(packet, fixId, context.outputMode === "human");
-    context.output.writeData(packet, {
-      summary: {
-        text: `moda.fix_packet.v1 for fix ${fixId}.${extras.summarySuffix}`,
-        confidence: "high"
-      },
-      ...extras.findings.length > 0 ? { findings: extras.findings } : {},
-      ...extras.artifacts.length > 0 ? { artifacts: extras.artifacts } : {},
-      ...extras.warnings.length > 0 ? { warnings: extras.warnings } : {},
-      ...extras.nextCommands.length > 0 ? { nextCommands: extras.nextCommands } : {}
-    });
-    return EXIT_OK;
-  }
-  let fix = await getFix(tenantId, fixId, profileOptions);
-  if (context.flags.wait === "true" && ADVANCING_STATUSES.has(fix.status)) {
-    const timeoutMs = parsePositiveInt(context.flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, MAX_WAIT_TIMEOUT_MS);
-    const pollIntervalMs = parsePositiveInt(context.flags["poll-interval"], DEFAULT_POLL_INTERVAL_MS, MAX_POLL_INTERVAL_MS);
-    fix = await driveAdvance({
-      tenantId,
-      fixId,
-      initial: fix,
-      timeoutMs,
-      pollIntervalMs,
-      profileOptions,
-      context
-    });
-  }
-  const fidelityCopy = fixVerifiedFidelityCopy(fix);
-  const detailCf = counterfactualBlock(fix.gateResult ?? null);
-  if (context.outputMode === "human") {
-    process.stderr.write(`MODA-FIX-${fix.shortRef}  ${fix.status}  ${fix.fixType}${fidelityCopy ? `  — ${fidelityCopy}` : ""}${fix.statusReason ? `  — ${fix.statusReason}` : ""}
-`);
-    if (detailCf) {
-      process.stderr.write(`${counterfactualHumanLine(detailCf)}
-`);
-    }
-  }
-  context.output.writeData(fix, {
-    summary: {
-      text: `Fix MODA-FIX-${fix.shortRef} is ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.${fidelityCopy ? ` ${fidelityCopy}.` : ""}`,
-      confidence: "high"
-    },
-    findings: gateFindings(fix),
-    nextCommands: nextCommandsFor(fix)
-  });
-  return EXIT_OK;
-}
-async function driveAdvance(args) {
-  const deadline = Date.now() + args.timeoutMs;
-  let fix = args.initial;
-  let lastStatus = "";
-  const announce = (row) => {
-    if (row.status === lastStatus)
-      return;
-    lastStatus = row.status;
-    announceFixTransition(args.context, row);
-  };
-  announce(fix);
-  while (ADVANCING_STATUSES.has(fix.status)) {
-    if (Date.now() >= deadline) {
-      throw new Error(`Timed out after ${args.timeoutMs}ms waiting for fix ${args.fixId} (status ${fix.status})`);
-    }
-    fix = await advanceFix(args.tenantId, args.fixId, args.profileOptions);
-    announce(fix);
-    if (!ADVANCING_STATUSES.has(fix.status))
-      break;
-    if (isRestingProposed(fix)) {
-      break;
-    }
-    await sleep(fix.status === "GATING" ? args.pollIntervalMs : Math.min(STEP_DELAY_MS, args.pollIntervalMs));
-  }
-  return fix;
-}
-function profileOptionsFor(context) {
-  return { profile: context.profile, env: context.env };
-}
-function requireTenantId(flags, profileOptions) {
-  const tenantId = flags["tenant-id"] || resolveApiTenantId(profileOptions);
-  if (!tenantId) {
-    throw new CliInputError("Missing tenant id. Run `moda init` or pass --tenant-id=<id>.");
-  }
-  return tenantId;
-}
-function fixesBase(tenantId) {
-  return `/tenants/${encodeURIComponent(tenantId)}/fixes`;
-}
-async function assertRegateCooldown(tenantId, fixId, context, profileOptions, candidateHash) {
-  const current = await getFix(tenantId, fixId, profileOptions);
-  if (candidateHash && current.candidateRef?.contentSha256 !== candidateHash)
-    return;
-  const gate = current.gateResult ?? null;
-  if (!REGATE_COOLDOWN_STATUSES.has(current.status) || !gate?.verdict || gate.pending)
-    return;
-  const landedAt = typeof gate.completedAt === "string" ? Date.parse(gate.completedAt) : Number.NaN;
-  if (Number.isNaN(landedAt))
-    return;
-  const ageMs = Date.now() - landedAt;
-  if (ageMs >= VERIFY_COOLDOWN_MS)
-    return;
-  const waitMin = Math.ceil((VERIFY_COOLDOWN_MS - ageMs) / 60000);
-  const rerun = ["moda", "fix", "verify", shellArg(fixId), ...Object.entries(context.flags).filter(([key]) => key !== "yes" && key !== "fix-id").map(([key, value]) => value === "true" ? `--${key}` : `--${key}=${shellArg(value)}`), "--yes"].join(" ");
-  throw new CliInputError(`MODA-FIX-${current.shortRef} was gated ${Math.max(0, Math.floor(ageMs / 60000))} min ago (verdict ${gate.verdict}); re-gating within 10 minutes re-runs the replay. Nothing was sent.`, `Wait ~${waitMin} min, or re-run with --yes to gate now: ${rerun}`);
-}
-function sha256(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
-}
-async function getFix(tenantId, fixId, profileOptions) {
-  return await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}`, { method: "GET" }, profileOptions);
-}
-async function advanceFix(tenantId, fixId, profileOptions) {
-  return await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/advance`, { method: "POST" }, profileOptions, { timeoutMs: ADVANCE_TIMEOUT_MS, retries: 0 });
-}
-async function fetchPacketFailSoft(tenantId, fixId, profileOptions) {
-  try {
-    return await callControlAPI(`${fixesBase(tenantId)}/${encodeURIComponent(fixId)}/packet`, { method: "GET" }, profileOptions);
-  } catch {
-    return null;
-  }
-}
-function isRestingProposed(fix) {
-  return fix.status === "PROPOSED" && /gate (pending|unavailable)/i.test(fix.statusReason ?? "");
-}
-function announceFixTransition(context, row) {
-  const line = `fix MODA-FIX-${row.shortRef}: ${row.status}${row.statusReason ? ` — ${row.statusReason}` : ""}`;
-  if (context.outputMode === "human") {
-    process.stderr.write(`${line}
-`);
-  } else if (context.outputMode === "agent-stream") {
-    context.output.writeEvent({
-      event: "progress",
-      phase: "fix",
-      message: line,
-      elapsed_ms: Date.now() - context.startedAt
-    });
-  }
-}
-function isArtifactFix(fix) {
-  return fix.fixType === "TOOL_SCHEMA" || fix.fixType === "SKILL";
-}
-function materializePacketCandidates(packet, fixId, human) {
-  const findings = [];
-  const artifacts = [];
-  const warnings = [];
-  const nextCommands = [];
-  const summaryParts = [];
-  const tool = packet.candidate_tool;
-  const skill = packet.candidate_skill;
-  const skillEdit = packet.candidate_skill_edit;
-  const hasTool = typeof tool?.proposed_description === "string" && tool.proposed_description !== "";
-  const hasSkill = typeof skill?.skill_md === "string" && skill.skill_md !== "";
-  const hasSkillEdit = typeof skillEdit?.proposed_skill_md === "string" && skillEdit.proposed_skill_md !== "";
-  if (!hasTool && !hasSkill && !hasSkillEdit) {
-    return { findings, artifacts, warnings, nextCommands, summarySuffix: "" };
-  }
-  const rawRef = typeof packet.short_ref === "string" && packet.short_ref.trim() ? packet.short_ref : fixId;
-  const ref = rawRef.replace(/[^A-Za-z0-9._-]/g, "").replace(/^\.+/, "").slice(0, 64) || "fix";
-  const w = (line) => process.stderr.write(`${line}
-`);
-  const block = (label, text) => {
-    w(`  ${label}:`);
-    for (const line of (text || "(none)").split(`
-`))
-      w(`    ${line}`);
-  };
-  const writeCandidateFile = (name, content, kind, description) => {
-    const relPath = safeTargetSourcePath(`.moda/fixes/${ref}/${name}`);
-    const absPath = join(process.cwd(), relPath);
-    try {
-      assertRealpathContained(absPath, relPath);
-      writeContainedFile(absPath, relPath, content);
-      artifacts.push({ kind, path: relPath, description });
-      return relPath;
-    } catch (error) {
-      warnings.push(`Could not write ${relPath}: ${error instanceof Error ? error.message : String(error)} — the full candidate text is still in the packet payload.`);
-      return null;
-    }
-  };
-  if (hasTool && tool) {
-    const toolName = typeof tool.tool_name === "string" && tool.tool_name ? tool.tool_name : "unknown-tool";
-    const source = typeof tool.current_description_source === "string" ? tool.current_description_source : "";
-    const paramNotes = (Array.isArray(tool.param_notes) ? tool.param_notes : []).filter((note) => typeof note === "string" && note !== "");
-    const rationale = typeof tool.rationale === "string" ? tool.rationale : "";
-    const currentPath = writeCandidateFile("tool-description.current.md", typeof tool.current_description === "string" ? tool.current_description : "", "fix_tool_description_current", `Current description of tool '${toolName}'${source ? ` (from ${source})` : ""} — the diff base.`);
-    const proposedPath = writeCandidateFile("tool-description.proposed.md", tool.proposed_description ?? "", "fix_tool_description_proposed", `Proposed description for tool '${toolName}' — apply it to your tool definition, then \`moda fix mark-applied ${shellArg(fixId)}\`.`);
-    findings.push({
-      id: "fix:candidate_tool",
-      title: `tool '${toolName}' description candidate${source ? ` (current from ${source})` : ""}`,
-      status: "proposed",
-      severity: "info",
-      ...rationale || paramNotes.length > 0 ? {
-        description: [rationale, ...paramNotes.map((note) => `param note: ${note}`)].filter(Boolean).join(`
-`)
-      } : {}
-    });
-    summaryParts.push(`Includes a tool-description candidate for '${toolName}'.`);
-    if (human) {
-      w("");
-      w(`Tool-description candidate — '${toolName}'${source ? ` (current description from ${source})` : ""}`);
-      block("current ", tool.current_description ?? "");
-      block("proposed", tool.proposed_description ?? "");
-      if (paramNotes.length > 0)
-        block("param notes", paramNotes.join(`
-`));
-      if (rationale)
-        block("rationale", rationale);
-      if (currentPath && proposedPath) {
-        w(`  diff: diff ${shellArg(currentPath)} ${shellArg(proposedPath)}`);
-      }
-    }
-  }
-  if (hasSkill && skill) {
-    const skillName = typeof skill.skill_name === "string" && skill.skill_name ? skill.skill_name : "moda-fix-skill";
-    const skillPath = writeCandidateFile("SKILL.md", skill.skill_md ?? "", "fix_candidate_skill", `Drafted SKILL.md for '${skillName}' — install it (for example .claude/skills/${skillName}/SKILL.md), then \`moda fix mark-applied ${shellArg(fixId)}\`.`);
-    findings.push({
-      id: "fix:candidate_skill",
-      title: `skill '${skillName}' drafted (SKILL.md, ${(skill.skill_md ?? "").length} chars)`,
-      status: "proposed",
-      severity: "info",
-      description: `Install the skill in your agent, then confirm with \`moda fix mark-applied ${shellArg(fixId)}\`. Gating on the replay holdout stays pending until the skill is registered with the skill harness.`
-    });
-    summaryParts.push(`Includes a drafted SKILL.md candidate ('${skillName}').`);
-    if (human) {
-      w("");
-      w(`Skill candidate — '${skillName}'`);
-      if (skillPath)
-        w(`  SKILL.md written to ${skillPath}`);
-      w(`  install it (for example .claude/skills/${skillName}/SKILL.md), then confirm:`);
-      w(`  moda fix mark-applied ${shellArg(fixId)} --note=${shellArg(`installed skill ${skillName}`)}`);
-    }
-  }
-  if (hasSkillEdit && skillEdit) {
-    const skillKey = typeof skillEdit.skill_key === "string" && skillEdit.skill_key ? skillEdit.skill_key : typeof skillEdit.skill_name === "string" && skillEdit.skill_name ? skillEdit.skill_name : "moda-skill";
-    const changeSummary = typeof skillEdit.change_summary === "string" ? skillEdit.change_summary : "";
-    const currentPath = writeCandidateFile("SKILL.current.md", typeof skillEdit.current_skill_md === "string" ? skillEdit.current_skill_md : "", "fix_skill_edit_current", `Current SKILL.md of your synced skill '${skillKey}' — the diff base.`);
-    const proposedPath = writeCandidateFile("SKILL.proposed.md", skillEdit.proposed_skill_md ?? "", "fix_skill_edit_proposed", `Proposed SKILL.md for '${skillKey}' (minimal edit) — apply it to the existing skill in your repo, then \`moda fix mark-applied ${shellArg(fixId)}\`.`);
-    findings.push({
-      id: "fix:candidate_skill_edit",
-      title: `skill '${skillKey}' edit proposed${changeSummary ? `: ${changeSummary}` : " (minimal delta to the existing skill)"}`,
-      status: "proposed",
-      severity: "info",
-      description: `This amends the EXISTING synced skill '${skillKey}' — a minimal delta, not a new skill. Apply the proposed SKILL.md in your repo, then confirm with \`moda fix mark-applied ${shellArg(fixId)}\`.`
-    });
-    summaryParts.push(`Includes a skill-edit candidate amending existing skill '${skillKey}'.`);
-    if (human) {
-      w("");
-      w(`Skill-edit candidate — amends existing skill '${skillKey}'`);
-      if (changeSummary)
-        block("change summary", changeSummary);
-      if (currentPath)
-        w(`  current SKILL.md written to ${currentPath}`);
-      if (proposedPath)
-        w(`  proposed SKILL.md written to ${proposedPath}`);
-      if (currentPath && proposedPath)
-        w(`  diff: diff ${shellArg(currentPath)} ${shellArg(proposedPath)}`);
-      w(`  apply the edit to the existing skill in your repo, then confirm:`);
-      w(`  moda fix mark-applied ${shellArg(fixId)} --note=${shellArg(`amended skill ${skillKey}`)}`);
-    }
-  }
-  nextCommands.push({
-    command: `moda fix mark-applied ${shellArg(fixId)} --note="where/how you applied it"`,
-    purpose: "Confirm you applied the candidate in your own stack (no PR) — flips the fix to SHIPPED and starts recurrence monitoring.",
-    mutability: "write",
-    requires_approval: true
-  });
-  return {
-    findings,
-    artifacts,
-    warnings,
-    nextCommands,
-    summarySuffix: summaryParts.length > 0 ? ` ${summaryParts.join(" ")}` : ""
-  };
-}
-function baselineFidelityDescriptor(gate) {
-  const fidelity = gate?.baselineFidelity;
-  const base = fidelity?.prompt === "tenant" ? "tenant prompt baseline" : fidelity?.prompt === "generic" ? "standard-agent baseline" : null;
-  if (fidelity?.skills === "observed") {
-    return `${base ?? "baseline"} · skill recovered from production receipts`;
-  }
-  return base;
-}
-function verifiedFidelityCopy(gate) {
-  const descriptor = baselineFidelityDescriptor(gate);
-  return descriptor ? `Verified — ${descriptor}` : null;
-}
-function counterfactualBlock(gate) {
-  if (!gate || gate.pending === true)
-    return null;
-  const cf = gate.counterfactual;
-  if (!cf || typeof cf !== "object" || typeof cf.verdict !== "string" || !cf.verdict)
-    return null;
-  return cf;
-}
-function counterfactualSentence(cf) {
-  return `prevented ${cf.wins ?? 0} of ${cf.informative ?? 0} replayed production failures (control still failed in ${cf.informative ?? 0}; regressions ${cf.losses ?? 0})`;
-}
-function counterfactualHumanLine(cf) {
-  return `Counterfactual: ${cf.verdict} — ${counterfactualSentence(cf)}; anchors ${cf.anchors ?? 0}, abstained ${cf.abstained ?? 0}`;
-}
-function fixVerifiedFidelityCopy(fix) {
-  if (fix.status !== "VERIFIED")
-    return null;
-  return verifiedFidelityCopy(fix.gateResult ?? null);
-}
-function gateFindings(fix) {
-  const gateResult = fix.gateResult ?? null;
-  if (!gateResult || gateResult.pending === true)
-    return [];
-  const verdict = gateResult.verdict ?? fix.status;
-  const fidelity = baselineFidelityDescriptor(gateResult);
-  const cf = counterfactualBlock(gateResult);
-  return [
-    {
-      id: "fix:gate",
-      title: `gate ${verdict}: ${gateResult.reason ?? fix.statusReason ?? ""}`.trim(),
-      status: verdict,
-      severity: verdict === "pass" ? "info" : verdict === "fail" ? "error" : "warning",
-      description: `${formatGateScoreboard(gateResult)}${fidelity ? `; baseline fidelity: ${fidelity}` : ""}` + `${cf ? `; counterfactual ${cf.verdict}: ${counterfactualSentence(cf)} (anchors ${cf.anchors ?? 0}, abstained ${cf.abstained ?? 0})` : ""}`
-    }
-  ];
-}
-function formatGateScoreboard(gate) {
-  const holdout = gate.holdout ?? {};
-  const repair = gate.repair ?? {};
-  const guard = gate.byScope?.regression_guard;
-  return `${gate.byScope ? "in-problem holdout" : "holdout"}: candidate ${holdout.candidate ?? 0}/${holdout.n ?? 0} vs baseline ${holdout.baseline ?? 0}/${holdout.n ?? 0} ` + `(wins ${holdout.wins ?? 0}, losses ${holdout.losses ?? 0}); ` + (guard ? `regression guards: candidate ${guard.candidate ?? 0}/${guard.n ?? 0} vs baseline ${guard.baseline ?? 0}/${guard.n ?? 0} ` + `(losses ${guard.losses ?? 0}, noise floor ${guard.noiseFloor ?? 0}); ` : "") + `training cases (repair): candidate ${repair.candidate ?? 0}/${repair.n ?? 0} vs baseline ${repair.baseline ?? 0}/${repair.n ?? 0}; ` + `noise floor ${gate.noiseFloor ?? 0}; abstained ${gate.abstained ?? 0}`;
-}
-function printHumanGateVerdict(fix, gateRunId, gateResult, cases) {
-  const w = (line) => process.stderr.write(`${line}
-`);
-  w("");
-  w("Fix gate verdict");
-  w("----------------");
-  w(`Fix:      MODA-FIX-${fix.shortRef} (${fix.status})`);
-  w(`Gate run: ${gateRunId}`);
-  w(`Verdict:  ${gateResult?.verdict ?? "none"}${gateResult?.reason ? ` — ${gateResult.reason}` : ""}`);
-  const fidelity = baselineFidelityDescriptor(gateResult);
-  if (fidelity) {
-    w(`Baseline: ${fidelity}`);
-  }
-  if (gateResult) {
-    w(`Score:    ${formatGateScoreboard(gateResult)}`);
-  }
-  const cf = counterfactualBlock(gateResult);
-  if (cf) {
-    w(counterfactualHumanLine(cf));
-  }
-  if (cases.length > 0) {
-    w("");
-    w("Per-case (holdout is the verdict; repair rows are training cases):");
-    for (const row of cases) {
-      w(`  ${row.caseId}: baseline=${passLabel(row.prodPass)} candidate=${passLabel(row.proposedPass)}`);
-    }
-  }
-  w("");
-}
-function passLabel(value) {
-  if (value === null || value === undefined)
-    return "abstained";
-  return value ? "pass" : "fail";
-}
-function nextCommandsFor(fix) {
-  const packetCommand = {
-    command: `moda fix ${shellArg(fix.id)} --packet`,
-    purpose: "Read the packet — the tool/skill candidate is written as local artifacts to apply in your own stack.",
-    mutability: "write",
-    requires_approval: false
-  };
-  const markAppliedCommand = {
-    command: `moda fix mark-applied ${shellArg(fix.id)} --note="where/how you applied it"`,
-    purpose: "Confirm you applied the candidate in your own stack (no PR) — flips the fix to SHIPPED and starts recurrence monitoring.",
-    mutability: "write",
-    requires_approval: true
-  };
-  const skillGatePending = fix.fixType === "SKILL" && (fix.candidateRef?.kind === "skill_edit" || fix.candidateRef?.kind === "skill" && !fix.candidateRef?.skillId);
-  switch (fix.status) {
-    case "VERIFIED":
-      if (isArtifactFix(fix)) {
-        return [packetCommand, markAppliedCommand];
-      }
-      return [
-        {
-          command: `moda fix submit ${shellArg(fix.id)} --pr`,
-          purpose: "Open the draft fix PR (merge with the magic word to confirm).",
-          mutability: "write",
-          requires_approval: true
-        },
-        {
-          command: `moda fix checkout ${shellArg(fix.id)}`,
-          purpose: "Write the verified candidate locally instead of opening a PR.",
-          mutability: "write",
-          requires_approval: false
-        }
-      ];
-    case "PROPOSED":
-      if (skillGatePending) {
-        return [packetCommand, markAppliedCommand];
-      }
-      return [
-        {
-          command: `moda fix verify ${shellArg(fix.id)}`,
-          purpose: "Gate the proposed candidate on the frozen holdout.",
-          mutability: "write",
-          requires_approval: false
-        }
-      ];
-    case "GATE_FAILED":
-      if (isArtifactFix(fix)) {
-        return [
-          {
-            command: `moda fix verify ${shellArg(fix.id)}`,
-            purpose: "Re-gate the stored candidate on the frozen holdout.",
-            mutability: "write",
-            requires_approval: false
-          },
-          packetCommand
-        ];
-      }
-      return [
-        {
-          command: `moda fix checkout ${shellArg(fix.id)}`,
-          purpose: "Check out the candidate, edit it, and re-gate (fail-to-pass loop).",
-          mutability: "write",
-          requires_approval: false
-        },
-        {
-          command: `moda fix verify ${shellArg(fix.id)} --prompt-file=<path>`,
-          purpose: "Re-gate an edited local candidate on the frozen holdout.",
-          mutability: "write",
-          requires_approval: false
-        }
-      ];
-    case "GATE_INCONCLUSIVE":
-      return [
-        {
-          command: `moda fix verify ${shellArg(fix.id)}`,
-          purpose: "Re-run the gate — the last run was inconclusive (never a pass).",
-          mutability: "write",
-          requires_approval: false
-        }
-      ];
-    case "UNROUTED":
-      return [
-        {
-          command: `moda fix ${shellArg(fix.id)} --packet`,
-          purpose: "Read the investigation packet — this fix is deliverable as diagnosis.",
-          mutability: "read",
-          requires_approval: false
-        },
-        {
-          command: "moda prompts status",
-          purpose: "If the reason says evidence carries no prompt version: check the prompt lockfile, then pass prompt: lock.prompts['<key>'] to createThinkTelemetry / createAI7Telemetry (docs.moda.dev/prompt-management/attribution).",
-          mutability: "read",
-          requires_approval: false
-        }
-      ];
-    case "NO_EVIDENCE":
-    case "BLOCKED_COVERAGE":
-    case "NO_HEADROOM":
-      return [
-        {
-          command: `moda fix ${shellArg(fix.id)} --packet`,
-          purpose: "Read the investigation packet — this fix is deliverable as diagnosis.",
-          mutability: "read",
-          requires_approval: false
-        }
-      ];
-    case "DRAFT":
-    case "SCOPING":
-    case "PROPOSING":
-    case "GATING":
-      return [
-        {
-          command: `moda fix ${shellArg(fix.id)} --wait`,
-          purpose: "Drive the advance-on-poll pipeline to its next resting status.",
-          mutability: "write",
-          requires_approval: false
-        }
-      ];
-    default:
-      return [
-        {
-          command: `moda fix ${shellArg(fix.id)}`,
-          purpose: "Track the fix status.",
-          mutability: "read",
-          requires_approval: false
-        }
-      ];
-  }
-}
-function assertRealpathContained(absPath, relPath) {
-  const root = realpathSync(process.cwd());
-  const within = (p) => p === root || p.startsWith(root + sep);
-  const segments = absPath.slice(root.length).split(sep).filter(Boolean);
-  let probe = root;
-  for (const segment of segments) {
-    probe = join(probe, segment);
-    let stat;
-    try {
-      stat = lstatSync(probe);
-    } catch {
-      break;
-    }
-    if (stat.isSymbolicLink()) {
-      throw new CliInputError(`Refusing to write through a symlink: ${relPath}`);
-    }
-    if (stat.isFile() && stat.nlink > 1) {
-      throw new CliInputError(`Refusing to write through a hard link (${stat.nlink} names share this file): ${relPath} — replace it with an independent copy (cp then rm the link) and re-run.`);
-    }
-    if (!within(realpathSync(probe))) {
-      throw new CliInputError(`Refusing to write outside the repo: ${relPath} resolves past the working tree`);
-    }
-  }
-}
-function writeContainedFile(absPath, relPath, content) {
-  mkdirSync(dirname(absPath), { recursive: true });
-  const existedBefore = existsSync(absPath);
-  let fd;
-  try {
-    fd = openSync(absPath, fsConstants.O_RDWR | fsConstants.O_CREAT | O_NOFOLLOW, 420);
-  } catch (error) {
-    if (error.code === "ELOOP") {
-      throw new CliInputError(`Refusing to write through a symlink: ${relPath}`);
-    }
-    throw error;
-  }
-  try {
-    const stat = fstatSync(fd);
-    if (!stat.isFile()) {
-      throw new CliInputError(`Refusing to write ${relPath}: not a regular file`);
-    }
-    if (stat.nlink > 1) {
-      throw new CliInputError(`Refusing to write through a hard link (${stat.nlink} names share this file): ${relPath} — replace it with an independent copy (cp then rm the link) and re-run.`);
-    }
-    if (readFileSync(fd, "utf8") === content) {
-      return "unchanged";
-    }
-    ftruncateSync(fd, 0);
-    writeSync(fd, content, 0, "utf8");
-    return existedBefore ? "updated" : "wrote";
-  } finally {
-    closeSync(fd);
-  }
-}
-function safeTargetSourcePath(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed || trimmed.includes("\x00")) {
-    throw new CliInputError(`Refusing to write an invalid target source path: ${JSON.stringify(raw).slice(0, 120)}`);
-  }
-  if (isAbsolute(trimmed) || /^[A-Za-z]:[\\/]/.test(trimmed)) {
-    throw new CliInputError(`Refusing to write outside the repo: target source path is absolute (${trimmed})`);
-  }
-  const segments = trimmed.split(/[\\/]+/).filter(Boolean);
-  if (segments.length === 0 || segments.some((segment) => segment === "..")) {
-    throw new CliInputError(`Refusing to write outside the repo: target source path contains '..' (${trimmed})`);
-  }
-  return segments.join("/");
-}
-function parsePositiveInt(raw, fallback, max) {
-  const parsed = Number.parseInt(raw ?? "", 10);
-  if (!Number.isFinite(parsed) || parsed <= 0)
-    return fallback;
-  return Math.min(parsed, max);
-}
-function sleep(ms) {
-  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
-}
-export {
-  writeContainedFile,
-  runFixesCommand,
-  runFixCommand
-};