@moda-ai/cli 1.26.0 → 1.27.1

package/dist/cli.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_WAIT_TIMEOUT_MS,
   buildDoctorReport,
+  fetchLatestRun,
   runDoctorCommand,
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-xf5nx5hc.js";
+} from "./cli-cjqzrp9k.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -359,6 +362,909 @@ function embeddedWindowSize(conversation) {
   return Math.min(center - from, to - center);
 }
 
+// src/fix.ts
+import {
+  closeSync,
+  constants as fsConstants,
+  existsSync,
+  fstatSync,
+  ftruncateSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  writeSync
+} from "node:fs";
+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 ADVANCING_STATUSES = new Set(["DRAFT", "SCOPING", "PROPOSING", "PROPOSED", "GATING"]);
+var FIX_USAGE = [
+  "Usage: moda fixes [--status=S] [--limit=N] [--cursor=TOKEN]",
+  "       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]",
+  "       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(`
+`);
+async function runFixesCommand(context) {
+  validateConfig();
+  const profileOptions = profileOptionsFor(context);
+  const tenantId = requireTenantId(context.flags, profileOptions);
+  const query = new URLSearchParams;
+  if (context.flags.status)
+    query.set("status", context.flags.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 ${fix.id}`,
+      purpose: "Open the top-ranked fix (status, gate result, next actions).",
+      mutability: "read",
+      requires_approval: false
+    }))
+  });
+  return EXIT_OK;
+}
+async function runFixCommand(context) {
+  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 ${problemId} --wait`,
+          purpose: "Drive the pipeline (scope → propose → gate) to a resting status.",
+          mutability: "write",
+          requires_approval: false
+        },
+        {
+          command: `moda fix ${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);
+  if (context.outputMode === "human") {
+    process.stderr.write(`
+Fix MODA-FIX-${fix.shortRef} rested at ${fix.status}${fix.statusReason ? ` — ${fix.statusReason}` : ""}
+`);
+  }
+  context.output.writeData({ fix, ...packet ? { packet } : {} }, {
+    summary: {
+      text: `Fix MODA-FIX-${fix.shortRef} reached ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.`,
+      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 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 ${fixId} --wait\`.`,
+        confidence: "high"
+      },
+      nextCommands: [
+        {
+          command: `moda fix ${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"
+    });
+  }
+  context.output.writeData({
+    fixId: fix.id,
+    shortRef: fix.shortRef,
+    status: fix.status,
+    gateRunId: enqueue.gateRunId,
+    verdict: verdict || null,
+    gateResult,
+    ...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"}`,
+      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 ${fixId} --packet\` for the candidate (written as local artifacts), apply it, then confirm with \`moda fix mark-applied ${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 ${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 ${fix.problemId} --wait\` to propose one, or edit the target locally and gate it with \`moda fix verify ${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 ${fix.id} --prompt-file=${relPath}`,
+      `  3. Hand back: moda fix submit ${fix.id} --pr   (or --local-ref=${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 ${fix.id} --prompt-file=${relPath}`,
+        purpose: "Re-gate the (possibly edited) local candidate on the frozen holdout.",
+        mutability: "write",
+        requires_approval: false
+      },
+      {
+        command: `moda fix submit ${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 ${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 ${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
+    });
+  }
+  if (context.outputMode === "human") {
+    process.stderr.write(`MODA-FIX-${fix.shortRef}  ${fix.status}  ${fix.fixType}${fix.statusReason ? `  — ${fix.statusReason}` : ""}
+`);
+  }
+  context.output.writeData(fix, {
+    summary: {
+      text: `Fix MODA-FIX-${fix.shortRef} is ${fix.status}${fix.statusReason ? ` (${fix.statusReason})` : ""}.`,
+      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;
+    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
+      });
+    }
+  };
+  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 (fix.status === "PROPOSED" && /gate (pending|unavailable)/i.test(fix.statusReason ?? "")) {
+      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"] || resolveTenantId(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 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 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 hasTool = typeof tool?.proposed_description === "string" && tool.proposed_description !== "";
+  const hasSkill = typeof skill?.skill_md === "string" && skill.skill_md !== "";
+  if (!hasTool && !hasSkill) {
+    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 ${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 ${currentPath} ${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 ${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 ${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 ${fixId} --note="installed skill ${skillName}"`);
+    }
+  }
+  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.",
+    mutability: "write",
+    requires_approval: true
+  });
+  return {
+    findings,
+    artifacts,
+    warnings,
+    nextCommands,
+    summarySuffix: summaryParts.length > 0 ? ` ${summaryParts.join(" ")}` : ""
+  };
+}
+function gateFindings(fix) {
+  const gateResult = fix.gateResult ?? null;
+  if (!gateResult)
+    return [];
+  const verdict = gateResult.verdict ?? fix.status;
+  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)
+    }
+  ];
+}
+function formatGateScoreboard(gate) {
+  const holdout = gate.holdout ?? {};
+  const repair = gate.repair ?? {};
+  return `holdout: candidate ${holdout.candidate ?? 0}/${holdout.n ?? 0} vs baseline ${holdout.baseline ?? 0}/${holdout.n ?? 0} ` + `(wins ${holdout.wins ?? 0}, losses ${holdout.losses ?? 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}` : ""}`);
+  if (gateResult) {
+    w(`Score:    ${formatGateScoreboard(gateResult)}`);
+  }
+  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 ${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 ${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" && !fix.candidateRef?.skillId;
+  switch (fix.status) {
+    case "VERIFIED":
+      if (isArtifactFix(fix)) {
+        return [packetCommand, markAppliedCommand];
+      }
+      return [
+        {
+          command: `moda fix submit ${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 ${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 ${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 ${fix.id}`,
+            purpose: "Re-gate the stored candidate on the frozen holdout.",
+            mutability: "write",
+            requires_approval: false
+          },
+          packetCommand
+        ];
+      }
+      return [
+        {
+          command: `moda fix checkout ${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 ${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 ${fix.id}`,
+          purpose: "Re-run the gate — the last run was inconclusive (never a pass).",
+          mutability: "write",
+          requires_approval: false
+        }
+      ];
+    case "UNROUTED":
+    case "NO_EVIDENCE":
+    case "BLOCKED_COVERAGE":
+    case "NO_HEADROOM":
+      return [
+        {
+          command: `moda fix ${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 ${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 ${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));
+}
+
 // src/sync.ts
 async function runSyncCommand(context) {
   const resource = context.positionals[0] ?? "harness";
@@ -534,8 +1440,8 @@ async function sendCliUsageTelemetry(input) {
 }
 
 // src/update-check.ts
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
 var UPDATE_CHECK_FLAG = "no-update-check";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 var REGISTRY_TIMEOUT_MS = 1500;
@@ -549,11 +1455,11 @@ function isUpdateCheckDisabled(flags, env = process.env) {
   return flags[UPDATE_CHECK_FLAG] === "true" || env.MODA_CLI_UPDATE_CHECK === "0" || env.DO_NOT_TRACK === "1" || env.CI !== undefined && env.CI !== "" && env.CI !== "false" && env.CI !== "0";
 }
 function cachePath(options = {}) {
-  return join(getModaDir(options), "update-check.json");
+  return join2(getModaDir(options), "update-check.json");
 }
 function readCache(options = {}) {
   try {
-    const parsed = JSON.parse(readFileSync(cachePath(options), "utf8"));
+    const parsed = JSON.parse(readFileSync2(cachePath(options), "utf8"));
     if (parsed && typeof parsed === "object" && typeof parsed.checked_at === "number" && typeof parsed.latest === "string") {
       return parsed;
     }
@@ -562,7 +1468,7 @@ function readCache(options = {}) {
 }
 function writeCache(cache, options = {}) {
   try {
-    mkdirSync(getModaDir(options), { recursive: true });
+    mkdirSync2(getModaDir(options), { recursive: true });
     writeFileSync(cachePath(options), `${JSON.stringify(cache, null, 2)}
 `, "utf8");
   } catch {}
@@ -1124,8 +2030,8 @@ function renderJsonSchemas() {
 
 // src/keys.ts
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 var KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS = {
   list: "GET /api/cli/keys?profile=<profile>",
   create: "POST /api/cli/keys",
@@ -1192,14 +2098,14 @@ function writeLocalApiKeySecret(descriptor, apiKey, options = {}) {
   return path;
 }
 function keyDescriptorStorePath(options = {}) {
-  return join2(getModaPaths(options).dir, "keys.json");
+  return join3(getModaPaths(options).dir, "keys.json");
 }
 function loadLocalKeyDescriptors(options = {}) {
   const path = keyDescriptorStorePath(options);
   try {
-    if (!existsSync(path))
+    if (!existsSync2(path))
       return [];
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return [];
     }
@@ -1547,12 +2453,12 @@ async function runKeysCommand(context) {
 }
 
 // src/agent.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "node:fs";
-import { join as join3, relative, resolve } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync } from "node:fs";
+import { join as join4, relative, resolve as resolve2 } from "node:path";
 var MODA_DIR = ".moda";
-var HARNESS_PATH = join3(MODA_DIR, "harness.json");
-var HARNESS_REPORT_MARKDOWN_PATH = join3(MODA_DIR, "HARNESS_REPORT.md");
-var HARNESS_SUMMARY_PATH = join3(MODA_DIR, "HARNESS.md");
+var HARNESS_PATH = join4(MODA_DIR, "harness.json");
+var HARNESS_REPORT_MARKDOWN_PATH = join4(MODA_DIR, "HARNESS_REPORT.md");
+var HARNESS_SUMMARY_PATH = join4(MODA_DIR, "HARNESS.md");
 var MAX_AGENT_EVIDENCE_BYTES = 24000;
 async function runAgentCommand(context) {
   const subcommand2 = context.positionals[0] ?? "context";
@@ -1674,7 +2580,7 @@ async function buildAgentContext(context) {
       },
       report: reportState.state,
       sync: syncState ? {
-        path: join3(MODA_DIR, "sync-state.json"),
+        path: join4(MODA_DIR, "sync-state.json"),
         exists: true,
         source: syncState.source,
         updatedAt: syncState.updatedAt,
@@ -1682,7 +2588,7 @@ async function buildAgentContext(context) {
         remoteHarnessId: syncState.remote.harnessId,
         remoteVersionId: syncState.remote.versionId
       } : {
-        path: join3(MODA_DIR, "sync-state.json"),
+        path: join4(MODA_DIR, "sync-state.json"),
         exists: false
       }
     },
@@ -1732,18 +2638,18 @@ function summarizeAgentContext(payload, noun) {
   return `Local Moda ${noun} is healthy with ${agents} runtime agent(s).`;
 }
 function readHarnessGraphIfPresent(cwd) {
-  const path = join3(cwd, HARNESS_PATH);
-  if (!existsSync2(path))
+  const path = join4(cwd, HARNESS_PATH);
+  if (!existsSync3(path))
     return;
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return;
   }
 }
 function readHarnessReportState(cwd) {
-  const path = join3(cwd, HARNESS_REPORT_PATH);
-  if (!existsSync2(path)) {
+  const path = join4(cwd, HARNESS_REPORT_PATH);
+  if (!existsSync3(path)) {
     return {
       state: {
         path: HARNESS_REPORT_PATH,
@@ -1787,11 +2693,11 @@ function readHarnessReportState(cwd) {
   }
 }
 function readApproval(cwd) {
-  const path = join3(cwd, HARNESS_REPORT_APPROVAL_PATH);
-  if (!existsSync2(path))
+  const path = join4(cwd, HARNESS_REPORT_APPROVAL_PATH);
+  if (!existsSync3(path))
     return;
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return;
   }
@@ -1867,9 +2773,9 @@ function existingArtifacts(cwd) {
     [HARNESS_REPORT_PATH, "harness_report", "Cited harness analyst report."],
     [HARNESS_REPORT_MARKDOWN_PATH, "harness_report_markdown", "Human-readable harness analyst report."],
     [HARNESS_SUMMARY_PATH, "harness_summary", "Human-readable harness graph summary."],
-    [join3(MODA_DIR, "sync-state.json"), "sync_state", "Last local harness sync state."],
-    [join3(MODA_DIR, "prompts.yml"), "prompt_manifest", "Local prompt discovery manifest."]
-  ].flatMap(([path, kind, description]) => existsSync2(join3(cwd, path)) ? [{ path, kind, description }] : []);
+    [join4(MODA_DIR, "sync-state.json"), "sync_state", "Last local harness sync state."],
+    [join4(MODA_DIR, "prompts.yml"), "prompt_manifest", "Local prompt discovery manifest."]
+  ].flatMap(([path, kind, description]) => existsSync3(join4(cwd, path)) ? [{ path, kind, description }] : []);
 }
 function expandEvidenceRef(ref, loaded, cwd) {
   if (ref.startsWith("doctor:")) {
@@ -1950,9 +2856,9 @@ function readCitationExcerpt(cwd, citation) {
   if (!citation.path || citation.type !== "file" && citation.type !== "generated_doc")
     return citation.excerpt;
   const absolute = safeResolve(cwd, citation.path);
-  if (!absolute || !existsSync2(absolute))
+  if (!absolute || !existsSync3(absolute))
     return citation.excerpt;
-  const text = readFileSync3(absolute, "utf8");
+  const text = readFileSync4(absolute, "utf8");
   if (citation.line && citation.line > 0) {
     return text.split(/\r?\n/)[citation.line - 1]?.slice(0, 1000) ?? citation.excerpt;
   }
@@ -1963,10 +2869,10 @@ function readBoundedModaArtifact(cwd, artifactPath) {
     throw new CliInputError(`Artifact '${artifactPath}' is outside .moda and cannot be expanded directly.`, "Use a citation evidence ref for source-file evidence.");
   }
   const absolute = safeResolve(cwd, artifactPath);
-  if (!absolute || !existsSync2(absolute))
+  if (!absolute || !existsSync3(absolute))
     throw missingEvidence(`artifact:${artifactPath}`);
   const size = statSync(absolute).size;
-  const text = readFileSync3(absolute, "utf8");
+  const text = readFileSync4(absolute, "utf8");
   return {
     path: artifactPath,
     bytes: size,
@@ -1975,7 +2881,7 @@ function readBoundedModaArtifact(cwd, artifactPath) {
   };
 }
 function safeResolve(cwd, path) {
-  const absolute = resolve(cwd, path);
+  const absolute = resolve2(cwd, path);
   const rel = relative(cwd, absolute);
   if (rel.startsWith("..") || rel === ".." || rel.startsWith("/"))
     return;
@@ -2009,8 +2915,8 @@ function purposeForCommand(command) {
 }
 
 // src/production-intelligence.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // src/ask-stream.ts
 class AskStreamError extends Error {
@@ -3430,12 +4336,12 @@ function loadHarnessHints(cwd) {
     skillPaths: new Map,
     entrypointPaths: []
   };
-  const harnessPath = join4(cwd, ".moda", "harness.json");
-  if (!existsSync3(harnessPath))
+  const harnessPath = join5(cwd, ".moda", "harness.json");
+  if (!existsSync4(harnessPath))
     return hints;
   hints.reportPath = ".moda/harness.json";
   try {
-    const parsed = JSON.parse(readFileSync4(harnessPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(harnessPath, "utf8"));
     const graph = asRecord(parsed);
     const artifacts = Array.isArray(graph?.artifacts) ? graph.artifacts : [];
     for (const item of artifacts) {
@@ -3463,11 +4369,11 @@ function loadHarnessHints(cwd) {
   return hints;
 }
 function localHarnessSummary(cwd) {
-  const path = join4(cwd, ".moda", "harness.json");
-  if (!existsSync3(path))
+  const path = join5(cwd, ".moda", "harness.json");
+  if (!existsSync4(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     return {
       harnessId: parsed.harnessId,
       graphHash: parsed.graphHash,
@@ -3478,16 +4384,16 @@ function localHarnessSummary(cwd) {
   }
 }
 function localSyncBrief(cwd, relativePath, label) {
-  const path = join4(cwd, relativePath);
-  if (!existsSync3(path)) {
+  const path = join5(cwd, relativePath);
+  if (!existsSync4(path)) {
     return { status: "missing", summary: `${label} state not found`, path: relativePath };
   }
   return { status: "present", summary: `${label} state exists locally`, path: relativePath };
 }
 function localSkillBrief(cwd) {
-  const claudeSkill = join4(cwd, ".claude", "skills");
-  const cursorRules = join4(cwd, ".cursor", "rules");
-  if (existsSync3(claudeSkill) || existsSync3(cursorRules)) {
+  const claudeSkill = join5(cwd, ".claude", "skills");
+  const cursorRules = join5(cwd, ".cursor", "rules");
+  if (existsSync4(claudeSkill) || existsSync4(cursorRules)) {
     return { status: "present", summary: "Local agent skill/rule directory exists" };
   }
   return { status: "missing", summary: "No local agent skill/rule directory found" };
@@ -3728,7 +4634,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: "Reserved for `moda ask` local fallback." },
+      { 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: 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." }
@@ -3799,6 +4705,8 @@ function event(name, when, terminal, deprecated = false) {
 function exitCodesForCommand(command) {
   if (command === "ask")
     return [0, 1, 3, 4, 5, 130];
+  if (command === "fix")
+    return [0, 1, 3, 4, 130];
   if (command === "init" || command === "harness")
     return [0, 1, 4, 5, 130];
   return [0, 1, 4, 130];
@@ -3806,7 +4714,7 @@ function exitCodesForCommand(command) {
 
 // src/cli.ts
 import { fileURLToPath } from "url";
-import { realpathSync } from "fs";
+import { realpathSync as realpathSync2 } from "fs";
 function parseArgs(argv) {
   const args = argv.slice(2);
   let command = "";
@@ -3967,6 +4875,21 @@ Commands:
   skills sync                      Push local .claude/skills/**/SKILL.md up to Moda
   skills sync --dry-run            Show what would be pushed without writing
 
+  Fixes (a fix with proof):
+  fixes                            Ranked Fix queue (--status=S --limit=N --cursor=TOKEN)
+  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
+  fix start <problem_id>           Draft a Fix from a Problem (--type=auto|prompt); --wait drives
+                                   scope -> propose -> gate and prints the packet
+  fix verify <fix_id>              Re-gate on the frozen holdout; --prompt-file=P gates local content
+                                   (exit 0 pass / 1 fail with per-case findings / 3 degraded-inconclusive)
+  fix checkout <fix_id>            Write the candidate at its target source path (never runs git)
+  fix submit <fix_id>              Deliver: --pr opens a draft PR | --local-ref=<branch> records your branch
+  fix mark-applied <fix_id>        Confirm a candidate you applied in your own stack (--note=TEXT);
+                                   no PR needed — flips to SHIPPED and starts monitoring
+  fix dismiss <fix_id>             Reject with --reason=TEXT (feeds problem feedback)
+
 Options:
   --help                           Show this help message
   --version                        Show version number
@@ -4162,7 +5085,11 @@ Examples:
   moda prompts sync
   moda prompts promote support.triage --label=prod --version=pver_abc123
   moda prompts ab --baseline=prompts/agent.prompt.md --candidate=prompts/agent-v2.prompt.md --conversations=conv_1,conv_2
-  moda skills pull`);
+  moda skills pull
+  moda fixes
+  moda fix start <problem_id> --wait
+  moda fix verify <fix_id> --prompt-file=prompts/agent.prompt.md
+  moda fix mark-applied <fix_id> --note="tool description updated in our agent config"`);
 }
 function printCommandHelp(definition) {
   const lines = [];
@@ -4407,7 +5334,7 @@ async function runTailCommand(params, context) {
       break;
     if (params.max_events !== undefined && emitted >= params.max_events)
       break;
-    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, intervalMs));
   }
 }
 async function attachWorldState(rows) {
@@ -5025,7 +5952,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-efv643ec.js");
+      const { runInit } = await import("./index-fwxpt51s.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",
@@ -5430,6 +6357,42 @@ var commandRegistry = createCommandRegistry([
     handler: async (context) => ({
       exitCode: await runSkillsCommand(context)
     })
+  },
+  {
+    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"],
+    auth: "none",
+    outputModes: ["human", "json", "agent"],
+    mutability: "read",
+    validateConfigBeforeRun: false,
+    resetApiRequestCountBeforeRun: false,
+    telemetry: "result",
+    handler: async (context) => ({
+      exitCode: await runFixesCommand(context)
+    })
+  },
+  {
+    name: "fix",
+    description: 'Draft, verify, check out, submit, and dismiss Fixes ("a fix with proof")',
+    examples: [
+      "moda fix start <problem_id> --wait",
+      "moda fix <fix_id> --packet",
+      "moda fix verify <fix_id> --prompt-file=prompts/agent.prompt.md",
+      "moda fix checkout <fix_id>",
+      "moda fix submit <fix_id> --pr",
+      'moda fix mark-applied <fix_id> --note="tool description updated in our agent config"',
+      'moda fix dismiss <fix_id> --reason="not actionable"'
+    ],
+    auth: "none",
+    outputModes: ["human", "json", "agent"],
+    mutability: "write",
+    validateConfigBeforeRun: false,
+    resetApiRequestCountBeforeRun: false,
+    telemetry: "result",
+    handler: async (context) => ({
+      exitCode: await runFixCommand(context)
+    })
   }
 ]);
 function classifyCliError(error) {
@@ -5677,7 +6640,7 @@ function installSignalHandlers() {
 async function main() {
   process.exitCode = await dispatchParsedCommand(parseArgs(process.argv));
 }
-var isMain = process.argv[1] && fileURLToPath(import.meta.url) === realpathSync(process.argv[1]);
+var isMain = process.argv[1] && fileURLToPath(import.meta.url) === realpathSync2(process.argv[1]);
 if (isMain) {
   installSignalHandlers();
   main().catch((error) => {