@poetic-ai/poetic 1.42.0

package/dist/chunk-KM3F7SYE.js

@@ -0,0 +1,702 @@
+// 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|unauthori[sz]ed|token|credential|login/i.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: `poetic 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 ? `poetic monitor ${snapshot.taskId} --detailed` : "poetic providers"
+          }
+        ]
+      })
+    );
+  }
+  return events;
+}
+function classifyProgress(snapshot) {
+  if (!statusIsActive(snapshot)) return null;
+  const progress = snapshot.progress;
+  if (!progress) return null;
+  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 ? `poetic monitor ${snapshot.taskId} --detailed` : "poetic 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 ? `poetic cost history --task ${snapshot.taskId}` : "poetic 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 ? `poetic compete results ${snapshot.taskId}` : "poetic compete 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: "Poetic 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 ? `poetic monitor ${snapshot.taskId} --detailed` : "poetic 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: "poetic 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 Poetic 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: "poetic 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 severityRank(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) => severityRank(b.severity) - severityRank(a.severity));
+}
+
+// src/core/health/snapshot.ts
+import * as fs from "fs";
+import * as path from "path";
+function buildRunHealthSnapshot(input = {}) {
+  return {
+    ...input,
+    status: input.status ?? "unknown",
+    now: input.now ?? Date.now()
+  };
+}
+function severityRank2(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) => severityRank2(event.severity) > severityRank2(worst) ? event.severity : worst,
+    "info"
+  );
+  return {
+    events,
+    worstSeverity,
+    categories
+  };
+}
+function safeSettle(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+function readJsonFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readNum(record, key) {
+  const v = record[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function readStr(record, key) {
+  const v = record[key];
+  return typeof v === "string" && v.trim().length > 0 ? v : void 0;
+}
+function readBool(record, key) {
+  const v = record[key];
+  return typeof v === "boolean" ? v : void 0;
+}
+function buildProgressSignal(stateRecord, now) {
+  return safeSettle(() => {
+    const updatedAtStr = readStr(stateRecord, "updatedAt") ?? readStr(stateRecord, "updated_at");
+    const startedAtStr = readStr(stateRecord, "startedAt") ?? readStr(stateRecord, "started_at");
+    const activePhase = readStr(stateRecord, "activePhase");
+    const status = readStr(stateRecord, "status");
+    const lastProgressAt = updatedAtStr ? Date.parse(updatedAtStr) : void 0;
+    const startedAt = startedAtStr ? Date.parse(startedAtStr) : void 0;
+    if (!lastProgressAt && !startedAt) return void 0;
+    const stallCheckAt = lastProgressAt ?? startedAt;
+    const staleForMs = stallCheckAt !== void 0 ? now - stallCheckAt : void 0;
+    const staleAfterMs = 10 * 60 * 1e3;
+    return {
+      lastProgressAt: lastProgressAt ?? startedAt,
+      staleAfterMs,
+      stalled: staleForMs !== void 0 && staleForMs >= staleAfterMs && isActiveStateRecord(stateRecord),
+      progressLabel: activePhase ?? status
+    };
+  });
+}
+function isActiveStateRecord(record) {
+  const ACTIVE = /* @__PURE__ */ new Set([
+    "queued",
+    "pending",
+    "starting",
+    "running",
+    "processing",
+    "verifying",
+    "active",
+    "executing",
+    "in-progress",
+    "in_progress",
+    "submitted",
+    "submitting"
+  ]);
+  const status = readStr(record, "status") ?? readStr(record, "state") ?? "";
+  return ACTIVE.has(status.toLowerCase());
+}
+function buildProviderHealthSignals(providerHealthCachePath, providerIds) {
+  return safeSettle(() => {
+    if (!fs.existsSync(providerHealthCachePath)) return [];
+    const cache = readJsonFile(providerHealthCachePath);
+    if (!cache) return [];
+    return providerIds.map((providerId) => {
+      const entry = cache[providerId];
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+      const e = entry;
+      const consecutiveFailures = readNum(e, "consecutiveFailures") ?? 0;
+      const lastFailurePhase = readStr(e, "lastFailurePhase");
+      const degradedUntil = readNum(e, "degradedUntil");
+      const now = Date.now();
+      const isDegraded = degradedUntil !== void 0 && degradedUntil > now;
+      return {
+        provider: providerId,
+        availability: isDegraded ? "degraded" : consecutiveFailures >= 5 ? "unavailable" : consecutiveFailures >= 3 ? "degraded" : "ready",
+        consecutiveFailures,
+        lastFailurePhase,
+        lastError: readStr(e, "lastError")
+      };
+    }).filter((s) => s !== null);
+  }) ?? [];
+}
+function inferProviderHealthFromVariants(variants) {
+  return variants.filter(
+    (v) => typeof v === "object" && v !== null && !Array.isArray(v)
+  ).map((v) => {
+    const provider = readStr(v, "provider");
+    if (!provider) return null;
+    const errorMessage = readStr(v, "errorMessage") ?? readStr(v, "terminationReason") ?? "";
+    const lowerError = errorMessage.toLowerCase();
+    const authBroken = /auth|unauthori[sz]ed|token|credential|login/.test(lowerError);
+    const timedOut = readBool(v, "timedOut") === true || /timeout|timed.?out/.test(lowerError);
+    const outputFailure = /json|schema|parse|malformed|unparseable|truncated/.test(lowerError);
+    const success = readBool(v, "success");
+    return {
+      provider,
+      variant: readStr(v, "variant"),
+      authState: authBroken ? "invalid" : void 0,
+      availability: success === false && !authBroken ? timedOut ? "degraded" : "unavailable" : void 0,
+      lastError: errorMessage || void 0,
+      lastFailurePhase: authBroken ? "startup" : timedOut ? "timeout" : outputFailure ? "output" : success === false ? "mid_execution" : void 0,
+      consecutiveFailures: success === false ? 1 : void 0
+    };
+  }).filter((s) => s !== null);
+}
+function buildBudgetSignal(budgetRecord) {
+  return safeSettle(() => {
+    const spent = readNum(budgetRecord, "spent") ?? readNum(budgetRecord, "spentUsd") ?? readNum(budgetRecord, "totalCostUsd");
+    const limit = readNum(budgetRecord, "limit") ?? readNum(budgetRecord, "limitUsd");
+    const remaining = readNum(budgetRecord, "remaining");
+    if (spent === void 0 && limit === void 0) return void 0;
+    const projectedUsd = spent !== void 0 && limit !== void 0 && remaining !== void 0 ? spent + (spent > 0 && remaining > 0 && limit > remaining ? spent / (limit - remaining) * remaining : 0) : void 0;
+    const burnRateRatio = spent !== void 0 && limit !== void 0 && limit > 0 ? spent / limit : void 0;
+    return {
+      spentUsd: spent,
+      limitUsd: limit,
+      projectedUsd,
+      burnRateRatio
+    };
+  });
+}
+function buildJudgeSignal(stateRecord, variants) {
+  return safeSettle(() => {
+    const outcome = readStr(stateRecord, "outcome");
+    const errorMessage = readStr(stateRecord, "errorMessage");
+    const winner = stateRecord.winner;
+    const completedVariants = Array.isArray(variants) ? variants.filter(
+      (v) => typeof v === "object" && v !== null && readBool(v, "success") === true
+    ).length : 0;
+    const noWinner = outcome === "no_winner" || completedVariants > 1 && !winner && outcome !== "failed";
+    if (!noWinner && !errorMessage) return void 0;
+    const status = errorMessage ? "failed" : noWinner ? "no_winner" : "selected";
+    return {
+      status,
+      completedVariants,
+      reason: noWinner ? "No winner was selected." : errorMessage
+    };
+  });
+}
+function buildOutputSignal(variants) {
+  return safeSettle(() => {
+    const failedVariants = (Array.isArray(variants) ? variants : []).filter(
+      (v) => typeof v === "object" && v !== null && readBool(v, "success") === false
+    );
+    const parseErrors = failedVariants.map((v) => readStr(v, "errorMessage") ?? readStr(v, "terminationReason") ?? "").filter((msg) => /json|schema|parse|malformed|unparseable|truncated/i.test(msg));
+    if (parseErrors.length === 0) return void 0;
+    return {
+      parseErrors,
+      unparseable: true
+    };
+  });
+}
+function buildWorktreeSignal(worktreeStatePath) {
+  return safeSettle(() => {
+    if (!fs.existsSync(worktreeStatePath)) return void 0;
+    const record = readJsonFile(worktreeStatePath);
+    if (!record) return void 0;
+    const cleanupBlocked = readBool(record, "cleanupBlocked");
+    const reuseBlocked = readBool(record, "reuseBlocked");
+    const dirty = readBool(record, "dirty");
+    const staleLock = readBool(record, "staleLock");
+    const preservedForReview = readBool(record, "preservedForReview");
+    if (!cleanupBlocked && !reuseBlocked && !dirty && !staleLock && !preservedForReview) {
+      return void 0;
+    }
+    return {
+      cleanupBlocked: cleanupBlocked ?? false,
+      reuseBlocked: reuseBlocked ?? false,
+      dirty: dirty ?? false,
+      staleLock: staleLock ?? false,
+      preservedForReview: preservedForReview ?? false,
+      reason: readStr(record, "reason"),
+      path: readStr(record, "path")
+    };
+  });
+}
+function buildHandoffSignal(stateRecord) {
+  return safeSettle(() => {
+    const completedAt = readStr(stateRecord, "completedAt");
+    const synthesis = stateRecord.synthesis;
+    if (!completedAt || !synthesis || typeof synthesis !== "object" || Array.isArray(synthesis)) {
+      return void 0;
+    }
+    const s = synthesis;
+    return {
+      runCompleted: true,
+      success: readBool(s, "success") === true || readBool(s, "deliverySucceeded") === true,
+      changesProduced: readBool(s, "synthesisApplied") === true || readBool(s, "winnerFallback") === true,
+      durableArtifactPresent: Boolean(
+        readNum(s, "prNumber") || readStr(s, "prUrl") || readBool(s, "deliverySucceeded") || readBool(s, "synthesisApplied")
+      ),
+      reviewArtifactPresent: Boolean(readNum(s, "prNumber") || readStr(s, "prUrl")),
+      applied: readBool(s, "synthesisApplied"),
+      artifactPath: readStr(s, "artifactPath")
+    };
+  });
+}
+function buildCompetitionHealthSnapshot(input) {
+  const now = input.now ?? Date.now();
+  const stateRecord = input.stateRecord !== void 0 ? input.stateRecord : safeSettle(() => readJsonFile(input.stateFilePath));
+  if (!stateRecord) {
+    return buildRunHealthSnapshot({ status: "unknown", now });
+  }
+  const status = deriveLifecycleStatus(stateRecord);
+  const runId = readStr(stateRecord, "taskId") ?? readStr(stateRecord, "evaluationId") ?? path.basename(input.stateFilePath, ".json");
+  const taskId = runId;
+  const startedAt = parseTimestamp(
+    readStr(stateRecord, "startedAt") ?? readStr(stateRecord, "createdAt")
+  );
+  const updatedAt = parseTimestamp(readStr(stateRecord, "updatedAt"));
+  const resultRecord = stateRecord.result && typeof stateRecord.result === "object" ? stateRecord.result : void 0;
+  const rawVariants = Array.isArray(stateRecord.variants) ? stateRecord.variants : Array.isArray(stateRecord.candidates) ? stateRecord.candidates : Array.isArray(resultRecord?.variants) ? resultRecord.variants : [];
+  const progress = buildProgressSignal(stateRecord, now);
+  let providers;
+  if (input.providerHealthCachePath && fs.existsSync(input.providerHealthCachePath)) {
+    const providerIds = rawVariants.filter((v) => typeof v === "object" && v !== null).map((v) => readStr(v, "provider")).filter((id) => Boolean(id));
+    const uniqueIds = [...new Set(providerIds)];
+    const cached = buildProviderHealthSignals(input.providerHealthCachePath, uniqueIds);
+    providers = cached.length > 0 ? cached : inferProviderHealthFromVariants(rawVariants);
+  } else {
+    providers = inferProviderHealthFromVariants(rawVariants);
+  }
+  const budgetRecord = stateRecord.budget instanceof Object && !Array.isArray(stateRecord.budget) ? stateRecord.budget : null;
+  const budget = budgetRecord ? buildBudgetSignal(budgetRecord) : void 0;
+  const judge = buildJudgeSignal(stateRecord, rawVariants);
+  const output = buildOutputSignal(rawVariants);
+  const worktree = input.worktreeStatePath ? buildWorktreeSignal(input.worktreeStatePath) : void 0;
+  const handoff = buildHandoffSignal(stateRecord);
+  return buildRunHealthSnapshot({
+    runId,
+    taskId,
+    status,
+    now,
+    startedAt,
+    updatedAt,
+    providers: providers.length > 0 ? providers : void 0,
+    progress,
+    budget,
+    judge,
+    output,
+    worktree,
+    handoff
+  });
+}
+function parseTimestamp(value) {
+  if (!value) return void 0;
+  const ts = Date.parse(value);
+  return Number.isFinite(ts) ? ts : void 0;
+}
+function deriveLifecycleStatus(record) {
+  const raw = readStr(record, "status") ?? readStr(record, "state") ?? "unknown";
+  const s = raw.toLowerCase();
+  switch (s) {
+    case "queued":
+    case "pending":
+    case "starting":
+    case "running":
+    case "processing":
+    case "verifying":
+    case "completed":
+    case "failed":
+    case "cancelled":
+    case "idle":
+      return s;
+    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";
+  }
+}
+
+export {
+  classifyRunHealth,
+  buildRunHealthSnapshot,
+  summarizeRunHealth,
+  buildCompetitionHealthSnapshot
+};
+//# sourceMappingURL=chunk-KM3F7SYE.js.map