@poetic-ai/poetic 1.42.0

package/dist/chunk-BLPHWMDK.js

@@ -0,0 +1,797 @@
+import {
+  sanitizeSynthesisArtifactForPersistence
+} from "./chunk-GG6KJYW6.js";
+import {
+  parseVariantIdentifier
+} from "./chunk-CP7H3HSP.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  getExecutionContext,
+  hasExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  resolveProjectRuntimeDir
+} from "./chunk-RGWHUI5E.js";
+import {
+  resolveCliRepoRoot
+} from "./chunk-L7JZLXQL.js";
+
+// src/cli/utils/cli-state-roots.ts
+import path from "path";
+function resolveCliStateRoots(cwd = process.cwd()) {
+  const repoRoot = resolveCliRepoRoot(cwd);
+  const useAmbientRuntime = path.resolve(cwd) === path.resolve(process.cwd());
+  const runtimePoeticDir = useAmbientRuntime ? getRuntimeEnv("POETIC_TELEMETRY_DIR") : void 0;
+  const contextPoeticDir = useAmbientRuntime && hasExecutionContext() ? getExecutionContext().poeticDir : void 0;
+  const ambientPoeticDir = runtimePoeticDir ?? contextPoeticDir;
+  const poeticDir = path.resolve(ambientPoeticDir ?? path.join(repoRoot, ".poetic"));
+  const telemetryDir = path.join(poeticDir, "telemetry");
+  const telemetryStateDir = path.join(telemetryDir, "state");
+  return {
+    repoRoot,
+    poeticDir,
+    telemetryDir,
+    telemetryStateDir,
+    competitionsDir: path.join(telemetryStateDir, "competitions"),
+    backgroundDir: path.join(telemetryStateDir, "background"),
+    unifiedStateDir: resolveProjectRuntimeDir(poeticDir, "state")
+  };
+}
+
+// src/cli/utils/competition-state-reader.ts
+import * as fs from "fs";
+import * as path2 from "path";
+function normaliseRunMetadata(metadata) {
+  if (!metadata) return metadata;
+  const { presentationMode: legacyRunSemantics, ...currentMetadata } = metadata;
+  if (currentMetadata.runSemantics !== void 0 || legacyRunSemantics === void 0) {
+    return currentMetadata;
+  }
+  return {
+    ...currentMetadata,
+    runSemantics: legacyRunSemantics
+  };
+}
+function isRawHandleVariant(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRawBackgroundVariant(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCompetitionHandleStillRunning(handle) {
+  return handle.status === "running";
+}
+function isBackgroundHandleTerminal(handle) {
+  return handle.status === "completed" || handle.status === "failed" || handle.status === "terminated";
+}
+function isBackgroundHandleRunning(handle) {
+  return handle.status === "running";
+}
+function isCompetitionHandleTerminal(handle) {
+  return handle.status === "completed" || handle.status === "failed" || handle.status === "terminated";
+}
+function handleVariantIsTerminal(variant) {
+  return variant.success !== void 0 || variant.timedOut === true || Boolean(variant.errorMessage);
+}
+function deriveTerminalHandleStatus(handle) {
+  if (isCompetitionHandleTerminal(handle)) return handle.status;
+  if (handle.status !== "running") return handle.status;
+  if (typeof handle.completedAt !== "string" && typeof handle.outcome !== "string") {
+    return handle.status;
+  }
+  if (handle.outcome === "error" || handle.outcome === "all_failed" || handle.errorMessage) {
+    return "failed";
+  }
+  if (handle.outcome === "winner_selected" || handle.outcome === "no_winner" || handle.outcome === "timed_out") {
+    return "completed";
+  }
+  const rawItems = Array.isArray(handle.candidates) ? handle.candidates : Array.isArray(handle.variants) ? handle.variants : [];
+  if (typeof handle.completedAt === "string" && rawItems.length > 0 && rawItems.every((variant) => isRawHandleVariant(variant) && handleVariantIsTerminal(variant))) {
+    return "completed";
+  }
+  return handle.status;
+}
+function probeSource(filePath, readAt) {
+  const exists = fs.existsSync(filePath);
+  if (!exists) return { path: filePath, readAt, exists };
+  try {
+    return {
+      path: filePath,
+      readAt,
+      exists,
+      modifiedAt: fs.statSync(filePath).mtime.toISOString()
+    };
+  } catch {
+    return { path: filePath, readAt, exists };
+  }
+}
+function normaliseHandleVariant(v) {
+  return {
+    provider: v.provider,
+    requestedProvider: v.requestedProvider,
+    model: v.model,
+    requestedModel: v.requestedModel,
+    resolvedModel: v.resolvedModel,
+    providerCliVersion: v.providerCliVersion,
+    failoverFromProvider: v.failoverFromProvider,
+    failoverReason: v.failoverReason,
+    strategy: v.strategy,
+    executionMode: v.executionMode,
+    variant: v.variant,
+    workspaceMode: v.workspaceMode,
+    workspaceModeRequested: v.workspaceModeRequested,
+    reasoningEffort: v.reasoningEffort,
+    cursorPromptProfile: v.cursorPromptProfile,
+    submittedOnly: v.submittedOnly,
+    success: v.success,
+    outcome: v.outcome,
+    buildStatus: v.buildStatus,
+    lintStatus: v.lintStatus,
+    testStatus: v.testStatus,
+    testMetrics: v.testMetrics,
+    testsExecuted: v.testsExecuted,
+    prNumber: v.prNumber,
+    prUrl: v.prUrl,
+    cloudTaskId: v.cloudTaskId,
+    completeness: v.completeness,
+    duration: v.duration,
+    errorMessage: v.errorMessage,
+    providerDiagnostics: v.providerDiagnostics,
+    authError: v.authError,
+    timedOut: v.timedOut,
+    terminationReason: v.terminationReason,
+    retainedWorktreePath: optionalString(v.retainedWorktreePath),
+    branchName: optionalString(v.branchName),
+    baselineRef: optionalString(v.baselineRef),
+    artifactPath: optionalString(v.artifactPath),
+    artifactManifest: optionalString(v.artifactManifest),
+    filesChanged: optionalNumber(v.filesChanged),
+    ignoredPathEvidence: v.ignoredPathEvidence,
+    inputSpecWarning: normaliseInputSpecWarning(v.inputSpecWarning),
+    cursorMetadata: v.cursorMetadata,
+    customMetadata: v.customMetadata
+  };
+}
+function normaliseInputSpecWarning(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const warning = {};
+  if (typeof record.completenessScore === "number" && Number.isFinite(record.completenessScore)) {
+    warning.completenessScore = record.completenessScore;
+  }
+  if (Array.isArray(record.missingFields)) {
+    warning.missingFields = record.missingFields.filter(
+      (field) => typeof field === "string"
+    );
+  }
+  if (typeof record.hasFillPlaceholders === "boolean") {
+    warning.hasFillPlaceholders = record.hasFillPlaceholders;
+  }
+  return Object.keys(warning).length > 0 ? warning : void 0;
+}
+function normaliseBackgroundVariant(v) {
+  return {
+    provider: v.provider,
+    model: v.model,
+    variant: v.variant,
+    strategy: v.strategy,
+    executionMode: v.executionMode,
+    prNumber: v.prNumber,
+    prUrl: v.prUrl,
+    cloudTaskId: v.cloudTaskId,
+    completeness: v.completeness,
+    duration: v.duration,
+    errorMessage: v.errorMessage,
+    providerDiagnostics: v.providerDiagnostics,
+    authError: v.authError,
+    timedOut: v.timedOut,
+    terminationReason: v.terminationReason,
+    submittedOnly: v.submittedOnly,
+    success: v.success,
+    outcome: v.outcome,
+    lintStatus: v.lintStatus,
+    testStatus: v.testStatus,
+    testMetrics: v.testMetrics,
+    testsExecuted: v.testsExecuted,
+    inputSpecWarning: normaliseInputSpecWarning(v.inputSpecWarning)
+  };
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function normaliseCompetitionSynthesis(synthesis) {
+  if (!synthesis || typeof synthesis !== "object") return void 0;
+  return {
+    success: optionalBoolean(synthesis.success),
+    prNumber: optionalNumber(synthesis.prNumber),
+    prUrl: optionalString(synthesis.prUrl),
+    error: optionalString(synthesis.error),
+    mergedVariants: Array.isArray(synthesis.mergedVariants) ? synthesis.mergedVariants.filter((value) => typeof value === "string") : [],
+    synthesisIntents: Array.isArray(synthesis.synthesisIntents) ? synthesis.synthesisIntents : void 0,
+    donorProfiles: Array.isArray(synthesis.donorProfiles) ? synthesis.donorProfiles : void 0,
+    donorSelectionDecisions: Array.isArray(synthesis.donorSelectionDecisions) ? synthesis.donorSelectionDecisions : void 0,
+    intentFilteredHunkCount: optionalNumber(synthesis.intentFilteredHunkCount),
+    excludedHunkCount: optionalNumber(synthesis.excludedHunkCount),
+    unknownIncludedHunkCount: optionalNumber(synthesis.unknownIncludedHunkCount),
+    unknownExcludedHunkCount: optionalNumber(synthesis.unknownExcludedHunkCount),
+    intentMaterialSummaries: Array.isArray(synthesis.intentMaterialSummaries) ? synthesis.intentMaterialSummaries : void 0,
+    overlapRejectedHunkCount: optionalNumber(synthesis.overlapRejectedHunkCount),
+    deliverySucceeded: optionalBoolean(synthesis.deliverySucceeded),
+    synthesisApplied: optionalBoolean(synthesis.synthesisApplied),
+    complementaryPatchApplied: optionalBoolean(synthesis.complementaryPatchApplied),
+    applyMode: optionalString(synthesis.applyMode),
+    winnerFallback: optionalBoolean(synthesis.winnerFallback),
+    fallbackReason: optionalString(synthesis.fallbackReason),
+    patchApplyValidated: optionalBoolean(synthesis.patchApplyValidated),
+    gatesPassed: optionalBoolean(synthesis.gatesPassed),
+    gateFailureDetails: synthesis.gateFailureDetails,
+    aiGuidedFallbackAttempted: optionalBoolean(synthesis.aiGuidedFallbackAttempted),
+    aiGuidedFallbackOutcome: optionalString(synthesis.aiGuidedFallbackOutcome),
+    synthesisOutcomeStatus: optionalString(synthesis.synthesisOutcomeStatus),
+    synthesisDurationMs: optionalNumber(synthesis.synthesisDurationMs),
+    synthesisProvider: optionalString(synthesis.synthesisProvider),
+    synthesisModel: optionalString(synthesis.synthesisModel),
+    synthesisProviderDurationMs: optionalNumber(synthesis.synthesisProviderDurationMs),
+    synthesisGateDurationMs: optionalNumber(synthesis.synthesisGateDurationMs)
+  };
+}
+function deriveCompetitionVariantFromBackground(variant) {
+  const rawLabel = typeof variant.variant === "string" ? variant.variant.trim() : "";
+  const parsed = rawLabel.length > 0 ? parseVariantIdentifier(rawLabel) : void 0;
+  return {
+    provider: variant.provider ?? parsed?.provider ?? "unknown",
+    model: variant.model ?? parsed?.model,
+    strategy: variant.strategy ?? parsed?.strategy ?? "unknown",
+    executionMode: variant.executionMode ?? parsed?.executionMode,
+    success: variant.success,
+    outcome: variant.outcome,
+    prNumber: variant.prNumber,
+    prUrl: variant.prUrl,
+    cloudTaskId: variant.cloudTaskId,
+    completeness: variant.completeness,
+    duration: variant.duration,
+    errorMessage: variant.errorMessage,
+    providerDiagnostics: variant.providerDiagnostics,
+    authError: variant.authError,
+    timedOut: variant.timedOut,
+    terminationReason: variant.terminationReason,
+    submittedOnly: variant.submittedOnly,
+    inputSpecWarning: variant.inputSpecWarning
+  };
+}
+function readCompetitionState(taskId, opts) {
+  const roots = resolveCliStateRoots(opts?.cwd);
+  const stateDir = opts?.stateDir ?? roots.competitionsDir;
+  const bgDir = opts?.backgroundDir ?? roots.backgroundDir;
+  const bgDirs = opts?.backgroundDirs?.length ? opts.backgroundDirs : [bgDir];
+  const unifiedDir = opts?.unifiedStateDir ?? roots.unifiedStateDir;
+  const safeRawStateId = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(taskId);
+  const invalidTaskIdMessage = `Invalid competition task ID for raw state files: ${taskId}`;
+  const handlePath = safeRawStateId ? path2.join(stateDir, `${taskId}.json`) : "";
+  const bgPath = safeRawStateId ? bgDirs.map((candidateDir) => path2.join(candidateDir, `${taskId}.json`)).find((candidatePath) => fs.existsSync(candidatePath)) ?? path2.join(bgDirs[0] ?? bgDir, `${taskId}.json`) : "";
+  const safeId = taskId.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const unifiedPath = path2.join(unifiedDir, `${safeId}.json`);
+  const readAt = (/* @__PURE__ */ new Date()).toISOString();
+  const compSource = safeRawStateId ? probeSource(handlePath, readAt) : {
+    path: "",
+    readAt,
+    exists: false,
+    parseError: invalidTaskIdMessage
+  };
+  let handleData = null;
+  if (compSource.exists) {
+    try {
+      const parsed = parseJsonWithContext(
+        fs.readFileSync(handlePath, "utf8"),
+        `Competition handle (${taskId})`
+      );
+      handleData = sanitizeSynthesisArtifactForPersistence(parsed);
+    } catch (e) {
+      compSource.parseError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  const bgSource = safeRawStateId ? probeSource(bgPath, readAt) : {
+    path: "",
+    readAt,
+    exists: false,
+    parseError: invalidTaskIdMessage
+  };
+  let bgData = null;
+  if (bgSource.exists) {
+    try {
+      const parsed = parseJsonWithContext(
+        fs.readFileSync(bgPath, "utf8"),
+        `Background handle (${taskId})`
+      );
+      bgData = sanitizeSynthesisArtifactForPersistence(parsed);
+    } catch (e) {
+      bgSource.parseError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  const unifiedSource = probeSource(unifiedPath, readAt);
+  let executionMode;
+  if (unifiedSource.exists) {
+    try {
+      const parsed = parseJsonWithContext(
+        fs.readFileSync(unifiedPath, "utf8"),
+        `Unified state (${taskId})`
+      );
+      const m = parsed.executionMode;
+      executionMode = m === "autoloop" || m === "repair_loop" || m === "single_pass" ? m : void 0;
+    } catch (e) {
+      unifiedSource.parseError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  const sources = {
+    competitionHandle: compSource,
+    backgroundHandle: bgSource,
+    unifiedState: unifiedSource
+  };
+  const preferBackgroundTerminalState = handleData !== null && bgData !== null && isCompetitionHandleStillRunning(handleData) && isBackgroundHandleTerminal(bgData);
+  const preferBackgroundRunningState = handleData !== null && bgData !== null && isCompetitionHandleTerminal(handleData) && isBackgroundHandleRunning(bgData);
+  if (handleData !== null && !preferBackgroundTerminalState && !preferBackgroundRunningState) {
+    const rawItems = Array.isArray(handleData.candidates) ? handleData.candidates : Array.isArray(handleData.variants) ? handleData.variants : [];
+    const variants = rawItems.filter(isRawHandleVariant).map(normaliseHandleVariant);
+    const status = deriveTerminalHandleStatus(handleData);
+    return {
+      taskId,
+      primarySource: "competition_handle",
+      prompt: handleData.prompt,
+      initiatedBy: handleData.initiatedBy,
+      createdAt: handleData.createdAt,
+      updatedAt: handleData.updatedAt,
+      status,
+      outcome: handleData.outcome,
+      completedAt: handleData.completedAt,
+      errorMessage: handleData.errorMessage,
+      winner: handleData.winner,
+      winnerVerification: handleData.winnerVerification ?? void 0,
+      labId: handleData.labId,
+      labRunId: handleData.labRunId,
+      runMetadata: normaliseRunMetadata(handleData.runMetadata),
+      decision: handleData.decision,
+      judgeFailures: handleData.judgeFailures,
+      tieBreak: handleData.tieBreak,
+      synthesis: normaliseCompetitionSynthesis(handleData.synthesis),
+      application: handleData.application,
+      variants,
+      executionMode,
+      sources,
+      rawHandle: handleData
+    };
+  }
+  if (bgData !== null) {
+    const rawVariants = Array.isArray(bgData.result?.variants) ? bgData.result.variants : Array.isArray(bgData.variants) ? bgData.variants : [];
+    const backgroundWinner = bgData.result?.winner ?? null;
+    const backgroundSynthesis = normaliseCompetitionSynthesis(bgData.result?.synthesis);
+    const background = {
+      pid: bgData.pid,
+      status: bgData.status,
+      branch: bgData.branch,
+      startedAt: bgData.startedAt,
+      completedAt: bgData.completedAt,
+      failedAt: bgData.failedAt,
+      terminatedAt: bgData.terminatedAt,
+      signalReceivedAt: bgData.signalReceivedAt,
+      signal: bgData.signal,
+      signalDiagnostics: bgData.signalDiagnostics,
+      terminationSource: bgData.terminationSource,
+      activePhase: bgData.activePhase,
+      elapsedMs: bgData.elapsedMs,
+      timeoutMinutes: bgData.timeoutMinutes,
+      executorTimeoutMinutes: bgData.executorTimeoutMinutes,
+      detachMethod: bgData.detachMethod,
+      launcherPid: bgData.launcherPid,
+      launcherParentPid: bgData.launcherParentPid,
+      launcherPlatform: bgData.launcherPlatform,
+      launcherCwd: bgData.launcherCwd,
+      detachDisabled: bgData.detachDisabled,
+      orchestratorTimeoutObserved: bgData.orchestratorTimeoutObserved,
+      orchestratorTimeoutMessage: bgData.orchestratorTimeoutMessage,
+      error: bgData.error,
+      shutdownError: bgData.shutdownError,
+      prompt: bgData.prompt,
+      variants: rawVariants.filter(isRawBackgroundVariant).map(normaliseBackgroundVariant)
+    };
+    return {
+      taskId,
+      primarySource: "background_handle",
+      prompt: bgData.prompt,
+      initiatedBy: bgData.initiatedBy,
+      status: bgData.status,
+      outcome: backgroundWinner ? "winner_selected" : bgData.result?.success === false ? "all_failed" : void 0,
+      completedAt: bgData.completedAt,
+      errorMessage: bgData.error,
+      winner: backgroundWinner,
+      winnerVerification: bgData.result?.winnerVerification ?? void 0,
+      synthesis: backgroundSynthesis,
+      background,
+      variants: background.variants.map(deriveCompetitionVariantFromBackground),
+      executionMode,
+      sources,
+      rawHandle: bgData
+    };
+  }
+  return {
+    taskId,
+    primarySource: "none",
+    variants: [],
+    executionMode,
+    sources
+  };
+}
+async function getMostRecentCompetitionId(opts) {
+  const { readdir, stat } = await import("fs/promises");
+  const roots = resolveCliStateRoots(opts?.cwd);
+  const stateDir = opts?.stateDir ?? roots.competitionsDir;
+  let entries;
+  try {
+    const dirents = await readdir(stateDir, { withFileTypes: true });
+    entries = [];
+    for (const d of dirents) {
+      if (!d.isFile() || !d.name.endsWith(".json")) continue;
+      const fullPath = path2.join(stateDir, d.name);
+      const st = await stat(fullPath);
+      entries.push({ name: d.name, mtimeMs: st.mtimeMs });
+    }
+  } catch {
+    return null;
+  }
+  if (entries.length === 0) return null;
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const first = entries[0];
+  return first ? first.name.replace(/\.json$/, "") : null;
+}
+function readCompetitionEvents(taskId, opts) {
+  const roots = resolveCliStateRoots(opts?.cwd);
+  const stateDir = opts?.stateDir ?? roots.competitionsDir;
+  const safeRawStateId = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(taskId);
+  if (!safeRawStateId) return [];
+  const eventsPath = path2.join(stateDir, `${taskId}.events.jsonl`);
+  if (!fs.existsSync(eventsPath)) return [];
+  let raw;
+  try {
+    raw = fs.readFileSync(eventsPath, "utf8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = sanitizeSynthesisArtifactForPersistence(JSON.parse(trimmed));
+      events.push(parsed);
+    } catch {
+    }
+  }
+  events.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+  return events;
+}
+function resolveDisplayId(state) {
+  if (state.rawHandle && typeof state.rawHandle === "object") {
+    const h = state.rawHandle;
+    if (typeof h.evaluationId === "string") return h.evaluationId;
+    if (typeof h.taskId === "string") return h.taskId;
+  }
+  return state.taskId;
+}
+var RUN_SNAPSHOT_SCHEMA_VERSION_V1 = "1.0.0";
+var RunSnapshotCompatibilityError = class extends Error {
+  constructor(requestedVersion) {
+    super(
+      `Incompatible RunSnapshot schema version ${requestedVersion}; supported major version is 1`
+    );
+    this.requestedVersion = requestedVersion;
+    this.name = "RunSnapshotCompatibilityError";
+  }
+  requestedVersion;
+};
+function resolveRunSnapshotCompatibility(requestedVersion = RUN_SNAPSHOT_SCHEMA_VERSION_V1) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(requestedVersion);
+  if (!match || match[1] !== "1") throw new RunSnapshotCompatibilityError(requestedVersion);
+  return {
+    state: requestedVersion === RUN_SNAPSHOT_SCHEMA_VERSION_V1 ? "exact" : "compatible_minor_difference",
+    requestedVersion,
+    providedVersion: RUN_SNAPSHOT_SCHEMA_VERSION_V1
+  };
+}
+function variantSnapshotStatus(variant) {
+  if (variant.submittedOnly === true) return "detached";
+  if (variant.success === true) return "succeeded";
+  if (variant.timedOut === true || variant.success === false || variant.errorMessage)
+    return "failed";
+  return "running";
+}
+function evidenceReference(kind, value, variant) {
+  return typeof value === "string" && value.length > 0 ? [{ kind, value, ...variant ? { variant } : {} }] : [];
+}
+function variantSnapshot(variant, index) {
+  const id = variant.variant ?? `${variant.provider}:${variant.strategy}:${index + 1}`;
+  const status = variantSnapshotStatus(variant);
+  const evidence = [
+    ...evidenceReference("worktree", variant.retainedWorktreePath, id),
+    ...evidenceReference("branch", variant.branchName, id),
+    ...evidenceReference("commit", variant.baselineRef, id),
+    ...evidenceReference("commit", variant.cursorMetadata?.latestCommitSha, id),
+    ...evidenceReference("artifact", variant.artifactManifest, id),
+    ...evidenceReference("patch", variant.artifactPath, id)
+  ];
+  return {
+    id,
+    provider: variant.provider,
+    model: variant.resolvedModel ?? variant.model,
+    status,
+    phase: status === "running" || status === "detached" ? "execution" : "complete",
+    worktree: variant.retainedWorktreePath,
+    branch: variant.branchName,
+    changedFiles: variant.filesChanged,
+    verification: {
+      buildStatus: variant.buildStatus,
+      lintStatus: variant.lintStatus,
+      testStatus: variant.testStatus
+    },
+    evidence
+  };
+}
+function extractBacklogItemId(state) {
+  const argv = state.runMetadata?.replay?.argv;
+  if (!Array.isArray(argv) || !argv.every((argument) => typeof argument === "string")) {
+    return void 0;
+  }
+  const flagIndex = argv.indexOf("--backlog-item");
+  if (flagIndex >= 0) return argv[flagIndex + 1];
+  return argv.find((argument) => argument.startsWith("--backlog-item="))?.slice("--backlog-item=".length);
+}
+function deriveRunPhase(state, status, variantsTerminal) {
+  if (status === "succeeded" || status === "failed" || status === "cancelled") return "complete";
+  if (status === "unknown") return "unknown";
+  const synthesisStatus = state.runMetadata?.synthesis?.status;
+  if (synthesisStatus && (synthesisStatus !== "pending" || state.runMetadata?.synthesis?.expected === true && variantsTerminal)) {
+    return "synthesis";
+  }
+  if (state.runMetadata?.judge?.status === "requested") {
+    return "judge";
+  }
+  return "execution";
+}
+function terminalFusionStatus(state, hasDeliveryEvidence, variantsTerminal) {
+  if (state.status === "running") return { status: "running", partial: false };
+  if (state.status === "terminated") {
+    return state.completedAt ? { status: "cancelled", partial: false } : { status: "unknown", partial: true };
+  }
+  if (state.status === "failed") {
+    return state.errorMessage || state.completedAt ? { status: "failed", partial: false } : { status: "unknown", partial: true };
+  }
+  if (state.status === "completed") {
+    if (!variantsTerminal) return { status: "unknown", partial: true };
+    const synthesisSucceeded = state.synthesis?.success === true || state.runMetadata?.synthesis?.status === "succeeded";
+    const synthesisFailed = state.synthesis?.success === false || state.runMetadata?.synthesis?.status === "failed";
+    const synthesisCaveated = state.runMetadata?.synthesis?.status === "degraded" || state.runMetadata?.synthesis?.status === "partial";
+    if (synthesisSucceeded && state.completedAt && hasDeliveryEvidence) {
+      return { status: "succeeded", partial: false };
+    }
+    if (synthesisFailed && state.completedAt) return { status: "failed", partial: false };
+    if (synthesisCaveated && state.completedAt && hasDeliveryEvidence) {
+      return { status: "succeeded", partial: true };
+    }
+    return { status: "unknown", partial: true };
+  }
+  return { status: "unknown", partial: true };
+}
+function terminalCompetitionStatus(state, variants, variantsTerminal) {
+  if (state.status === "running") return { status: "running", partial: false };
+  if (state.status === "terminated") {
+    return state.completedAt ? { status: "cancelled", partial: false } : { status: "unknown", partial: true };
+  }
+  if (state.status === "failed") {
+    return state.errorMessage || state.completedAt ? { status: "failed", partial: false } : { status: "unknown", partial: true };
+  }
+  if (state.status === "completed") {
+    if (!state.completedAt || !variantsTerminal) return { status: "unknown", partial: true };
+    return variants.some((variant) => variant.status === "succeeded") ? { status: "succeeded", partial: false } : { status: "failed", partial: false };
+  }
+  return { status: "unknown", partial: true };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function minimumCandidatesForKind(kind) {
+  return kind === "fusion" ? 2 : 1;
+}
+function hasValidRunHandleShape(state, kind) {
+  if (state.primarySource !== "competition_handle" || !isRecord(state.rawHandle)) return false;
+  const handle = state.rawHandle;
+  const recordedId = typeof handle.evaluationId === "string" ? handle.evaluationId : typeof handle.taskId === "string" ? handle.taskId : void 0;
+  if (recordedId !== state.taskId) return false;
+  if (!isValidTimestamp(handle.createdAt) || !isValidTimestamp(handle.updatedAt)) return false;
+  if (!isRecord(handle.runMetadata) || handle.runMetadata.runSemantics !== kind) return false;
+  if (handle.runMetadata.synthesis !== void 0) {
+    if (!isRecord(handle.runMetadata.synthesis)) return false;
+    for (const field of ["status", "artifactPath", "jsonPath"]) {
+      const value = handle.runMetadata.synthesis[field];
+      if (value !== void 0 && typeof value !== "string") return false;
+    }
+  }
+  if (handle.runMetadata.replay !== void 0) {
+    if (!isRecord(handle.runMetadata.replay)) return false;
+    const { argv, taskLabel } = handle.runMetadata.replay;
+    if (argv !== void 0 && (!Array.isArray(argv) || !argv.every((item) => typeof item === "string"))) {
+      return false;
+    }
+    if (taskLabel !== void 0 && typeof taskLabel !== "string") return false;
+  }
+  if (state.status !== "running" && state.status !== "completed" && state.status !== "failed" && state.status !== "terminated") {
+    return false;
+  }
+  if (state.status !== "running" && handle.completedAt !== void 0 && !isValidTimestamp(handle.completedAt)) {
+    return false;
+  }
+  const candidates = Array.isArray(handle.candidates) ? handle.candidates : Array.isArray(handle.variants) ? handle.variants : void 0;
+  if (!candidates || candidates.length < minimumCandidatesForKind(kind)) return false;
+  return candidates.every(
+    (candidate) => isRecord(candidate) && typeof candidate.provider === "string" && candidate.provider.length > 0 && typeof candidate.strategy === "string" && candidate.strategy.length > 0
+  );
+}
+function isFusionReplayArgv(argv) {
+  if (!Array.isArray(argv) || argv[0] !== "poetic") {
+    return false;
+  }
+  if (argv[1] === "fusion") {
+    return true;
+  }
+  return argv[1] === "run" && argv[2] === "fusion";
+}
+function isSelectedFusionLaunch(state) {
+  const replay = state.runMetadata?.replay;
+  const selectedByArgv = isFusionReplayArgv(replay?.argv);
+  const command = replay?.command;
+  const selectedByCommand = command === "fusion" || command?.startsWith("poetic fusion ") === true || command?.startsWith("poetic run fusion ") === true || command === "poetic run fusion";
+  return state.runMetadata?.runSemantics === "fusion" && (selectedByArgv || selectedByCommand);
+}
+function isSelectedCompetitionLaunch(state) {
+  const replay = state.runMetadata?.replay;
+  const argv = replay?.argv;
+  const selectedByArgv = Array.isArray(argv) && argv.length >= 2 && argv[0] === "poetic" && argv[1] === "compete";
+  const command = replay?.command;
+  const selectedByCommand = command === "compete" || command === "poetic compete" || command?.startsWith("poetic compete ") === true;
+  return state.runMetadata?.runSemantics === "competition" && (selectedByArgv || selectedByCommand);
+}
+function evidencePathExists(value, repoRoot) {
+  if (typeof value !== "string" || value.length === 0) return false;
+  const candidate = path2.isAbsolute(value) ? value : path2.resolve(repoRoot, value);
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function composeRunSnapshotV1(state, options, compatibility, kind) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const primaryProof = state.primarySource === "competition_handle" ? state.sources.competitionHandle : state.primarySource === "background_handle" ? state.sources.backgroundHandle : void 0;
+  const lastModifiedAt = primaryProof?.modifiedAt;
+  const lastActivityAt = state.updatedAt ?? state.completedAt ?? lastModifiedAt ?? state.createdAt;
+  const ageMs = lastActivityAt ? now.getTime() - Date.parse(lastActivityAt) : Number.POSITIVE_INFINITY;
+  const stale = state.status === "running" && ageMs > (options.staleAfterMs ?? 5 * 60 * 1e3);
+  const corrupt = Object.values(state.sources).some((source) => Boolean(source.parseError)) || !hasValidRunHandleShape(state, kind);
+  const missing = state.primarySource === "none" && !corrupt;
+  const judgeEvidence = state.runMetadata?.judge;
+  const judgeEvidenceValue = judgeEvidence ? [judgeEvidence.requested, judgeEvidence.status, judgeEvidence.reason].filter((value) => typeof value === "string" && value.length > 0).join(":") : void 0;
+  const synthesisArtifactPath = state.runMetadata?.synthesis?.artifactPath;
+  const synthesisJsonPath = state.runMetadata?.synthesis?.jsonPath;
+  const repoRoot = resolveCliStateRoots(options.cwd).repoRoot;
+  const runEvidence = [
+    ...evidenceReference("judge", state.decision?.primaryJudge ?? judgeEvidenceValue),
+    ...evidenceReference("synthesis", synthesisArtifactPath),
+    ...evidenceReference("synthesis", synthesisJsonPath),
+    ...evidencePathExists(synthesisArtifactPath, repoRoot) ? evidenceReference("delivery", synthesisArtifactPath) : [],
+    ...evidencePathExists(synthesisJsonPath, repoRoot) ? evidenceReference("delivery", synthesisJsonPath) : [],
+    ...evidenceReference("verification", state.winnerVerification?.original?.summary),
+    ...evidenceReference("delivery", state.application?.taskId ?? state.application?.variantId),
+    ...evidenceReference("branch", state.application?.sourceBranch),
+    ...evidenceReference("branch", state.application?.targetBranch),
+    ...evidenceReference("commit", state.application?.sourceHeadSha),
+    ...evidenceReference("commit", state.application?.targetPostApplyHeadSha),
+    ...Array.isArray(state.application?.changedFiles) ? state.application.changedFiles.filter((value) => typeof value === "string").map((value) => ({ kind: "changed_file", value })) : []
+  ];
+  const variants = state.variants.map(variantSnapshot);
+  runEvidence.push(...variants.flatMap((variant) => variant.evidence));
+  const hasDeliveryEvidence = evidencePathExists(synthesisArtifactPath, repoRoot) || evidencePathExists(synthesisJsonPath, repoRoot) || state.application?.status === "applied" && evidenceReference(
+    "delivery",
+    state.application.targetPostApplyHeadSha ?? state.application.targetBranch
+  ).length > 0;
+  const variantsTerminal = variants.length >= minimumCandidatesForKind(kind) && variants.every((variant) => variant.status === "succeeded" || variant.status === "failed");
+  const terminal = kind === "competition" ? terminalCompetitionStatus(state, variants, variantsTerminal) : terminalFusionStatus(state, hasDeliveryEvidence, variantsTerminal);
+  const status = corrupt || missing || stale ? "unknown" : terminal.status;
+  const issues = [
+    ...compatibility.state === "compatible_minor_difference" ? ["compatibility"] : [],
+    ...corrupt ? ["corrupt"] : [],
+    ...missing ? ["missing"] : [],
+    ...terminal.partial ? ["partial"] : [],
+    ...stale ? ["stale"] : []
+  ];
+  return {
+    schemaVersion: RUN_SNAPSHOT_SCHEMA_VERSION_V1,
+    compatibility,
+    id: state.taskId,
+    kind,
+    status,
+    phase: deriveRunPhase(
+      state,
+      corrupt || missing ? "unknown" : terminal.status,
+      variantsTerminal
+    ),
+    timestamps: {
+      createdAt: state.createdAt,
+      updatedAt: state.updatedAt,
+      completedAt: state.completedAt,
+      lastActivityAt
+    },
+    source: {
+      backlogItemId: extractBacklogItemId(state),
+      task: optionalString(state.runMetadata?.replay?.taskLabel) ?? optionalString(state.prompt),
+      repository: state.background?.launcherCwd ?? repoRoot,
+      branch: state.application?.targetBranch ?? state.background?.branch
+    },
+    progress: {
+      completedVariants: variants.filter(
+        (variant) => variant.status === "succeeded" || variant.status === "failed"
+      ).length,
+      totalVariants: variants.length
+    },
+    health: {
+      state: state.primarySource === "none" ? "unavailable" : issues.length > 0 ? "degraded" : "healthy",
+      issues
+    },
+    provenance: { primarySource: state.primarySource, sources: state.sources },
+    freshness: {
+      state: stale ? "stale" : corrupt ? "unknown" : status === "succeeded" || status === "failed" || status === "cancelled" ? "historical" : lastActivityAt ? "fresh" : "unknown",
+      checkedAt,
+      lastModifiedAt
+    },
+    variants,
+    evidence: runEvidence
+  };
+}
+function getRunSnapshotV1(runId, options = {}) {
+  const compatibility = resolveRunSnapshotCompatibility(options.requestedSchemaVersion);
+  const state = readCompetitionState(runId, options);
+  if (state.primarySource === "none") return null;
+  if (!isSelectedFusionLaunch(state)) return null;
+  return composeRunSnapshotV1(state, options, compatibility, "fusion");
+}
+function getCompetitionRunSnapshotV1(runId, options = {}) {
+  const compatibility = resolveRunSnapshotCompatibility(options.requestedSchemaVersion);
+  const state = readCompetitionState(runId, options);
+  if (state.primarySource === "none") return null;
+  if (!isSelectedCompetitionLaunch(state)) return null;
+  return composeRunSnapshotV1(state, options, compatibility, "competition");
+}
+
+export {
+  resolveCliStateRoots,
+  normaliseInputSpecWarning,
+  readCompetitionState,
+  getMostRecentCompetitionId,
+  readCompetitionEvents,
+  resolveDisplayId,
+  RUN_SNAPSHOT_SCHEMA_VERSION_V1,
+  getRunSnapshotV1,
+  getCompetitionRunSnapshotV1
+};
+//# sourceMappingURL=chunk-BLPHWMDK.js.map