@moda-ai/cli 1.28.1 → 1.28.4

package/dist/cli.js

@@ -385,9 +385,16 @@ 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_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 10)",
+  "       moda fixes drive [--status=S] [--timeout=ms] [--pass-interval=ms]",
   "       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]",
@@ -401,6 +408,16 @@ async function runFixesCommand(context) {
   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;
   if (context.flags.status)
     query.set("status", context.flags.status);
@@ -440,6 +457,251 @@ async function runFixesCommand(context) {
   });
   return EXIT_OK;
 }
+async function runFixesDraftBatch(context, profileOptions, tenantId) {
+  const usage = "Usage: moda fixes draft-batch [--limit=N]  (N is 1-25, default 10)";
+  let limit;
+  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 !== undefined ? { 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;
+}
+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;
+  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;
+  for (const fix of snapshot) {
+    if (ADVANCING_STATUSES.has(fix.status) && !isRestingProposed(fix)) {
+      tracked.set(fix.id, fix);
+    }
+  }
+  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 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
+  }, {
+    ...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 ? {
+        command: !scanTruncated ? "moda fixes drive" : statusFilter ? "moda fix <fix_id> --wait" : "moda fixes drive --status=SCOPING",
+        purpose: !scanTruncated ? "The queue was re-ranked mid-page — re-run to pick up any fix that shifted past the boundary." : 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) {
   validateConfig();
   const profileOptions = profileOptionsFor(context);
@@ -514,14 +776,15 @@ async function runFixStart(context, profileOptions, tenantId) {
     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}${fix.statusReason ? ` — ${fix.statusReason}` : ""}
+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})` : ""}.`,
+      text: `Fix MODA-FIX-${fix.shortRef} reached ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.${fidelityCopy ? ` ${fidelityCopy}.` : ""}`,
       confidence: "high"
     },
     findings: gateFindings(fix),
@@ -624,6 +887,7 @@ async function runFixVerify(context, profileOptions, tenantId) {
       severity: baseline === "pass" && candidate === "fail" ? "error" : candidate === "fail" ? "warning" : "info"
     });
   }
