@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-VNDPQVUZ.js

@@ -0,0 +1,1853 @@
+import {
+  formatRunTaskMonitorHints,
+  hasRunTaskMonitorEvidence,
+  readRunTaskState
+} from "./chunk-DFHX4XYA.js";
+import {
+  findLabRunStateForTask
+} from "./chunk-FT7SGLXT.js";
+import {
+  extractTitleFromPrompt,
+  formatExecutionModeLabel,
+  formatTaskLabel
+} from "./chunk-2L36U25O.js";
+import {
+  defaultObserveProcess,
+  readCompetitionState,
+  resolveCliStateRoots,
+  resolveDisplayId
+} from "./chunk-AAAODV76.js";
+import {
+  resolveUnifiedStateFilePath
+} from "./chunk-NHTIXJCR.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  getPlanningRoot
+} from "./chunk-CSXLLEGB.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  parseVariantIdentifier
+} from "./chunk-TGXXYDL4.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  gatesAlsoFailingOnBase
+} from "./chunk-R2CKS6WT.js";
+import {
+  readVariantVerification
+} from "./chunk-3OPP2OZB.js";
+import {
+  firstDirWithFile,
+  resolveProjectRuntimeDir
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  formatReasoningEffortLevelForUser,
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+
+// src/cli/commands/monitor.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/core/health/snapshot.ts
+function buildRunHealthSnapshot(input = {}) {
+  return {
+    ...input,
+    status: input.status ?? "unknown",
+    now: input.now ?? Date.now()
+  };
+}
+function severityRank(severity) {
+  switch (severity) {
+    case "critical":
+      return 3;
+    case "warning":
+      return 2;
+    case "info":
+      return 1;
+  }
+}
+function summarizeRunHealth(events) {
+  const categories = Array.from(new Set(events.map((event) => event.category)));
+  const worstSeverity = events.reduce(
+    (worst, event) => severityRank(event.severity) > severityRank(worst) ? event.severity : worst,
+    "info"
+  );
+  return {
+    events,
+    worstSeverity,
+    categories
+  };
+}
+var AUTH_FAILURE_TEXT_PATTERN = /\bunauthori[sz]ed\b|\bnot (?:authenticated|logged in|signed in)\b|\b(?:please )?(?:log|sign) ?in (?:required|again)\b|\bauth(?:entication|orization)?[\s_-]*(?:failed|failure|required|missing|expired|error)\b|\b(?:invalid|missing|expired|revoked) (?:api[\s_-]?key|credentials?|(?:auth|access|oauth|refresh) token)\b|\b(?:credentials?|api[\s_-]?key|(?:auth|access|oauth) token) (?:is |are |has |have )?(?:missing|invalid|expired|revoked|not found|required)\b|\btoken (?:is |has )?(?:invalid|expired|revoked)\b|(?<!\()\b(?:invalid|expired|revoked) token\b|\b(?:status|http)[\s:=]*40[13]\b/i;
+
+// src/core/health/classifier.ts
+var DEFAULT_STALE_AFTER_MS = 10 * 60 * 1e3;
+var DEFAULT_JUDGE_CONFIDENCE_THRESHOLD = 0.65;
+var BUDGET_WARNING_RATIO = 0.9;
+var HIGH_BURN_RATE_RATIO = 1.25;
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set([
+  "queued",
+  "pending",
+  "starting",
+  "running",
+  "processing",
+  "verifying"
+]);
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function buildEvent(snapshot, input) {
+  return {
+    code: `RUN_HEALTH_${input.category.toUpperCase()}`,
+    category: input.category,
+    severity: input.severity,
+    status: input.status ?? "active",
+    title: input.title,
+    summary: input.summary,
+    evidence: input.evidence,
+    suggestedActions: input.suggestedActions ?? [],
+    runId: snapshot.runId,
+    taskId: snapshot.taskId,
+    provider: input.provider,
+    variant: input.variant,
+    detectedAt: snapshot.now
+  };
+}
+function statusIsActive(snapshot) {
+  return ACTIVE_STATUSES.has(snapshot.status);
+}
+function statusIsTerminal(snapshot) {
+  return TERMINAL_STATUSES.has(snapshot.status);
+}
+function hasAuthProblem(provider) {
+  return provider.authState === "missing" || provider.authState === "expired" || provider.authState === "invalid" || provider.lastFailurePhase === "startup" && AUTH_FAILURE_TEXT_PATTERN.test(provider.lastError ?? "");
+}
+function hasProviderHealthProblem(provider) {
+  return provider.availability === "degraded" || provider.availability === "unavailable" || provider.availability === "rate_limited" || provider.circuitState === "open" || (provider.consecutiveFailures ?? 0) >= 3;
+}
+function classifyProvider(snapshot, provider) {
+  const events = [];
+  if (hasAuthProblem(provider)) {
+    events.push(
+      buildEvent(snapshot, {
+        category: "auth_broken",
+        severity: "critical",
+        title: "Provider authentication needs attention",
+        summary: `${provider.provider} cannot run until authentication is repaired.`,
+        provider: provider.provider,
+        variant: provider.variant,
+        evidence: [
+          {
+            source: "provider_health",
+            message: provider.lastError ?? `Auth state is ${provider.authState ?? "not ready"}.`,
+            data: {
+              authState: provider.authState,
+              lastFailurePhase: provider.lastFailurePhase
+            }
+          }
+        ],
+        suggestedActions: [
+          {
+            label: "Repair provider login or credentials",
+            command: `build provider list --providers ${provider.provider}`
+          }
+        ]
+      })
+    );
+  }
+  if (hasProviderHealthProblem(provider) && !hasAuthProblem(provider)) {
+    const availability = provider.availability ?? "unknown";
+    const severity = provider.availability === "unavailable" || provider.circuitState === "open" ? "critical" : "warning";
+    events.push(
+      buildEvent(snapshot, {
+        category: "provider_unhealthy",
+        severity,
+        title: "Provider is degraded",
+        summary: `${provider.provider} is ${availability}; this run may need retry or rerouting.`,
+        provider: provider.provider,
+        variant: provider.variant,
+        evidence: [
+          {
+            source: "provider_health",
+            message: provider.lastError ?? `Provider availability is ${availability}.`,
+            data: {
+              availability: provider.availability,
+              circuitState: provider.circuitState,
+              consecutiveFailures: provider.consecutiveFailures
+            }
+          }
+        ],
+        suggestedActions: [
+          {
+            label: "Retry the run or choose another provider",
+            command: snapshot.taskId ? `build monitor ${snapshot.taskId} --detailed` : "build provider list"
+          }
+        ]
+      })
+    );
+  }
+  return events;
+}
+function classifyOwnerGone(snapshot, progress) {
+  const owner = progress.ownerPid === void 0 ? "owner process" : `owner process ${progress.ownerPid}`;
+  return buildEvent(snapshot, {
+    category: "stalled",
+    severity: "critical",
+    title: "Run owner process exited",
+    summary: `The run is still marked ${snapshot.status}, but its ${owner} is gone, so it will not finish or record a result.`,
+    evidence: [
+      {
+        source: "owner_process",
+        message: `${owner} is no longer running.`,
+        data: { ownerPid: progress.ownerPid, lastProgressAt: progress.lastProgressAt }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Inspect what the run recorded before it exited, then start the run again",
+        command: snapshot.taskId ? `build monitor ${snapshot.taskId} --detailed` : "build monitor <taskId> --detailed"
+      }
+    ]
+  });
+}
+function classifyProgress(snapshot) {
+  if (!statusIsActive(snapshot)) return null;
+  const progress = snapshot.progress;
+  if (!progress) return null;
+  if (progress.ownerProcess === "gone") return classifyOwnerGone(snapshot, progress);
+  const staleAfterMs = progress.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+  const lastActivityAt = progress.lastProgressAt ?? progress.lastHeartbeatAt;
+  const staleForMs = lastActivityAt === void 0 ? void 0 : snapshot.now - lastActivityAt;
+  const stalled = progress.stalled === true || staleForMs !== void 0 && staleForMs >= staleAfterMs;
+  if (!stalled) return null;
+  return buildEvent(snapshot, {
+    category: "stalled",
+    severity: "warning",
+    title: "Run appears stalled",
+    summary: staleForMs === void 0 ? "The run is marked active but has no recent progress signal." : `No progress has been observed for ${Math.round(staleForMs / 1e3)} seconds.`,
+    evidence: [
+      {
+        source: "progress",
+        message: progress.progressLabel ?? "Progress tracker reported no recent activity.",
+        data: {
+          lastProgressAt: progress.lastProgressAt,
+          lastHeartbeatAt: progress.lastHeartbeatAt,
+          staleAfterMs,
+          staleForMs
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Inspect the run logs",
+        command: snapshot.taskId ? `build monitor ${snapshot.taskId} --detailed` : "build monitor <taskId> --detailed"
+      }
+    ]
+  });
+}
+function classifyBudget(snapshot, budget) {
+  const limitRatio = budget.limitUsd && budget.limitUsd > 0 && budget.spentUsd !== void 0 ? budget.spentUsd / budget.limitUsd : void 0;
+  const projectedRatio = budget.limitUsd && budget.limitUsd > 0 && budget.projectedUsd !== void 0 ? budget.projectedUsd / budget.limitUsd : void 0;
+  const forecastExceeded = budget.forecastUsd && budget.forecastUsd > 0 && budget.projectedUsd !== void 0 ? budget.projectedUsd > budget.forecastUsd * HIGH_BURN_RATE_RATIO : false;
+  const burnRateExceeded = (budget.burnRateRatio ?? 0) > HIGH_BURN_RATE_RATIO;
+  if ((limitRatio ?? 0) < BUDGET_WARNING_RATIO && (projectedRatio ?? 0) < BUDGET_WARNING_RATIO && !forecastExceeded && !burnRateExceeded) {
+    return null;
+  }
+  const severity = "warning";
+  return buildEvent(snapshot, {
+    category: "budget_burn",
+    severity,
+    title: "Budget burn is above expectation",
+    summary: "Spend or projected spend is approaching the configured budget boundary.",
+    evidence: [
+      {
+        source: "budget",
+        message: "Cost telemetry indicates elevated spend.",
+        data: {
+          spentUsd: budget.spentUsd,
+          limitUsd: budget.limitUsd,
+          projectedUsd: budget.projectedUsd,
+          forecastUsd: budget.forecastUsd,
+          burnRateRatio: budget.burnRateRatio,
+          limitRatio,
+          projectedRatio
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Inspect current spend and projected cost",
+        command: snapshot.taskId ? `build telemetry cost history --task ${snapshot.taskId}` : "build telemetry cost status"
+      }
+    ]
+  });
+}
+function classifyJudge(snapshot, judge) {
+  const confidenceThreshold = judge.confidenceThreshold ?? DEFAULT_JUDGE_CONFIDENCE_THRESHOLD;
+  const lowConfidence = judge.confidence !== void 0 && judge.confidence < confidenceThreshold && (judge.completedVariants ?? 0) >= 2;
+  const disagreement = judge.status === "failed" || judge.status === "disagreement" || judge.status === "no_winner" || lowConfidence && judge.status !== "selected";
+  if (!disagreement) return null;
+  return buildEvent(snapshot, {
+    category: "judge_disagree",
+    severity: judge.status === "failed" ? "critical" : "warning",
+    title: "Judge needs escalation",
+    summary: judge.reason ?? "Completed variants did not produce a confident winner.",
+    evidence: [
+      {
+        source: "judge",
+        message: judge.reason ?? "Judge confidence is below threshold or no winner was selected.",
+        data: {
+          status: judge.status,
+          confidence: judge.confidence,
+          confidenceThreshold,
+          completedVariants: judge.completedVariants
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Review variant evidence and rerun judging if needed",
+        command: snapshot.taskId ? `build run competition results ${snapshot.taskId}` : "build run competition results <taskId>"
+      }
+    ]
+  });
+}
+function classifyOutput(snapshot, output) {
+  const parseErrors = output.parseErrors ?? [];
+  const schemaErrors = output.schemaErrors ?? [];
+  const hasDrift = output.unparseable === true || parseErrors.length > 0 || schemaErrors.length > 0;
+  if (!hasDrift) return null;
+  return buildEvent(snapshot, {
+    category: "output_drift",
+    severity: "warning",
+    title: "Provider output did not match the expected contract",
+    summary: "Build could not parse or validate part of the provider output.",
+    evidence: [
+      {
+        source: "output",
+        message: [...parseErrors, ...schemaErrors][0] ?? "Output was marked unparseable.",
+        data: {
+          parseErrors,
+          schemaErrors,
+          unparseable: output.unparseable,
+          materializedOutput: output.materializedOutput,
+          filesChanged: output.filesChanged
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Inspect provider output and parser diagnostics",
+        command: snapshot.taskId ? `build monitor ${snapshot.taskId} --detailed` : "build monitor <taskId> --detailed"
+      }
+    ]
+  });
+}
+function classifyWorktree(snapshot, worktree) {
+  const blocked = worktree.cleanupBlocked === true || worktree.reuseBlocked === true || worktree.dirty === true || worktree.staleLock === true || worktree.preservedForReview === true;
+  if (!blocked) return null;
+  return buildEvent(snapshot, {
+    category: "worktree_blocked",
+    severity: worktree.preservedForReview === true ? "info" : "warning",
+    title: "Worktree needs review before reuse",
+    summary: worktree.reason ?? "The worktree cannot be safely reused or cleaned automatically.",
+    evidence: [
+      {
+        source: "worktree",
+        message: worktree.reason ?? "Worktree state blocked automatic cleanup.",
+        data: {
+          cleanupBlocked: worktree.cleanupBlocked,
+          reuseBlocked: worktree.reuseBlocked,
+          dirty: worktree.dirty,
+          staleLock: worktree.staleLock,
+          preservedForReview: worktree.preservedForReview,
+          path: worktree.path
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Review or clean the worktree",
+        command: "build cleanup doctor"
+      }
+    ]
+  });
+}
+function classifyHandoff(snapshot) {
+  const handoff = snapshot.handoff;
+  if (!handoff) return null;
+  const terminalSuccess = handoff.runCompleted === true || statusIsTerminal(snapshot) && handoff.success === true;
+  const hasDurableResult = handoff.durableArtifactPresent === true || handoff.reviewArtifactPresent === true || handoff.applied === true;
+  if (!terminalSuccess || handoff.changesProduced !== true || hasDurableResult) return null;
+  return buildEvent(snapshot, {
+    category: "handoff_missing",
+    severity: "critical",
+    title: "Completed work has no durable handoff",
+    summary: "The run produced changes, but Build has no durable apply, review, or artifact record.",
+    evidence: [
+      {
+        source: "handoff",
+        message: "Completed work needs a reviewable artifact before cleanup.",
+        data: {
+          runCompleted: handoff.runCompleted,
+          success: handoff.success,
+          changesProduced: handoff.changesProduced,
+          durableArtifactPresent: handoff.durableArtifactPresent,
+          reviewArtifactPresent: handoff.reviewArtifactPresent,
+          applied: handoff.applied,
+          artifactPath: handoff.artifactPath
+        }
+      }
+    ],
+    suggestedActions: [
+      {
+        label: "Inspect worktree state and apply or discard changes",
+        command: "build cleanup doctor"
+      }
+    ]
+  });
+}
+function classifyNominal(snapshot) {
+  if (snapshot.status === "idle" || !statusIsActive(snapshot)) {
+    return buildEvent(snapshot, {
+      category: "idle",
+      severity: "info",
+      status: "active",
+      title: "Run is idle",
+      summary: "No active work is currently in progress.",
+      evidence: [
+        {
+          source: "run_state",
+          message: `Run status is ${snapshot.status}.`
+        }
+      ]
+    });
+  }
+  return buildEvent(snapshot, {
+    category: "working",
+    severity: "info",
+    status: "active",
+    title: "Run is working",
+    summary: "The run is active and no health issues are currently classified.",
+    evidence: [
+      {
+        source: "run_state",
+        message: `Run status is ${snapshot.status}.`
+      }
+    ]
+  });
+}
+function severityRank2(severity) {
+  switch (severity) {
+    case "critical":
+      return 3;
+    case "warning":
+      return 2;
+    case "info":
+      return 1;
+  }
+}
+function classifyRunHealth(snapshot) {
+  const events = [];
+  for (const provider of snapshot.providers ?? []) {
+    events.push(...classifyProvider(snapshot, provider));
+  }
+  const progressEvent = classifyProgress(snapshot);
+  if (progressEvent) events.push(progressEvent);
+  if (snapshot.budget) {
+    const event = classifyBudget(snapshot, snapshot.budget);
+    if (event) events.push(event);
+  }
+  if (snapshot.judge) {
+    const event = classifyJudge(snapshot, snapshot.judge);
+    if (event) events.push(event);
+  }
+  if (snapshot.output) {
+    const event = classifyOutput(snapshot, snapshot.output);
+    if (event) events.push(event);
+  }
+  if (snapshot.worktree) {
+    const event = classifyWorktree(snapshot, snapshot.worktree);
+    if (event) events.push(event);
+  }
+  const handoffEvent = classifyHandoff(snapshot);
+  if (handoffEvent) events.push(handoffEvent);
+  if (events.length === 0) {
+    events.push(classifyNominal(snapshot));
+  }
+  return events.sort((a, b) => severityRank2(b.severity) - severityRank2(a.severity));
+}
+
+// src/cli/handlers/compete/variant-gate-summary.ts
+function gateLabel(verification, channel) {
+  return verification.gates[channel].status.replace(/_/g, "-");
+}
+function formatVariantHonestyGateLine(verification) {
+  const line = `test=${gateLabel(verification, "test")} lint=${gateLabel(verification, "lint")}`;
+  return verification.status === "baseline_clean" ? `${line} (baseline_clean)` : line;
+}
+function formatVariantGateSummary(variant) {
+  const verification = readVariantVerification(variant);
+  const build = `build=${gateLabel(verification, "build")}`;
+  if (verification.status === "baseline_clean") {
+    return `${build} ${formatVariantHonestyGateLine(verification)}`;
+  }
+  const line = `${build} lint=${gateLabel(verification, "lint")} test=${gateLabel(verification, "test")}`;
+  const alsoOnBase = gatesAlsoFailingOnBase(verification.gates);
+  return alsoOnBase.length > 0 ? `${line} (also failing on base: ${alsoOnBase.join(", ")})` : line;
+}
+
+// src/cli/utils/autoloop-task-state-reader.ts
+import * as fs from "fs";
+import * as path from "path";
+var IN_FLIGHT_MONITORING_NOTE = "In-flight status is inferred from unified state (executionMode=autoloop, no autoloopFinal yet). Per-iteration progress is not available via monitor; run summary is written at completion.";
+function sanitizeAutoloopRunFilename(taskId) {
+  return taskId.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function sanitizeAutoloopTrajectoryFilename(taskId) {
+  return taskId.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+function resolveAutoloopRunResultPath(cwd, taskId) {
+  return path.join(
+    cwd,
+    ".build-project",
+    "autoloop",
+    "runs",
+    `${sanitizeAutoloopRunFilename(taskId)}.json`
+  );
+}
+function resolveAutoloopTrajectoryPath(cwd, taskId) {
+  return path.join(
+    cwd,
+    ".build-project",
+    "autoloop",
+    "runs",
+    `${sanitizeAutoloopTrajectoryFilename(taskId)}.trajectory.json`
+  );
+}
+function readJsonFile(filePath, label) {
+  if (!fs.existsSync(filePath)) {
+    return void 0;
+  }
+  try {
+    return parseJsonWithContext(fs.readFileSync(filePath, "utf8"), label);
+  } catch {
+    return void 0;
+  }
+}
+function readUnifiedAutoloopState(unifiedStateDir, taskId) {
+  const filePath = resolveUnifiedStateFilePath(taskId, unifiedStateDir);
+  const parsed = readJsonFile(filePath, `Unified state (${taskId})`);
+  if (!parsed) {
+    return void 0;
+  }
+  if (parsed.executionMode === "autoloop" || parsed.autoloopFinal !== void 0) {
+    return parsed;
+  }
+  return void 0;
+}
+function isUnifiedAutoloopInFlight(unified) {
+  return unified?.executionMode === "autoloop" && unified.autoloopFinal === void 0;
+}
+function deriveStatusFromRunRecord(record) {
+  const status = String(record.status ?? "").toLowerCase();
+  if (status === "completed") {
+    return "completed";
+  }
+  if (status === "failed" || status === "not_complete") {
+    return "failed";
+  }
+  if (status === "running" || status === "in_progress") {
+    return "running";
+  }
+  if (typeof record.success === "boolean") {
+    return record.success ? "completed" : "failed";
+  }
+  return "unknown";
+}
+function deriveStatusFromTrajectory(record) {
+  const status = String(record.status ?? "").toLowerCase();
+  if (status === "completed") {
+    return "completed";
+  }
+  if (status === "failed" || status === "not_complete") {
+    return "failed";
+  }
+  if (typeof record.success === "boolean") {
+    return record.success ? "completed" : "failed";
+  }
+  if (record.completedAt) {
+    return "unknown";
+  }
+  return "unknown";
+}
+function iterationCountFromUnified(unified) {
+  const current = unified?.iteration?.current;
+  if (typeof current?.index === "number") {
+    return current.index + 1;
+  }
+  const history = unified?.iteration?.history;
+  if (Array.isArray(history) && history.length > 0) {
+    const last = history[history.length - 1];
+    if (typeof last?.index === "number") {
+      return last.index + 1;
+    }
+  }
+  return void 0;
+}
+function hasAutoloopMonitorEvidence(taskId, opts = {}) {
+  return readAutoloopTaskState(taskId, opts) !== null;
+}
+function readAutoloopTaskState(taskId, opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const unifiedStateDir = opts.unifiedStateDir ?? resolveProjectRuntimeDir(path.join(cwd, ".build-project"), "state");
+  const runResultPath = resolveAutoloopRunResultPath(cwd, taskId);
+  const trajectoryPath = resolveAutoloopTrajectoryPath(cwd, taskId);
+  const unified = readUnifiedAutoloopState(unifiedStateDir, taskId);
+  const runRecord = readJsonFile(
+    runResultPath,
+    `Autoloop run result (${taskId})`
+  );
+  const trajectory = readJsonFile(
+    trajectoryPath,
+    `Autoloop trajectory (${taskId})`
+  );
+  if (!unified && !runRecord && !trajectory) {
+    return null;
+  }
+  const updatedAt = (typeof unified?.updatedAt === "number" ? new Date(unified.updatedAt).toISOString() : void 0) ?? runRecord?.recordedAt ?? trajectory?.completedAt ?? trajectory?.startedAt;
+  let status = "unknown";
+  let statusSource;
+  let liveMonitoringNote;
+  let success;
+  let terminationReason;
+  let totalIterations;
+  let provider;
+  let model;
+  let branch;
+  let worktree;
+  let startedAt;
+  let completedAt;
+  if (unified?.autoloopFinal) {
+    const finalMarker = unified.autoloopFinal;
+    success = finalMarker.success;
+    status = finalMarker.success ? "completed" : "failed";
+    statusSource = "autoloop_final";
+    terminationReason = finalMarker.terminationReason;
+    totalIterations = finalMarker.totalIterations;
+    provider = finalMarker.summary.provider;
+    model = finalMarker.summary.model;
+    startedAt = finalMarker.summary.startedAt;
+    completedAt = new Date(finalMarker.completedAt).toISOString();
+  } else if (runRecord) {
+    status = deriveStatusFromRunRecord(runRecord);
+    statusSource = "run_result";
+    success = typeof runRecord.success === "boolean" ? runRecord.success : status === "completed" ? true : status === "failed" ? false : void 0;
+    terminationReason = runRecord.terminationReason;
+    totalIterations = runRecord.totalIterations;
+    provider = runRecord.provider ?? void 0;
+    model = runRecord.model;
+    completedAt = runRecord.recordedAt;
+  } else if (trajectory) {
+    status = deriveStatusFromTrajectory(trajectory);
+    statusSource = "trajectory";
+    success = trajectory.success;
+    terminationReason = trajectory.terminationReason;
+    totalIterations = trajectory.totalIterations;
+    provider = trajectory.provider;
+    model = trajectory.model;
+    branch = trajectory.branch;
+    worktree = trajectory.worktree;
+    startedAt = trajectory.startedAt;
+    completedAt = trajectory.completedAt;
+  } else if (isUnifiedAutoloopInFlight(unified)) {
+    status = "running";
+    statusSource = "unified_state_only";
+    liveMonitoringNote = IN_FLIGHT_MONITORING_NOTE;
+    totalIterations = iterationCountFromUnified(unified);
+  } else if (unified?.executionMode === "autoloop") {
+    status = "unknown";
+    statusSource = "unified_state_only";
+  }
+  if (runRecord && !terminationReason) {
+    terminationReason = runRecord.terminationReason;
+  }
+  if (runRecord && totalIterations === void 0) {
+    totalIterations = runRecord.totalIterations;
+  }
+  if (trajectory) {
+    branch = branch ?? trajectory.branch;
+    worktree = worktree ?? trajectory.worktree;
+    provider = provider ?? trajectory.provider;
+    model = model ?? trajectory.model;
+    startedAt = startedAt ?? trajectory.startedAt;
+    completedAt = completedAt ?? trajectory.completedAt;
+    if (totalIterations === void 0) {
+      totalIterations = trajectory.totalIterations;
+    }
+    if (!terminationReason) {
+      terminationReason = trajectory.terminationReason;
+    }
+    if (success === void 0 && typeof trajectory.success === "boolean") {
+      success = trajectory.success;
+    }
+  }
+  if (status === "running" && statusSource === "unified_state_only") {
+    liveMonitoringNote = IN_FLIGHT_MONITORING_NOTE;
+  }
+  return {
+    taskId,
+    kind: "autoloop_task",
+    status,
+    success,
+    terminationReason,
+    totalIterations,
+    provider: provider && provider.length > 0 ? provider : void 0,
+    model,
+    branch,
+    worktree,
+    startedAt,
+    completedAt,
+    updatedAt,
+    runResultPath: fs.existsSync(runResultPath) ? runResultPath : void 0,
+    runResultRelativePath: fs.existsSync(runResultPath) ? path.relative(cwd, runResultPath) : void 0,
+    trajectoryPath: fs.existsSync(trajectoryPath) ? trajectoryPath : void 0,
+    trajectoryRelativePath: fs.existsSync(trajectoryPath) ? path.relative(cwd, trajectoryPath) : void 0,
+    statusSource,
+    persistence: unified?.autoloopFinal?.persistence,
+    liveMonitoringNote
+  };
+}
+function formatAutoloopMonitorHints(taskId, state) {
+  const safeRun = sanitizeAutoloopRunFilename(taskId);
+  const safeTrajectory = sanitizeAutoloopTrajectoryFilename(taskId);
+  const hints = [
+    "This ID may be from build run --autoloop.",
+    `Run summary (written at completion): .build-project/autoloop/runs/${safeRun}.json`,
+    `Trajectory: .build-project/autoloop/runs/${safeTrajectory}.trajectory.json`,
+    "For run history use: build run autoloop history",
+    `For iteration detail use: build loop explain ${taskId}`
+  ];
+  if (state?.branch) {
+    hints.push(`Review changes: git switch ${state.branch}`);
+  }
+  if (state?.status === "running") {
+    hints.push(IN_FLIGHT_MONITORING_NOTE);
+  }
+  return hints;
+}
+
+// src/cli/commands/monitor-health-liveness.ts
+import * as fs2 from "fs";
+var MONITOR_STALE_AFTER_MS = 10 * 60 * 1e3;
+function defaultStatMtimeMs(filePath) {
+  try {
+    return fs2.statSync(filePath).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function runEventsLogPath(state) {
+  const handlePath = state.sources.competitionHandle.path;
+  return handlePath.endsWith(".json") ? `${handlePath.slice(0, -5)}.events.jsonl` : void 0;
+}
+function buildMonitorProgressHealth(state, handleUpdatedAt, deps = {}) {
+  const eventsPath = runEventsLogPath(state);
+  const eventsModifiedAt = eventsPath ? (deps.statMtimeMs ?? defaultStatMtimeMs)(eventsPath) : void 0;
+  const activity = [handleUpdatedAt, eventsModifiedAt].filter(
+    (value) => typeof value === "number" && Number.isFinite(value)
+  );
+  const lastProgressAt = activity.length > 0 ? Math.max(...activity) : void 0;
+  const ownerPid = state.ownerPid;
+  const ownerProcess = typeof ownerPid === "number" ? (deps.observeProcess ?? defaultObserveProcess)(ownerPid) : void 0;
+  if (lastProgressAt === void 0 && ownerProcess === void 0) return void 0;
+  return {
+    lastProgressAt,
+    staleAfterMs: MONITOR_STALE_AFTER_MS,
+    progressLabel: state.background?.activePhase ?? state.status,
+    ownerProcess,
+    ownerPid
+  };
+}
+
+// src/cli/commands/monitor-variant-label.ts
+function formatMonitorVariantLabel(variant) {
+  const effort = normalizeReasoningEffortInput(variant.reasoningEffort) ?? (variant.variant ? normalizeReasoningEffortInput(parseVariantIdentifier(variant.variant).reasoningEffort) : void 0);
+  const base = `${variant.provider}${variant.model ? `:${variant.model}` : ""}`;
+  return effort ? `${base}:effort-${formatReasoningEffortLevelForUser(effort, variant.provider)}` : base;
+}
+var MONITOR_VARIANT_RAN_LABEL = "Ran";
+
+// src/cli/commands/monitor.ts
+function formatMonitorWinnerOrIdentityLine(state) {
+  if (!state.winner) return null;
+  const identityLabel = state.winner.variant?.trim() || `${state.winner.provider}${state.winner.model ? `:${state.winner.model}` : ""}`;
+  return state.decision?.reason === "judge_off" ? `Ungraded identity: ${identityLabel}` : `Winner: ${identityLabel}`;
+}
+function buildMonitorJsonPayload(rawHandle, state) {
+  if (!rawHandle || typeof rawHandle !== "object" || !state.winner || state.decision?.reason !== "judge_off") {
+    return rawHandle;
+  }
+  return {
+    ...rawHandle,
+    winner: null,
+    ungradedIdentity: state.winner
+  };
+}
+function formatMonitorVariantHonestyLine(variant) {
+  const lintStatus = "lintStatus" in variant ? variant.lintStatus : void 0;
+  if (!variant.outcome?.verification && variant.testStatus == null && lintStatus == null) {
+    return null;
+  }
+  return formatVariantHonestyGateLine(readVariantVerification(variant));
+}
+function formatMonitorSynthesisStatus(synthesis) {
+  const aiGuidedFallbackStatus = synthesis.aiGuidedFallbackAttempted === true ? (() => {
+    switch (synthesis.aiGuidedFallbackOutcome) {
+      case "donor_augmented":
+        return "ai fallback donor-augmented (applied)";
+      case "winner_equivalent":
+        return "ai fallback winner-equivalent (not applied)";
+      case "candidate_rejected":
+        return "ai fallback rejected by apply/gates (not applied)";
+      case "generation_failed":
+        return "ai fallback failed (winner retained)";
+      default:
+        return "ai fallback attempted";
+    }
+  })() : null;
+  const status = aiGuidedFallbackStatus ?? (synthesis.synthesisApplied ? "applied" : synthesis.winnerFallback ? "winner fallback" : synthesis.gatesPassed === false ? "gates failed" : synthesis.success === false ? "failed" : synthesis.success === true ? "completed" : "attempted");
+  const details = [];
+  if (typeof synthesis.deliverySucceeded === "boolean") {
+    details.push(`delivery=${synthesis.deliverySucceeded ? "yes" : "no"}`);
+  }
+  if (synthesis.synthesisApplied === true && synthesis.mergedVariants.length > 0) {
+    details.push(`donors=${synthesis.mergedVariants.length}`);
+  }
+  if (typeof synthesis.prNumber === "number") {
+    details.push(`PR #${synthesis.prNumber}`);
+  } else if (synthesis.prUrl) {
+    details.push(synthesis.prUrl);
+  }
+  if (synthesis.fallbackReason) {
+    details.push(synthesis.fallbackReason);
+  }
+  return details.length > 0 ? `${status} (${details.join(" \u2022 ")})` : status;
+}
+function failMonitorCommand() {
+  throw new ExitCodeError(1);
+}
+function buildAutoloopMonitorJsonPayload(state) {
+  return {
+    taskId: state.taskId,
+    kind: state.kind,
+    status: state.status,
+    success: state.success,
+    terminationReason: state.terminationReason,
+    totalIterations: state.totalIterations,
+    provider: state.provider,
+    model: state.model,
+    branch: state.branch,
+    worktree: state.worktree,
+    startedAt: state.startedAt,
+    completedAt: state.completedAt,
+    updatedAt: state.updatedAt,
+    statusSource: state.statusSource,
+    liveMonitoringNote: state.liveMonitoringNote,
+    runResult: state.runResultRelativePath,
+    trajectory: state.trajectoryRelativePath
+  };
+}
+function renderAutoloopMonitorState(state, opts) {
+  if (opts.json) {
+    const payload = buildAutoloopMonitorJsonPayload(state);
+    console.log(opts.follow ? JSON.stringify(payload) : JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(chalk.bold.cyan(`
+Monitor: ${state.taskId}`));
+  console.log(chalk.cyan("Mode: build run --autoloop"));
+  console.log(chalk.gray(`Status: ${state.status}`));
+  if (state.terminationReason) {
+    console.log(chalk.gray(`Termination: ${state.terminationReason}`));
+  }
+  if (typeof state.totalIterations === "number") {
+    console.log(chalk.gray(`Iterations: ${state.totalIterations}`));
+  }
+  if (state.provider) {
+    console.log(chalk.gray(`Provider: ${state.provider}${state.model ? `:${state.model}` : ""}`));
+  }
+  if (state.branch) {
+    console.log(chalk.gray(`Branch: ${state.branch}`));
+  }
+  if (state.worktree) {
+    console.log(chalk.gray(`Worktree: ${state.worktree}`));
+  }
+  if (state.updatedAt) {
+    console.log(chalk.gray(`Updated: ${state.updatedAt}`));
+  }
+  if (state.startedAt) {
+    console.log(chalk.gray(`Started: ${state.startedAt}`));
+  }
+  if (state.completedAt) {
+    console.log(chalk.gray(`Completed: ${state.completedAt}`));
+  }
+  if (typeof state.success === "boolean") {
+    console.log(state.success ? chalk.green("Success: yes") : chalk.red("Success: no"));
+  }
+  if (state.liveMonitoringNote) {
+    console.log(chalk.yellow(state.liveMonitoringNote));
+  }
+  if (state.runResultRelativePath) {
+    console.log(chalk.gray(`Run summary: ${state.runResultRelativePath}`));
+  } else if (state.status === "running") {
+    console.log(chalk.gray("Run summary not written yet (expected at completion)."));
+  }
+  if (state.trajectoryRelativePath) {
+    console.log(chalk.gray(`Trajectory: ${state.trajectoryRelativePath}`));
+  }
+  console.log();
+  console.log(chalk.gray("Tips:"));
+  for (const hint of formatAutoloopMonitorHints(state.taskId, state)) {
+    console.log(chalk.gray(`  - ${hint}`));
+  }
+}
+function buildRunTaskMonitorJsonPayload(state) {
+  const artifact = state.artifact;
+  return {
+    taskId: state.taskId,
+    kind: state.kind,
+    executionMode: state.executionMode,
+    status: state.status,
+    success: state.success,
+    updatedAt: state.updatedAt,
+    provider: artifact?.provider,
+    model: artifact?.model,
+    variant: artifact?.variant,
+    exitCode: artifact?.exitCode,
+    startedAt: artifact?.startedAt,
+    finishedAt: artifact?.finishedAt,
+    providerOutputArtifact: state.providerOutputArtifactRelativePath,
+    artifact
+  };
+}
+function renderRunTaskMonitorState(state, opts) {
+  if (opts.json) {
+    const payload = buildRunTaskMonitorJsonPayload(state);
+    console.log(opts.follow ? JSON.stringify(payload) : JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(chalk.bold.cyan(`
+Monitor: ${state.taskId}`));
+  console.log(chalk.cyan("Mode: build run (single-pass)"));
+  if (state.executionMode) {
+    console.log(chalk.gray(`Execution mode: ${formatExecutionModeLabel(state.executionMode)}`));
+  }
+  console.log(chalk.gray(`Status: ${state.status}`));
+  if (state.updatedAt) {
+    console.log(chalk.gray(`Updated: ${state.updatedAt}`));
+  }
+  const artifact = state.artifact;
+  if (artifact) {
+    console.log(
+      chalk.gray(`Provider: ${artifact.provider}${artifact.model ? `:${artifact.model}` : ""}`)
+    );
+    if (artifact.variant) {
+      console.log(chalk.gray(`Variant: ${artifact.variant}`));
+    }
+    console.log(artifact.success ? chalk.green("Success: yes") : chalk.red("Success: no"));
+    if (typeof artifact.exitCode === "number") {
+      console.log(chalk.gray(`Exit code: ${artifact.exitCode}`));
+    }
+    if (artifact.finishedAt) {
+      console.log(chalk.gray(`Finished: ${artifact.finishedAt}`));
+    }
+    if (state.providerOutputArtifactRelativePath) {
+      console.log(chalk.gray(`Provider output: ${state.providerOutputArtifactRelativePath}`));
+    }
+  } else if (state.providerOutputArtifactRelativePath) {
+    console.log(chalk.gray("Run still in progress; provider-output artifact not written yet."));
+    console.log(chalk.gray(`Expected artifact: ${state.providerOutputArtifactRelativePath}`));
+  }
+  console.log();
+  console.log(chalk.gray("Tips:"));
+  for (const hint of formatRunTaskMonitorHints(state.taskId)) {
+    console.log(chalk.gray(`  - ${hint}`));
+  }
+}
+function isSafeMonitorId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+}
+function isSafeLabId(value) {
+  return /^[A-Za-z0-9_-]+$/.test(value);
+}
+function isSafeRunId(value) {
+  return /^\d{8}-\d{6}-\d{3}$/.test(value);
+}
+function isTerminalMonitorState(state) {
+  const status = String(state.status ?? state.background?.status ?? "").toLowerCase();
+  const outcome = String(state.outcome ?? "").toLowerCase();
+  const terminalStatuses = /* @__PURE__ */ new Set(["completed", "complete", "failed", "failure", "cancelled"]);
+  const terminalOutcomes = /* @__PURE__ */ new Set(["completed", "failed", "no_winner", "cancelled"]);
+  return Boolean(state.completedAt ?? state.background?.completedAt ?? state.background?.failedAt) || terminalStatuses.has(status) || terminalOutcomes.has(outcome);
+}
+function isTerminalRunTaskState(state) {
+  return state.status === "completed" || state.status === "failed" || Boolean(state.artifact);
+}
+function isTerminalAutoloopState(state) {
+  return state.status === "completed" || state.status === "failed";
+}
+function isRunTaskMonitorState(state) {
+  return "kind" in state && state.kind === "run_task";
+}
+function isAutoloopMonitorState(state) {
+  return "kind" in state && state.kind === "autoloop_task";
+}
+function isTerminalMonitorRenderState(state) {
+  if (isRunTaskMonitorState(state)) {
+    return isTerminalRunTaskState(state);
+  }
+  if (isAutoloopMonitorState(state)) {
+    return isTerminalAutoloopState(state);
+  }
+  return isTerminalMonitorState(state);
+}
+function parseMonitorTimestamp(value) {
+  if (!value) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeRunLifecycleStatus(value) {
+  const status = String(value ?? "unknown").toLowerCase();
+  switch (status) {
+    case "queued":
+    case "pending":
+    case "starting":
+    case "running":
+    case "processing":
+    case "verifying":
+    case "completed":
+    case "failed":
+    case "cancelled":
+    case "idle":
+      return status;
+    case "complete":
+      return "completed";
+    case "canceled":
+    case "cancelled_by_user":
+      return "cancelled";
+    case "in-progress":
+    case "in_progress":
+    case "submitted":
+    case "executing":
+      return "running";
+    default:
+      return "unknown";
+  }
+}
+function inferProviderHealthFromVariant(variant) {
+  const diagnostics = variant.providerDiagnostics;
+  const execution = variant.outcome?.execution;
+  const executionStatus = String(execution?.status ?? "").toLowerCase();
+  const authErrors = diagnostics?.authErrors ?? [];
+  const transportErrors = diagnostics?.transportErrors ?? [];
+  const toolErrors = diagnostics?.toolErrors ?? [];
+  const authBroken = variant.authError !== void 0 || authErrors.length > 0;
+  const timedOut = variant.timedOut === true || variant.terminationReason === "timeout" || executionStatus === "timed_out";
+  const outputFailure = diagnostics?.terminalResultPresent === false;
+  const executionFailed = executionStatus === "failed" || executionStatus === "crashed" || variant.success === false && executionStatus === "";
+  const failed = authBroken || timedOut || outputFailure || executionFailed;
+  const error = variant.authError?.message ?? authErrors[0] ?? transportErrors[0] ?? toolErrors[0] ?? variant.errorMessage ?? variant.terminationReason;
+  return {
+    provider: variant.provider ?? "unknown",
+    variant: "variant" in variant ? variant.variant : void 0,
+    authState: authBroken ? "invalid" : void 0,
+    availability: authBroken ? void 0 : timedOut ? "degraded" : executionFailed ? "unavailable" : void 0,
+    lastError: error || void 0,
+    lastFailurePhase: authBroken ? "startup" : timedOut ? "timeout" : outputFailure ? "output" : executionFailed ? "mid_execution" : void 0,
+    consecutiveFailures: failed ? 1 : void 0
+  };
+}
+function structuredOutputErrors(variant) {
+  if (variant.providerDiagnostics?.terminalResultPresent !== false) return [];
+  return [`${variant.provider ?? "unknown"} did not emit its required terminal result event.`];
+}
+function buildMonitorHealthSnapshot(state, deps) {
+  const status = normalizeRunLifecycleStatus(
+    state.status ?? state.background?.status ?? state.background?.activePhase
+  );
+  const updatedAt = parseMonitorTimestamp(state.updatedAt) ?? parseMonitorTimestamp(state.background?.completedAt) ?? parseMonitorTimestamp(state.background?.startedAt);
+  const completedAt = parseMonitorTimestamp(state.completedAt) ?? parseMonitorTimestamp(state.background?.completedAt) ?? parseMonitorTimestamp(state.background?.failedAt);
+  const variants = state.primarySource === "background_handle" && state.background ? state.background.variants : state.variants;
+  const outputErrors = variants.flatMap((variant) => structuredOutputErrors(variant));
+  const completedVariants = variants.filter((variant) => variant.success === true).length;
+  const noWinner = state.outcome === "no_winner" || status === "completed" && !state.winner && variants.length > 1;
+  const providers = variants.filter((variant) => variant.provider).map((variant) => inferProviderHealthFromVariant(variant));
+  return buildRunHealthSnapshot({
+    runId: resolveDisplayId(state),
+    taskId: state.taskId,
+    status,
+    updatedAt,
+    progress: buildMonitorProgressHealth(state, updatedAt, deps),
+    providers,
+    judge: noWinner || state.errorMessage ? {
+      status: noWinner ? "no_winner" : "failed",
+      completedVariants,
+      reason: noWinner ? "No winner was selected." : state.errorMessage
+    } : void 0,
+    output: outputErrors.length > 0 ? {
+      parseErrors: outputErrors,
+      unparseable: true
+    } : void 0,
+    handoff: completedAt && state.synthesis ? {
+      runCompleted: true,
+      success: state.synthesis.success === true || state.synthesis.deliverySucceeded === true,
+      changesProduced: state.synthesis.synthesisApplied === true || state.synthesis.winnerFallback === true,
+      durableArtifactPresent: Boolean(
+        state.synthesis.prNumber || state.synthesis.prUrl || state.synthesis.deliverySucceeded || state.synthesis.synthesisApplied
+      ),
+      reviewArtifactPresent: Boolean(state.synthesis.prNumber || state.synthesis.prUrl),
+      applied: state.synthesis.synthesisApplied
+    } : void 0
+  });
+}
+function formatHealthEvent(event) {
+  const provider = event.provider ? ` provider=${event.provider}` : "";
+  return `${event.severity.toUpperCase()} ${event.category}${provider}: ${event.summary}`;
+}
+function renderSingleHealthEvent(event, indent = "") {
+  const color = event.severity === "critical" ? chalk.red : event.severity === "warning" ? chalk.yellow : chalk.gray;
+  console.log(color(`${indent}${formatHealthEvent(event)}`));
+  const firstAction = event.suggestedActions[0];
+  if (firstAction) {
+    console.log(chalk.gray(`${indent}Action: ${firstAction.command ?? firstAction.label}`));
+  }
+}
+function renderHealthEventsGrouped(events) {
+  const SEVERITY_RANK = {
+    critical: 3,
+    warning: 2,
+    info: 1
+  };
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const bucket = byCategory.get(event.category) ?? [];
+    bucket.push(event);
+    byCategory.set(event.category, bucket);
+  }
+  const groups = [...byCategory.entries()].sort(([, aEvents], [, bEvents]) => {
+    const aWorst = Math.max(...aEvents.map((e) => SEVERITY_RANK[e.severity] ?? 1));
+    const bWorst = Math.max(...bEvents.map((e) => SEVERITY_RANK[e.severity] ?? 1));
+    return bWorst - aWorst;
+  });
+  for (const [category, groupEvents] of groups) {
+    const worstSeverity = groupEvents.reduce(
+      (w, e) => (SEVERITY_RANK[e.severity] ?? 1) > (SEVERITY_RANK[w] ?? 1) ? e.severity : w,
+      "info"
+    );
+    const headerColor = worstSeverity === "critical" ? chalk.red.bold : worstSeverity === "warning" ? chalk.yellow.bold : chalk.gray.bold;
+    const count = groupEvents.length > 1 ? ` (${groupEvents.length})` : "";
+    console.log(headerColor(`
+  [${category}]${count}`));
+    for (const event of groupEvents) {
+      renderSingleHealthEvent(event, "    ");
+    }
+  }
+}
+function filterHealthEvents(events, category, severity) {
+  let filtered = events;
+  if (category) {
+    filtered = filtered.filter((e) => e.category === category);
+  }
+  if (severity) {
+    filtered = filtered.filter((e) => e.severity === severity);
+  }
+  return filtered;
+}
+function renderHealthEvents(events, opts = {}) {
+  const filtered = filterHealthEvents(events, opts.category, opts.severity);
+  const summary = summarizeRunHealth(filtered);
+  console.log(chalk.bold("\nHealth:"));
+  console.log(chalk.gray(`Status: ${summary.worstSeverity}`));
+  if (filtered.length === 0) {
+    console.log(chalk.gray("  (no events match the current filter)"));
+    return;
+  }
+  if (opts.category) {
+    for (const event of filtered) {
+      renderSingleHealthEvent(event, "  ");
+    }
+  } else {
+    renderHealthEventsGrouped(filtered);
+  }
+}
+var RUN_HEALTH_CATEGORIES = /* @__PURE__ */ new Set([
+  "stalled",
+  "auth_broken",
+  "provider_unhealthy",
+  "budget_burn",
+  "judge_disagree",
+  "output_drift",
+  "worktree_blocked",
+  "handoff_missing",
+  "working",
+  "idle"
+]);
+var RUN_HEALTH_SEVERITIES = /* @__PURE__ */ new Set(["info", "warning", "critical"]);
+function parseHealthCategory(value) {
+  if (value === void 0) return void 0;
+  if (RUN_HEALTH_CATEGORIES.has(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid health category "${value}". Expected one of: ${Array.from(RUN_HEALTH_CATEGORIES).join(", ")}`
+  );
+}
+function parseHealthSeverity(value) {
+  if (value === void 0) return void 0;
+  if (RUN_HEALTH_SEVERITIES.has(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid health severity "${value}". Expected one of: ${Array.from(RUN_HEALTH_SEVERITIES).join(", ")}`
+  );
+}
+function createMonitorCommand() {
+  const cmd = new Command("monitor").alias("m").description(
+    "Monitor a competition task by taskId (handle file)\n\nExamples:\n  build monitor T123456\n  build monitor T123456 --follow\n  build monitor T123456 --detailed --interval 10\n  build monitor T123456 --lab --lab-id lab-abc123 --run-id 20251210-153042-001"
+  ).argument("<taskId>", "(REQUIRED) Competition task ID (e.g., T123456)").option("--json", "(OPTIONAL) Output raw JSON handle").option("--health", "(OPTIONAL) Show operator-oriented run health").option(
+    "--category <category>",
+    "(OPTIONAL) Filter health output to a specific category (requires --health)\n    Categories: stalled, auth_broken, provider_unhealthy, budget_burn,\n                judge_disagree, output_drift, worktree_blocked, handoff_missing,\n                working, idle\n    Example: --health --category stalled"
+  ).option(
+    "--severity <severity>",
+    "(OPTIONAL) Filter health output to a specific severity (requires --health)\n    Values: info, warning, critical\n    Example: --health --severity critical"
+  ).option(
+    "--follow",
+    "(OPTIONAL) Refresh periodically and print updates\n    Example: --follow"
+  ).option(
+    "--interval <seconds>",
+    "(OPTIONAL) Refresh interval in seconds (default: 15)\n    Example: --interval 10",
+    "15"
+  ).option(
+    "--timeout <minutes>",
+    "(OPTIONAL) Stop --follow after this many minutes\n    Example: --timeout 30"
+  ).option(
+    "--detailed",
+    "(OPTIONAL) Show additional local inspection tips\n    Example: --detailed"
+  ).option(
+    "--lab",
+    "(OPTIONAL) Monitor a lab run (uses lab-specific state directory)\n    Example: --lab"
+  ).option(
+    "--lab-id <labId>",
+    "(OPTIONAL) Specify lab ID for monitoring (requires --run-id)\n    Example: --lab-id lab-abc123"
+  ).option(
+    "--run-id <runId>",
+    "(OPTIONAL) Specify run ID for lab monitoring (requires --lab-id)\n    Example: --run-id 20251210-153042-001"
+  ).action(
+    async (taskId, opts) => {
+      const emitError = (message, extra) => {
+        if (opts.json) {
+          console.log(JSON.stringify({ error: message, ...extra }));
+        } else {
+          console.log(chalk.red(`
+Error: ${message}`));
+        }
+      };
+      if (!isSafeMonitorId(taskId)) {
+        emitError(`invalid taskId "${taskId}"`);
+        failMonitorCommand();
+      }
+      if (opts.lab && !opts.labId && !opts.runId) {
+        emitError("--lab requires --lab-id and --run-id to specify which lab run to monitor");
+        if (!opts.json) {
+          console.log(chalk.yellow("\nUsage:"));
+          console.log(chalk.gray("  build monitor <taskId> --lab-id <labId> --run-id <runId>"));
+          console.log(chalk.yellow("\nTo find available labs:"));
+          console.log(chalk.gray("  ls .build-project/labs/  # List lab IDs"));
+          console.log(
+            chalk.gray("  ls .build-project/labs/<labId>/runs/  # List run IDs for a lab")
+          );
+          console.log(chalk.yellow("\nNote:"));
+          console.log(
+            chalk.gray("  The --lab flag is optional when using --lab-id and --run-id together")
+          );
+        }
+        failMonitorCommand();
+      }
+      if (opts.labId && !opts.runId) {
+        emitError("--lab-id requires --run-id");
+        if (!opts.json) {
+          console.log(chalk.gray("Lab runs are organized by both lab ID and run ID"));
+          console.log(chalk.yellow("\nUsage:"));
+          console.log(
+            chalk.gray("  build monitor T123456 --lab-id lab-abc123 --run-id 20251210-153042-001")
+          );
+          console.log(chalk.yellow("\nTo find run IDs for a lab:"));
+          console.log(
+            chalk.gray("  ls .build-project/labs/<labId>/runs/  # List available runs")
+          );
+        }
+        failMonitorCommand();
+      }
+      if (opts.runId && !opts.labId) {
+        emitError("--run-id requires --lab-id");
+        if (!opts.json) {
+          console.log(chalk.gray("Lab runs are organized by both lab ID and run ID"));
+          console.log(chalk.yellow("\nUsage:"));
+          console.log(
+            chalk.gray("  build monitor T123456 --lab-id lab-abc123 --run-id 20251210-153042-001")
+          );
+          console.log(chalk.yellow("\nTo find lab IDs:"));
+          console.log(chalk.gray("  ls .build-project/labs/  # List available labs"));
+        }
+        failMonitorCommand();
+      }
+      if (opts.labId && !isSafeLabId(opts.labId)) {
+        emitError(`invalid --lab-id "${opts.labId}"`);
+        failMonitorCommand();
+      }
+      if (opts.runId && !isSafeRunId(opts.runId)) {
+        emitError(`invalid --run-id "${opts.runId}"`);
+        failMonitorCommand();
+      }
+      let stateDir;
+      let backgroundDir;
+      let unifiedStateDir;
+      const isLabMode = opts.lab || opts.labId;
+      const repoRoot = getPlanningRoot();
+      const buildDir = path2.join(repoRoot, ".build-project");
+      if (isLabMode) {
+        const { LabPathResolver } = await import("./lab-mode-YXQ2Y3NG.js");
+        const resolver = LabPathResolver.getInstance();
+        if (opts.labId && opts.runId) {
+          resolver.setContext({
+            labId: opts.labId,
+            runId: opts.runId,
+            baseline: "HEAD",
+            // Default baseline (not critical for monitoring)
+            task: ""
+            // Empty task (not critical for monitoring)
+          });
+        }
+        const stateRootDir = resolver.getStateDir(buildDir);
+        stateDir = path2.join(stateRootDir, "competitions");
+        backgroundDir = path2.join(stateRootDir, "background");
+        unifiedStateDir = stateRootDir;
+      } else {
+        const roots = resolveCliStateRoots(repoRoot);
+        stateDir = firstDirWithFile(roots.competitionsReadDirs, `${taskId}.json`);
+        backgroundDir = firstDirWithFile(roots.backgroundReadDirs, `${taskId}.json`);
+        unifiedStateDir = roots.unifiedStateDir;
+      }
+      let handlePath = path2.join(stateDir, `${taskId}.json`);
+      let backgroundHandlePath = path2.join(backgroundDir, `${taskId}.json`);
+      if (!isLabMode && !fs3.existsSync(handlePath) && !fs3.existsSync(backgroundHandlePath)) {
+        const labMatch = findLabRunStateForTask(taskId, buildDir);
+        if (labMatch) {
+          stateDir = path2.join(labMatch.stateRoot, "competitions");
+          backgroundDir = path2.join(labMatch.stateRoot, "background");
+          unifiedStateDir = labMatch.stateRoot;
+          handlePath = path2.join(stateDir, `${taskId}.json`);
+          backgroundHandlePath = path2.join(backgroundDir, `${taskId}.json`);
+        }
+      }
+      const runTaskEvidence = hasRunTaskMonitorEvidence(taskId, {
+        cwd: repoRoot,
+        unifiedStateDir
+      });
+      const autoloopEvidence = hasAutoloopMonitorEvidence(taskId, {
+        cwd: repoRoot,
+        unifiedStateDir
+      });
+      if (!fs3.existsSync(handlePath) && !fs3.existsSync(backgroundHandlePath) && !runTaskEvidence && !autoloopEvidence) {
+        emitError(`Task not found: ${taskId}`, {
+          code: "task_not_found",
+          taskId
+        });
+        if (opts.json) {
+          failMonitorCommand();
+        }
+        console.log(chalk.gray("\nPossible reasons:"));
+        console.log(chalk.gray("  - Task ID is incorrect"));
+        console.log(chalk.gray("  - Task was never created"));
+        console.log(chalk.gray("  - Task state file was deleted"));
+        console.log(chalk.yellow("\nPost-run visibility hints:"));
+        for (const hint of formatRunTaskMonitorHints(taskId)) {
+          console.log(chalk.gray(`  - ${hint}`));
+        }
+        for (const hint of formatAutoloopMonitorHints(taskId)) {
+          console.log(chalk.gray(`  - ${hint}`));
+        }
+        try {
+          const taskFiles = [];
+          if (fs3.existsSync(stateDir)) {
+            const files = fs3.readdirSync(stateDir).filter((f) => f.endsWith(".json"));
+            for (const f of files) {
+              const fullPath = path2.join(stateDir, f);
+              const stats = fs3.statSync(fullPath);
+              let title;
+              try {
+                const raw = JSON.parse(fs3.readFileSync(fullPath, "utf8"));
+                if (raw && typeof raw === "object") {
+                  const prompt = raw.prompt ?? raw.intent ?? raw.goal;
+                  title = typeof prompt === "string" ? extractTitleFromPrompt(prompt) : void 0;
+                }
+              } catch {
+              }
+              taskFiles.push({
+                taskId: f.replace(".json", ""),
+                title,
+                mtime: stats.mtime
+              });
+            }
+          }
+          const bgDir = path2.dirname(backgroundHandlePath);
+          if (fs3.existsSync(bgDir)) {
+            const bgFiles = fs3.readdirSync(bgDir).filter((f) => f.endsWith(".json"));
+            for (const f of bgFiles) {
+              const fullPath = path2.join(bgDir, f);
+              const stats = fs3.statSync(fullPath);
+              let title;
+              try {
+                const raw = JSON.parse(fs3.readFileSync(fullPath, "utf8"));
+                if (raw && typeof raw === "object") {
+                  const prompt = raw.prompt ?? raw.intent ?? raw.goal;
+                  title = typeof prompt === "string" ? extractTitleFromPrompt(prompt) : void 0;
+                }
+              } catch {
+              }
+              taskFiles.push({
+                taskId: f.replace(".json", ""),
+                title,
+                mtime: stats.mtime
+              });
+            }
+          }
+          if (taskFiles.length > 0) {
+            console.log(chalk.yellow(`
+Available tasks (${taskFiles.length} found):`));
+            const recentTasks = taskFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(0, 5);
+            for (const task of recentTasks) {
+              const age = Math.round((Date.now() - task.mtime.getTime()) / 6e4);
+              const timeStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+              console.log(
+                chalk.gray(
+                  `  - ${formatTaskLabel({ title: task.title, id: task.taskId })} (${timeStr})`
+                )
+              );
+            }
+            if (taskFiles.length > 5) {
+              console.log(chalk.gray(`  ... and ${taskFiles.length - 5} more`));
+            }
+          } else {
+            console.log(chalk.gray("\nNo tasks found in state directory"));
+          }
+        } catch (_e) {
+        }
+        if (isLabMode) {
+          console.log(
+            chalk.gray("\nIf this is a lab run, ensure --lab-id and --run-id are correct")
+          );
+          console.log(
+            chalk.gray(
+              "Lab state location: .build-project/labs/{labId}/runs/{runId}/state/competitions/"
+            )
+          );
+        }
+        failMonitorCommand();
+      }
+      const render = async () => {
+        const state = readCompetitionState(taskId, {
+          stateDir,
+          backgroundDir,
+          unifiedStateDir,
+          cwd: repoRoot
+        });
+        const parseFailure = [
+          state.sources.competitionHandle,
+          state.sources.backgroundHandle,
+          state.sources.unifiedState
+        ].find((source) => source.exists && source.parseError);
+        if (parseFailure?.parseError) {
+          const message = `Failed to read handle: ${parseFailure.parseError}`;
+          if (opts.json) {
+            console.log(JSON.stringify({ error: message }));
+          } else {
+            console.log(chalk.red(message));
+          }
+          failMonitorCommand();
+        }
+        if (!state.sources.competitionHandle.exists && !state.sources.backgroundHandle.exists) {
+          const runTaskState = readRunTaskState(taskId, {
+            cwd: repoRoot,
+            unifiedStateDir
+          });
+          if (runTaskState) {
+            if (opts.health) {
+              emitError(
+                "Run-task health is not available via monitor; inspect provider-output artifacts instead.",
+                { code: "run_task_health_unsupported", taskId }
+              );
+              failMonitorCommand();
+            }
+            renderRunTaskMonitorState(runTaskState, {
+              json: opts.json,
+              follow: opts.follow
+            });
+            return runTaskState;
+          }
+          const autoloopState = readAutoloopTaskState(taskId, {
+            cwd: repoRoot,
+            unifiedStateDir
+          });
+          if (autoloopState) {
+            if (opts.health) {
+              emitError(
+                "Autoloop health is not available via monitor; use build loop explain instead.",
+                { code: "autoloop_health_unsupported", taskId }
+              );
+              failMonitorCommand();
+            }
+            renderAutoloopMonitorState(autoloopState, {
+              json: opts.json,
+              follow: opts.follow
+            });
+            return autoloopState;
+          }
+          console.log(chalk.yellow(`Task state file disappeared: ${taskId}`));
+          return null;
+        }
+        if (opts.health) {
+          try {
+            parseHealthCategory(opts.category);
+            parseHealthSeverity(opts.severity);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            emitError(message);
+            failMonitorCommand();
+          }
+          const healthSnapshot = buildMonitorHealthSnapshot(state);
+          const allEvents = classifyRunHealth(healthSnapshot);
+          const filteredEvents = filterHealthEvents(allEvents, opts.category, opts.severity);
+          const summary = summarizeRunHealth(filteredEvents);
+          if (opts.json) {
+            const payload = {
+              taskId,
+              health: summary
+            };
+            console.log(opts.follow ? JSON.stringify(payload) : JSON.stringify(payload, null, 2));
+            if (summary.worstSeverity === "critical") {
+              failMonitorCommand();
+            }
+          } else {
+            const events = filteredEvents;
+            const headerId = resolveDisplayId(state);
+            const headerTitle = extractTitleFromPrompt(state.prompt ?? state.background?.prompt);
+            console.log(
+              chalk.bold.cyan(
+                `
+Monitor: ${formatTaskLabel({ title: headerTitle, id: headerId })}`
+              )
+            );
+            renderHealthEvents(events, {
+              category: opts.category,
+              severity: opts.severity
+            });
+          }
+          return state;
+        }
+        try {
+          if (state.primarySource === "background_handle" && state.background) {
+            if (opts.json) {
+              const monitorJsonPayload = buildMonitorJsonPayload(state.rawHandle, state);
+              const payload = opts.follow ? JSON.stringify(monitorJsonPayload) : JSON.stringify(monitorJsonPayload, null, 2);
+              console.log(payload);
+              return state;
+            }
+            const bgTaskId = state.rawHandle?.taskId ?? taskId;
+            const bgPrompt = state.rawHandle?.prompt;
+            const bgTitle = typeof bgPrompt === "string" ? extractTitleFromPrompt(bgPrompt) : void 0;
+            console.log(
+              chalk.bold.cyan(
+                `
+Monitor: ${formatTaskLabel({ title: bgTitle, id: String(bgTaskId) })}`
+              )
+            );
+            console.log(chalk.cyan("Mode: Background"));
+            if (typeof state.background.pid === "number")
+              console.log(chalk.gray(`PID: ${state.background.pid}`));
+            if (state.background.label)
+              console.log(chalk.gray(`Label: ${state.background.label}`));
+            if (state.background.detachMethod)
+              console.log(chalk.gray(`Detach: ${state.background.detachMethod}`));
+            if (state.background.status)
+              console.log(chalk.gray(`Status: ${state.background.status}`));
+            if (state.initiatedBy) console.log(chalk.gray(`Initiated by: ${state.initiatedBy}`));
+            if (state.background.activePhase)
+              console.log(chalk.gray(`Phase: ${state.background.activePhase}`));
+            if (typeof state.background.elapsedMs === "number")
+              console.log(chalk.gray(`Elapsed: ${Math.round(state.background.elapsedMs)}ms`));
+            if (typeof state.background.timeoutMinutes === "number")
+              console.log(
+                chalk.gray(`Timeouts: orchestrator=${state.background.timeoutMinutes}m`)
+              );
+            if (typeof state.background.executorTimeoutMinutes === "number")
+              console.log(
+                chalk.gray(
+                  `Executor Timeout: ${state.background.executorTimeoutMinutes}m per variant`
+                )
+              );
+            if (state.background.signal)
+              console.log(chalk.yellow(`Signal: ${state.background.signal}`));
+            if (state.background.terminatedAt)
+              console.log(chalk.gray(`Terminated: ${state.background.terminatedAt}`));
+            if (state.background.signalDiagnostics) {
+              const diagnostics = state.background.signalDiagnostics;
+              const details = [
+                typeof diagnostics.pid === "number" ? `pid=${diagnostics.pid}` : null,
+                typeof diagnostics.parentPid === "number" ? `ppid=${diagnostics.parentPid}` : null,
+                diagnostics.platform ? `platform=${diagnostics.platform}` : null,
+                typeof diagnostics.uptimeMs === "number" ? `uptime=${Math.round(diagnostics.uptimeMs)}ms` : null,
+                diagnostics.activePhase ? `phase=${diagnostics.activePhase}` : null
+              ].filter((value) => value !== null);
+              if (details.length > 0) {
+                console.log(chalk.gray(`Signal Diagnostics: ${details.join(", ")}`));
+              }
+            }
+            if (state.background.orchestratorTimeoutObserved)
+              console.log(chalk.yellow("Orchestrator timeout observed: yes"));
+            if (state.background.orchestratorTimeoutMessage)
+              console.log(
+                chalk.yellow(
+                  `Orchestrator timeout detail: ${state.background.orchestratorTimeoutMessage}`
+                )
+              );
+            if (state.background.error)
+              console.log(chalk.red(`Error: ${state.background.error}`));
+            if (state.background.shutdownError)
+              console.log(chalk.red(`Shutdown Error: ${state.background.shutdownError}`));
+            const backgroundWinnerLine = formatMonitorWinnerOrIdentityLine(state);
+            if (backgroundWinnerLine) {
+              console.log(chalk.gray(backgroundWinnerLine));
+            }
+            if (state.synthesis) {
+              console.log(
+                chalk.gray(`Synthesis: ${formatMonitorSynthesisStatus(state.synthesis)}`)
+              );
+            }
+            const bgVariants = state.background.variants;
+            if (bgVariants.length > 0) {
+              console.log(chalk.bold("\nVariants:"));
+              for (const v of bgVariants) {
+                const provider = v.provider ?? "unknown";
+                const label = v.variant ?? provider;
+                const vstatus = v.success === true ? chalk.green(MONITOR_VARIANT_RAN_LABEL) : v.success === false ? chalk.red("Error") : chalk.gray("\u2026");
+                const prUrl = v.prUrl;
+                const details = [];
+                if (prUrl) details.push(prUrl);
+                if (v.cloudTaskId) details.push(`task=${v.cloudTaskId}`);
+                if (typeof v.completeness === "number")
+                  details.push(`complete=${v.completeness}%`);
+                if (v.timedOut) details.push("timed_out");
+                if (v.terminationReason) details.push(`terminated=${v.terminationReason}`);
+                if (v.errorMessage) details.push(`error=${v.errorMessage}`);
+                const honesty = formatMonitorVariantHonestyLine(v);
+                if (honesty) details.push(honesty);
+                const suffix = details.length > 0 ? chalk.gray(` ${details.join(" | ")}`) : "";
+                console.log(`  ${vstatus} ${label}${suffix}`);
+              }
+            } else {
+              console.log(chalk.gray("\nNo variant status yet. Check again shortly."));
+            }
+            return state;
+          }
+          if (opts.json) {
+            console.log(JSON.stringify(buildMonitorJsonPayload(state.rawHandle, state), null, 2));
+            return state;
+          }
+          const headerId = resolveDisplayId(state);
+          const headerTitle = extractTitleFromPrompt(state.prompt);
+          console.log(
+            chalk.bold.cyan(`
+Monitor: ${formatTaskLabel({ title: headerTitle, id: headerId })}`)
+          );
+          if (state.executionMode) {
+            console.log(chalk.cyan(`Mode: ${formatExecutionModeLabel(state.executionMode)}`));
+          }
+          if (state.prompt) {
+            console.log(chalk.gray(`Prompt: ${String(state.prompt).slice(0, 100)}...`));
+          }
+          if (state.status) {
+            console.log(chalk.gray(`Status: ${state.status}`));
+          }
+          if (state.initiatedBy) {
+            console.log(chalk.gray(`Initiated by: ${state.initiatedBy}`));
+          }
+          if (state.outcome) {
+            console.log(chalk.gray(`Outcome: ${state.outcome}`));
+          }
+          console.log(chalk.gray(`Created: ${state.createdAt}`));
+          console.log(chalk.gray(`Updated: ${state.updatedAt}`));
+          if (state.completedAt) {
+            console.log(chalk.gray(`Completed: ${state.completedAt}`));
+          }
+          const winnerLine = formatMonitorWinnerOrIdentityLine(state);
+          if (winnerLine) {
+            console.log(chalk.gray(winnerLine));
+          }
+          if (state.errorMessage) {
+            console.log(chalk.red(`Error: ${state.errorMessage}`));
+          }
+          if (state.synthesis) {
+            console.log(
+              chalk.gray(`Synthesis: ${formatMonitorSynthesisStatus(state.synthesis)}`)
+            );
+          }
+          console.log(chalk.bold("\nVariants/Candidates:"));
+          const items = state.variants;
+          if (items.length === 0) {
+            console.log(chalk.gray("  (no items yet)"));
+          }
+          for (const v of items) {
+            const mode = v.executionMode === "cloud" ? "[cloud]" : "[local]";
+            const status = v.submittedOnly ? chalk.cyan("Submitted") : v.success ? chalk.green(MONITOR_VARIANT_RAN_LABEL) : v.success === false ? chalk.red("Error") : chalk.gray("?");
+            console.log(chalk.gray(`  - ${status} ${mode} ${formatMonitorVariantLabel(v)}`));
+            const details = [];
+            if (v.prNumber) details.push(`PR #${v.prNumber}`);
+            if (v.prUrl) details.push(v.prUrl);
+            const cursorMeta = v.cursorMetadata || v.customMetadata?.cursor;
+            if (v.cloudTaskId) {
+              details.push(`task=${v.cloudTaskId}`);
+            } else if (cursorMeta?.detectedCloudTaskId) {
+              details.push(`task=${cursorMeta.detectedCloudTaskId}`);
+            }
+            if (typeof v.completeness === "number") details.push(`complete=${v.completeness}%`);
+            if (v.timedOut) details.push("timed_out");
+            if (v.terminationReason) details.push(`terminated=${v.terminationReason}`);
+            if (v.errorMessage) details.push(`error=${v.errorMessage}`);
+            const honesty = formatMonitorVariantHonestyLine(v);
+            if (honesty) details.push(honesty);
+            if (cursorMeta?.commitCount !== void 0) {
+              details.push(`commits=${cursorMeta.commitCount}`);
+            }
+            if (cursorMeta?.latestCommitSha) {
+              details.push(`latest=${String(cursorMeta.latestCommitSha).slice(0, 7)}`);
+            }
+            if (details.length > 0) console.log(chalk.gray(`    ${details.join(" \u2022 ")}`));
+            if (cursorMeta && "lastCommentSnippet" in cursorMeta && cursorMeta.lastCommentSnippet) {
+              console.log(
+                chalk.gray(`    ${cursorMeta.lastCommentSnippet}`)
+              );
+            }
+            if (cursorMeta && "lastCommentTimestamp" in cursorMeta && cursorMeta.lastCommentTimestamp) {
+              console.log(
+                chalk.gray(
+                  `    Time: ${cursorMeta.lastCommentTimestamp}`
+                )
+              );
+            }
+          }
+          console.log();
+          console.log(chalk.gray("Tips:"));
+          console.log(chalk.gray("  \u2022 Use --health for operator-oriented run health"));
+          if (opts.detailed) {
+            console.log(chalk.gray("  \u2022 Inspect variant worktrees for retained local output"));
+          }
+          return state;
+        } catch (e) {
+          const message = e instanceof Error ? e.message : String(e);
+          if (opts.json) {
+            console.log(JSON.stringify({ error: `Failed to read handle: ${message}` }));
+          } else {
+            console.log(chalk.red(`Failed to read handle: ${message}`));
+          }
+          failMonitorCommand();
+        }
+      };
+      if (!opts.follow) {
+        await render();
+        if (isLabMode && opts.labId && opts.runId) {
+          const { LabPathResolver } = await import("./lab-mode-YXQ2Y3NG.js");
+          LabPathResolver.getInstance().clearContext();
+        }
+        return;
+      }
+      const intervalSeconds = Number.parseFloat(String(opts.interval || "15"));
+      if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
+        emitError("--interval must be a positive number of seconds");
+        failMonitorCommand();
+      }
+      const intervalMs = Math.max(1e3, intervalSeconds * 1e3);
+      const timeoutMinutes = opts.timeout === void 0 ? void 0 : Number.parseFloat(String(opts.timeout));
+      if (timeoutMinutes !== void 0 && (!Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0)) {
+        emitError("--timeout must be a positive number of minutes");
+        failMonitorCommand();
+      }
+      const deadlineMs = timeoutMinutes === void 0 ? void 0 : Date.now() + timeoutMinutes * 60 * 1e3;
+      const autoloopStateForWatch = readAutoloopTaskState(taskId, {
+        cwd: repoRoot,
+        unifiedStateDir
+      });
+      const watchPath = fs3.existsSync(handlePath) || fs3.existsSync(backgroundHandlePath) ? handlePath : readRunTaskState(taskId, { cwd: repoRoot, unifiedStateDir })?.providerOutputArtifactPath ?? autoloopStateForWatch?.runResultPath ?? autoloopStateForWatch?.trajectoryPath ?? resolveUnifiedStateFilePath(taskId, unifiedStateDir);
+      console.log(
+        chalk.gray(
+          `
+Watching ${watchPath} every ${Math.round(intervalMs / 1e3)}s (Ctrl+C to stop)
+`
+        )
+      );
+      if (isLabMode && opts.labId && opts.runId) {
+        signalCoordinator.register("monitor-follow-cleanup", async () => {
+          const { LabPathResolver } = await import("./lab-mode-YXQ2Y3NG.js");
+          LabPathResolver.getInstance().clearContext();
+        });
+      }
+      const followOnce = async () => {
+        const state = await render();
+        if (state && isTerminalMonitorRenderState(state)) {
+          return state;
+        }
+        if (deadlineMs !== void 0 && Date.now() >= deadlineMs) {
+          if (!opts.json) {
+            console.log(chalk.gray(`Monitor timeout reached after ${timeoutMinutes}m`));
+          }
+          return state;
+        }
+        return state;
+      };
+      const initialState = await followOnce();
+      if (initialState && isTerminalMonitorRenderState(initialState)) {
+        return;
+      }
+      if (deadlineMs !== void 0 && Date.now() >= deadlineMs) {
+        return;
+      }
+      while (true) {
+        await new Promise((r) => setTimeout(r, intervalMs));
+        const state = await followOnce();
+        if (state && isTerminalMonitorRenderState(state)) {
+          return;
+        }
+        if (deadlineMs !== void 0 && Date.now() >= deadlineMs) {
+          return;
+        }
+      }
+    }
+  );
+  return cmd;
+}
+
+export {
+  formatVariantGateSummary,
+  formatMonitorWinnerOrIdentityLine,
+  buildMonitorJsonPayload,
+  buildMonitorHealthSnapshot,
+  createMonitorCommand
+};
+//# sourceMappingURL=chunk-VNDPQVUZ.js.map