@poetic-ai/poetic 1.42.0

package/dist/chunk-ZTT5IVPY.js

@@ -0,0 +1,1160 @@
+import {
+  getVariantOutcome
+} from "./chunk-YTYIEZQY.js";
+import {
+  findLabRunStateForTask
+} from "./chunk-ROMHOSMQ.js";
+import {
+  formatAutoloopMonitorHints,
+  formatRunTaskMonitorHints,
+  hasAutoloopMonitorEvidence,
+  hasRunTaskMonitorEvidence,
+  readAutoloopTaskState,
+  readRunTaskState,
+  resolveUnifiedStateFilePath
+} from "./chunk-AY5EWJPF.js";
+import {
+  readCompetitionState,
+  resolveDisplayId
+} from "./chunk-BLPHWMDK.js";
+import {
+  buildRunHealthSnapshot,
+  classifyRunHealth,
+  summarizeRunHealth
+} from "./chunk-KM3F7SYE.js";
+import {
+  extractTitleFromPrompt,
+  formatExecutionModeLabel,
+  formatTaskLabel
+} from "./chunk-F5JO7HAS.js";
+import {
+  ExitCodeError
+} from "./chunk-FUVP64ER.js";
+import {
+  deriveTestVerificationDisplay,
+  formatVerificationDisplayVerdict
+} from "./chunk-QNOB37UH.js";
+import {
+  getPlanningRoot
+} from "./chunk-OPYFYTWQ.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+
+// src/cli/commands/monitor.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/cli/handlers/compete/variant-gate-summary.ts
+function formatGateStatus(status) {
+  return typeof status === "string" && status.trim().length > 0 ? status.trim().replace(/_/g, "-") : "unknown";
+}
+function formatVariantHonestyGateLine(input) {
+  const line = `test=${formatGateStatus(input.testStatus)} lint=${formatGateStatus(input.lintStatus)}`;
+  return input.verificationStatus === "baseline_clean" ? `${line} (baseline_clean)` : line;
+}
+function formatVariantGateSummary(variant) {
+  const verification = getVariantOutcome(variant).verification;
+  const verificationStatus = verification.status ?? verification.outcome;
+  if (verificationStatus === "baseline_clean") {
+    return [
+      `build=${formatGateStatus(verification.buildStatus)}`,
+      formatVariantHonestyGateLine({
+        testStatus: variant.testStatus ?? verification.testStatus,
+        lintStatus: variant.lintStatus ?? verification.lintStatus,
+        verificationStatus
+      })
+    ].join(" ");
+  }
+  const testDisplay = deriveTestVerificationDisplay({
+    testStatus: verification.testStatus,
+    rawTestStatus: variant.testStatus,
+    exitCode: variant.testsExecuted?.exitCode,
+    failedTests: variant.testMetrics?.failedTests
+  });
+  return [
+    `build=${formatGateStatus(verification.buildStatus)}`,
+    `lint=${formatGateStatus(verification.lintStatus)}`,
+    `test=${formatVerificationDisplayVerdict(testDisplay)}`
+  ].join(" ");
+}
+
+// src/cli/commands/monitor.ts
+function formatMonitorWinnerOrIdentityLine(state) {
+  if (!state.winner) return null;
+  const identityLabel = `${state.winner.provider}${state.winner.model ? `:${state.winner.model}` : ""} ${state.winner.strategy}`;
+  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 verification = variant.outcome?.verification;
+  const testStatus = variant.testStatus ?? verification?.testStatus;
+  const lintStatus = "lintStatus" in variant ? variant.lintStatus : verification && "lintStatus" in verification ? verification.lintStatus : void 0;
+  const verificationStatus = verification?.status;
+  if (testStatus == null && lintStatus == null && verificationStatus == null) {
+    return null;
+  }
+  return formatVariantHonestyGateLine({
+    testStatus,
+    lintStatus,
+    verificationStatus
+  });
+}
+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: poetic 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: poetic 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) {
+  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: updatedAt ? {
+      lastProgressAt: updatedAt,
+      staleAfterMs: 10 * 60 * 1e3,
+      progressLabel: state.background?.activePhase ?? state.status
+    } : void 0,
+    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  poetic monitor T123456\n  poetic monitor T123456 --follow\n  poetic monitor T123456 --detailed --interval 10\n  poetic 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("  poetic monitor <taskId> --lab-id <labId> --run-id <runId>"));
+          console.log(chalk.yellow("\nTo find available labs:"));
+          console.log(chalk.gray("  ls .poetic/labs/  # List lab IDs"));
+          console.log(chalk.gray("  ls .poetic/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(
+              "  poetic 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 .poetic/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(
+              "  poetic monitor T123456 --lab-id lab-abc123 --run-id 20251210-153042-001"
+            )
+          );
+          console.log(chalk.yellow("\nTo find lab IDs:"));
+          console.log(chalk.gray("  ls .poetic/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 poeticDir = path.join(repoRoot, ".poetic");
+      if (isLabMode) {
+        const { LabPathResolver } = await import("./lab-mode-OTWVHN63.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(poeticDir);
+        stateDir = path.join(stateRootDir, "competitions");
+        backgroundDir = path.join(stateRootDir, "background");
+        unifiedStateDir = stateRootDir;
+      } else {
+        stateDir = path.join(poeticDir, "telemetry", "state", "competitions");
+        backgroundDir = path.join(poeticDir, "telemetry", "state", "background");
+        unifiedStateDir = path.join(poeticDir, "state");
+      }
+      let handlePath = path.join(stateDir, `${taskId}.json`);
+      let backgroundHandlePath = path.join(backgroundDir, `${taskId}.json`);
+      if (!isLabMode && !fs.existsSync(handlePath) && !fs.existsSync(backgroundHandlePath)) {
+        const labMatch = findLabRunStateForTask(taskId, poeticDir);
+        if (labMatch) {
+          stateDir = path.join(labMatch.stateRoot, "competitions");
+          backgroundDir = path.join(labMatch.stateRoot, "background");
+          unifiedStateDir = labMatch.stateRoot;
+          handlePath = path.join(stateDir, `${taskId}.json`);
+          backgroundHandlePath = path.join(backgroundDir, `${taskId}.json`);
+        }
+      }
+      const runTaskEvidence = hasRunTaskMonitorEvidence(taskId, {
+        cwd: repoRoot,
+        unifiedStateDir
+      });
+      const autoloopEvidence = hasAutoloopMonitorEvidence(taskId, {
+        cwd: repoRoot,
+        unifiedStateDir
+      });
+      if (!fs.existsSync(handlePath) && !fs.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 (fs.existsSync(stateDir)) {
+            const files = fs.readdirSync(stateDir).filter((f) => f.endsWith(".json"));
+            for (const f of files) {
+              const fullPath = path.join(stateDir, f);
+              const stats = fs.statSync(fullPath);
+              let title;
+              try {
+                const raw = JSON.parse(fs.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 = path.dirname(backgroundHandlePath);
+          if (fs.existsSync(bgDir)) {
+            const bgFiles = fs.readdirSync(bgDir).filter((f) => f.endsWith(".json"));
+            for (const f of bgFiles) {
+              const fullPath = path.join(bgDir, f);
+              const stats = fs.statSync(fullPath);
+              let title;
+              try {
+                const raw = JSON.parse(fs.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: .poetic/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 poetic 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.branch)
+              console.log(chalk.gray(`Branch: ${state.background.branch}`));
+            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("OK") : 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("OK") : v.success === false ? chalk.red("Error") : chalk.gray("?");
+            const line = `${status} ${mode} ${v.provider}${v.model ? `:${v.model}` : ""} ${v.strategy}`;
+            console.log(chalk.gray(`  - ${line}`));
+            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-OTWVHN63.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 = fs.existsSync(handlePath) || fs.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-OTWVHN63.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,
+  createMonitorCommand
+};
+//# sourceMappingURL=chunk-ZTT5IVPY.js.map