+  const fidelityCopy = verifiedFidelityCopy(gateResult);
   context.output.writeData({
     fixId: fix.id,
     shortRef: fix.shortRef,
@@ -631,11 +895,13 @@ async function runFixVerify(context, profileOptions, tenantId) {
     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" ? `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"}`,
+      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,
@@ -845,13 +1111,19 @@ async function runFixDetail(context, profileOptions, tenantId, fixId) {
       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}${fix.statusReason ? `  — ${fix.statusReason}` : ""}
+    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})` : ""}.`,
+      text: `Fix MODA-FIX-${fix.shortRef} is ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.${fidelityCopy ? ` ${fidelityCopy}.` : ""}`,
       confidence: "high"
     },
     findings: gateFindings(fix),
@@ -867,18 +1139,7 @@ async function driveAdvance(args) {
     if (row.status === lastStatus)
       return;
     lastStatus = row.status;
-    const line = `fix MODA-FIX-${row.shortRef}: ${row.status}${row.statusReason ? ` — ${row.statusReason}` : ""}`;
-    if (args.context.outputMode === "human") {
-      process.stderr.write(`${line}
-`);
-    } else if (args.context.outputMode === "agent-stream") {
-      args.context.output.writeEvent({
-        event: "progress",
-        phase: "fix",
-        message: line,
-        elapsed_ms: Date.now() - args.context.startedAt
-      });
-    }
+    announceFixTransition(args.context, row);
   };
   announce(fix);
   while (ADVANCING_STATUSES.has(fix.status)) {
@@ -889,7 +1150,7 @@ async function driveAdvance(args) {
     announce(fix);
     if (!ADVANCING_STATUSES.has(fix.status))
       break;
-    if (fix.status === "PROPOSED" && /gate (pending|unavailable)/i.test(fix.statusReason ?? "")) {
+    if (isRestingProposed(fix)) {
       break;
     }
     await sleep(fix.status === "GATING" ? args.pollIntervalMs : Math.min(STEP_DELAY_MS, args.pollIntervalMs));
@@ -922,6 +1183,23 @@ async function fetchPacketFailSoft(tenantId, fixId, profileOptions) {
     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";
 }
@@ -1058,18 +1336,51 @@ function materializePacketCandidates(packet, fixId, human) {
     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)
+  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)
+      description: `${formatGateScoreboard(gateResult)}${fidelity ? `; baseline fidelity: ${fidelity}` : ""}` + `${cf ? `; counterfactual ${cf.verdict}: ${counterfactualSentence(cf)} (anchors ${cf.anchors ?? 0}, abstained ${cf.abstained ?? 0})` : ""}`
     }
   ];
 }
@@ -1087,9 +1398,17 @@ function printHumanGateVerdict(fix, gateRunId, gateResult, cases) {
   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):");
@@ -4811,7 +5130,7 @@ function buildManifest(commands) {
     exit_codes: [
       { code: 0, name: "ok", meaning: "Command completed successfully." },
       { code: 1, name: "error", meaning: "Command, input, API, network, or unexpected failure." },
-      { code: 3, name: "degraded", meaning: "Degraded result: `moda ask` local fallback, or `moda fix verify` gate inconclusive/blocked-coverage (never treat as a pass)." },
+      { code: 3, name: "degraded", meaning: "Degraded result: `moda ask` local fallback, `moda fix verify` gate inconclusive/blocked-coverage (never treat as a pass), or `moda fixes drive` timeout with fixes still advancing." },
       { code: 4, name: "auth_required", meaning: "Run login_command, then resume." },
       { code: 5, name: "input_required", meaning: "Choose from input_request choices, then resume." },
       { code: 130, name: "cancelled", meaning: "Interrupted or output consumer closed." }
@@ -4882,7 +5201,7 @@ function event(name, when, terminal, deprecated = false) {
 function exitCodesForCommand(command) {
   if (command === "ask")
     return [0, 1, 3, 4, 5, 130];
-  if (command === "fix")
+  if (command === "fix" || command === "fixes")
     return [0, 1, 3, 4, 130];
   if (command === "init" || command === "harness")
     return [0, 1, 4, 5, 130];
@@ -5055,6 +5374,12 @@ Commands:
 
   Fixes (a fix with proof):
   fixes                            Ranked Fix queue (--status=S --limit=N --cursor=TOKEN)
+  fixes draft-batch                Campaign mode: batch-draft fixes for the top-ranked problems
+                                   (--limit=N, 1-25, default 10 — batches cap at 25: LLM spend guard)
+  fixes drive                      Round-robin one advance per active fix per pass until all rest
+                                   (--status=S narrows the server-side scan window to one advancing
+                                   status, --timeout=ms default 2h, --pass-interval=ms default 20s;
+                                   exit 3 when the timeout lapses with fixes still advancing)
   fix <fix_id>                     One Fix: status + gate result; --packet prints moda.fix_packet.v1
                                    (tool/skill candidates are also written under .moda/fixes/<ref>/);
                                    --wait drives a still-running pipeline to rest
@@ -6704,11 +7029,17 @@ var commandRegistry = createCommandRegistry([
   },
   {
     name: "fixes",
-    description: 'List the ranked queue of Fixes ("a fix with proof") for this tenant',
-    examples: ["moda fixes", "moda fixes --status=VERIFIED", "moda fixes --limit=10"],
+    description: 'List the ranked queue of Fixes ("a fix with proof"); campaign mode batch-drafts and drives them',
+    examples: [
+      "moda fixes",
+      "moda fixes --status=VERIFIED",
+      "moda fixes draft-batch --limit=10",
+      "moda fixes drive",
+      "moda fixes drive --status=SCOPING"
+    ],
     auth: "none",
     outputModes: ["human", "json", "agent"],
-    mutability: "read",
+    mutability: "write",
     validateConfigBeforeRun: false,
     resetApiRequestCountBeforeRun: false,
     telemetry: "result",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.28.1",
+  "version": "1.28.4",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-08-19T22:54:45.735Z",
-  "cli_version": "1.28.1",
+  "bundled_at": "2026-08-23T02:04:41.686Z",
+  "cli_version": "1.28.4",
   "skills": [
     {
       "id": "integration-node-anthropic",