@moda-ai/cli 1.28.0 → 1.28.3

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,12 @@ async function runFixVerify(context, profileOptions, tenantId) {
     gateRunId: enqueue.gateRunId,
     verdict: verdict || null,
     gateResult,
+    ...gateResult?.baselineFidelity ? { baselineFidelity: gateResult.baselineFidelity } : {},
     ...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 +1110,14 @@ async function runFixDetail(context, profileOptions, tenantId, fixId) {
       context
     });
   }
+  const fidelityCopy = fixVerifiedFidelityCopy(fix);
   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}` : ""}
 `);
   }
   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 +1133,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 +1144,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 +1177,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";
 }
@@ -933,9 +1205,11 @@ function materializePacketCandidates(packet, fixId, human) {
   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 !== "";
-  if (!hasTool && !hasSkill) {
+  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;
@@ -1014,6 +1288,34 @@ function materializePacketCandidates(packet, fixId, human) {
       w(`  moda fix mark-applied ${fixId} --note="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 ${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 ${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 ${currentPath} ${proposedPath}`);
+      w(`  apply the edit to the existing skill in your repo, then confirm:`);
+      w(`  moda fix mark-applied ${fixId} --note="amended skill ${skillKey}"`);
+    }
+  }
   nextCommands.push({
     command: `moda fix mark-applied ${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.",
@@ -1028,18 +1330,36 @@ 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 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);
   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}` : ""}`
     }
   ];
 }
@@ -1057,6 +1377,10 @@ 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)}`);
   }
@@ -1087,7 +1411,7 @@ function nextCommandsFor(fix) {
     mutability: "write",
     requires_approval: true
   };
-  const skillGatePending = fix.fixType === "SKILL" && fix.candidateRef?.kind === "skill" && !fix.candidateRef?.skillId;
+  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)) {
@@ -4781,7 +5105,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." }
@@ -4852,7 +5176,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];
@@ -5025,6 +5349,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
@@ -6674,11 +7004,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.0",
+  "version": "1.28.3",
   "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-19T21:29:46.133Z",
-  "cli_version": "1.28.0",
+  "bundled_at": "2026-08-21T03:28:44.293Z",
+  "cli_version": "1.28.3",
   "skills": [
     {
       "id": "integration-node-anthropic",