@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-NTD6CSI6.js

@@ -0,0 +1,1266 @@
+import {
+  resolveInitiatedBy
+} from "./chunk-PNFTPNSR.js";
+import {
+  COMPLETENESS_VALIDATION_THRESHOLD,
+  parseCompetitionDeliveryRecord
+} from "./chunk-DCACX7BV.js";
+import {
+  normalizeProviderCliVersion
+} from "./chunk-S47ISY27.js";
+import {
+  canonicalizeVariantIdentifier,
+  formatVariantIdentifier,
+  formatVariantIdentifierFromResult,
+  parseVariantIdentifier
+} from "./chunk-TGXXYDL4.js";
+import {
+  atomicWriteTextSync
+} from "./chunk-RFDVSI4N.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  deriveVariantOutcome,
+  failedGatesAlsoFailingOnBase,
+  hasMeaningfulCompetitionProgress,
+  repairOutcomeCanSupersedeRawTouchedFailure
+} from "./chunk-3OPP2OZB.js";
+import {
+  assertSafePathComponent
+} from "./chunk-S2VQCZO4.js";
+import {
+  LabPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  resolveCheckoutRoot
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  redactPersistedTestsExecuted
+} from "./chunk-WV3KQDPE.js";
+import {
+  sanitizeSynthesisArtifactForPersistence,
+  sanitizeSynthesisStringForPersistence
+} from "./chunk-VSWC5ZXI.js";
+import {
+  lockOwnerIsAlive,
+  processIsAlive,
+  readProcessIdentity
+} from "./chunk-MT2WAIR3.js";
+import {
+  resolveBuildRoot
+} from "./chunk-CHA2HDE5.js";
+import {
+  getExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/synthesis/synthesis-result-status.ts
+function hasDeliveredWinnerMaterial(fields) {
+  if (typeof fields.code === "string" && fields.code.trim().length > 0) return true;
+  const merged = Array.isArray(fields.mergedVariants) ? fields.mergedVariants : [];
+  return merged.length > 0;
+}
+function uniqueVariantCount(fields) {
+  const ids = [
+    ...Array.isArray(fields.contributingVariants) ? fields.contributingVariants : [],
+    ...Array.isArray(fields.mergedVariants) ? fields.mergedVariants : []
+  ].filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim());
+  return new Set(ids).size;
+}
+function isSynthesisResultDelivered(fields) {
+  if (fields.deliverySucceeded === true) return true;
+  if (fields.winnerFallback === true) return true;
+  if (fields.winnerClone === true) return true;
+  if (fields.synthesisOutcomeStatus === "winner_carry_forward") return true;
+  if (fields.synthesisApplied === true) return true;
+  if (fields.success === true && hasDeliveredWinnerMaterial(fields)) return true;
+  return false;
+}
+function resolveSynthesisResultStatus(fields) {
+  if (!isSynthesisResultDelivered(fields)) return null;
+  if (fields.synthesisApplied === true && uniqueVariantCount(fields) > 1) {
+    return "synthesized";
+  }
+  return "winner_retained";
+}
+function resolveSynthesisDeliveryProjection(fields) {
+  const delivered = isSynthesisResultDelivered(fields);
+  return {
+    success: delivered,
+    resultStatus: resolveSynthesisResultStatus(fields)
+  };
+}
+function markSynthesisResultRejected(result, message) {
+  return {
+    ...result,
+    success: false,
+    resultStatus: void 0,
+    error: message,
+    reasoning: result.reasoning ? `${result.reasoning}
+${message}` : message,
+    deliverySucceeded: false,
+    synthesisApplied: false,
+    winnerFallback: false,
+    winnerClone: false,
+    fallbackReason: void 0,
+    patchApplyValidated: false,
+    gatesPassed: false,
+    synthesisOutcomeStatus: "generation_failed"
+  };
+}
+function withSynthesisDeliveryFields(result) {
+  const projection = resolveSynthesisDeliveryProjection(result);
+  return {
+    ...result,
+    success: projection.success,
+    resultStatus: projection.resultStatus ?? void 0
+  };
+}
+
+// src/orchestrator/basic/undelivered-worker-message.ts
+var MAX_UNDELIVERED_MESSAGE_CHARS = 400;
+function undeliveredWorkerMessage(facts) {
+  if (facts.success || facts.exitCode !== 0 || facts.filesChanged > 0) return void 0;
+  const message = (facts.stdout ?? "").slice(-MAX_UNDELIVERED_MESSAGE_CHARS * 4).replace(/\s+/g, " ").trim();
+  if (message.length === 0) return void 0;
+  return message.length > MAX_UNDELIVERED_MESSAGE_CHARS ? `...${message.slice(-MAX_UNDELIVERED_MESSAGE_CHARS).trimStart()}` : message;
+}
+function undeliveredMessageFromResult(result) {
+  return undeliveredWorkerMessage({
+    success: result.success,
+    exitCode: result.result?.exitCode,
+    filesChanged: result.filesChanged ?? result.worktreeSummary?.filesChanged ?? 0,
+    stdout: result.result?.stdout
+  });
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function undeliveredMessageFromRecord(record) {
+  const engine = asRecord(record?.engineResult);
+  const evidence = asRecord(record?.evidence);
+  const changedFiles = Array.isArray(evidence?.changedFiles) ? evidence.changedFiles.length : 0;
+  return undeliveredWorkerMessage({
+    success: evidence?.success !== false,
+    exitCode: typeof engine?.exitCode === "number" ? engine.exitCode : void 0,
+    filesChanged: changedFiles,
+    stdout: typeof engine?.stdout === "string" ? engine.stdout : void 0
+  });
+}
+function formatUndeliveredWorkerLine(message) {
+  return `Worker said: ${message}`;
+}
+function undeliveredLineFromRecord(record) {
+  const message = undeliveredMessageFromRecord(record);
+  return message ? formatUndeliveredWorkerLine(message) : void 0;
+}
+function undeliveredLineFromTelemetry(reader, taskId, variants) {
+  try {
+    for (const variant of new Set(variants)) {
+      if (!variant) continue;
+      const record = reader.getVariantResultRecord(taskId, variant);
+      if (record) return undeliveredLineFromRecord(record);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function undeliveredLineLookup(reader, taskId) {
+  return (variant) => undeliveredLineFromTelemetry(reader, taskId, [variant]);
+}
+
+// src/orchestrator/competition-handle.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var TERMINAL_EVALUATION_STATUSES = /* @__PURE__ */ new Set(["completed", "failed"]);
+var _seqCounters = /* @__PURE__ */ new Map();
+function readExistingMaxSeq(eventsPath) {
+  try {
+    if (!fs.existsSync(eventsPath)) return -1;
+    const raw = fs.readFileSync(eventsPath, "utf8");
+    let max = -1;
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed.seq === "number" && Number.isFinite(parsed.seq)) {
+          max = Math.max(max, Math.floor(parsed.seq));
+        }
+      } catch {
+      }
+    }
+    return max;
+  } catch {
+    return -1;
+  }
+}
+function nextSeq(taskId, eventsPath) {
+  let prev = _seqCounters.get(taskId);
+  if (prev === void 0) {
+    prev = readExistingMaxSeq(eventsPath);
+  }
+  const next = prev + 1;
+  _seqCounters.set(taskId, next);
+  return next;
+}
+function sanitizeDiagnosticValue(value, depth = 0) {
+  if (depth > 4) return "[truncated]";
+  if (value == null) return value;
+  if (typeof value === "string") return sanitizeSynthesisStringForPersistence(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map((entry) => sanitizeDiagnosticValue(entry, depth + 1));
+  }
+  if (value instanceof Error) {
+    const details = {
+      name: sanitizeSynthesisStringForPersistence(value.name),
+      message: sanitizeSynthesisStringForPersistence(value.message)
+    };
+    if (typeof value.stack === "string") {
+      details.stack = sanitizeSynthesisStringForPersistence(value.stack);
+    }
+    return details;
+  }
+  if (typeof value === "object") {
+    const details = {};
+    for (const [key, entry] of Object.entries(value).slice(0, 100)) {
+      const keyAwareValue = sanitizeSynthesisArtifactForPersistence({ [key]: entry });
+      details[key] = keyAwareValue[key] ?? sanitizeDiagnosticValue(entry, depth + 1);
+    }
+    return details;
+  }
+  return sanitizeSynthesisStringForPersistence(String(value));
+}
+function sanitizeHandlePrompt(prompt) {
+  return sanitizeSynthesisStringForPersistence(prompt ?? "");
+}
+function sanitizeHandleErrorMessage(message) {
+  return typeof message === "string" ? sanitizeSynthesisStringForPersistence(message) : void 0;
+}
+var COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_SCORER_ID = "competition-handle-persistence-composite";
+var COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_SCORER_VERSION = "1.0.0";
+var COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD = {
+  authority: "core.validation.completeness.competition-handle-persistence-composite",
+  owner: COMPLETENESS_VALIDATION_THRESHOLD.owner,
+  minimumAcceptableScore: COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+};
+var PERSISTENCE_FAIL_CLOSED_EVIDENCE_PROVENANCE = "persistence-fail-closed";
+function failClosedUnderPersistenceComposite(base) {
+  return {
+    score: 0,
+    scorerId: COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_SCORER_ID,
+    scorerVersion: COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_SCORER_VERSION,
+    evidenceProvenance: PERSISTENCE_FAIL_CLOSED_EVIDENCE_PROVENANCE,
+    ok: false,
+    breakdown: base.breakdown,
+    threshold: {
+      authority: COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.authority,
+      value: COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_VALIDATION_THRESHOLD.minimumAcceptableScore
+    },
+    components: [base]
+  };
+}
+function normalizePersistedCompletenessPair(completeness, completenessAssessment) {
+  if (completenessAssessment == null) {
+    return { completeness, completenessAssessment: void 0 };
+  }
+  const rawScore = completenessAssessment.score;
+  const scoreInRange = typeof rawScore === "number" && Number.isFinite(rawScore) && rawScore >= 0 && rawScore <= 100;
+  if (!scoreInRange || completenessAssessment.ok === false) {
+    if (completenessAssessment.scorerId === COMPETITION_HANDLE_PERSISTENCE_COMPOSITE_COMPLETENESS_SCORER_ID && completenessAssessment.score === 0 && completenessAssessment.ok === false) {
+      return {
+        completeness: 0,
+        completenessAssessment
+      };
+    }
+    const normalized = failClosedUnderPersistenceComposite(completenessAssessment);
+    return {
+      completeness: normalized.score,
+      completenessAssessment: normalized
+    };
+  }
+  return {
+    completeness: rawScore,
+    completenessAssessment
+  };
+}
+function extractErrorDetails(error) {
+  if (!error || typeof error !== "object" && !(error instanceof Error)) return void 0;
+  return sanitizeDiagnosticValue(error);
+}
+function getEventsPath(taskId) {
+  const safeTaskId = assertSafePathComponent(taskId, "evaluationId");
+  return path.join(getBaseDir(), `${safeTaskId}.events.jsonl`);
+}
+function sanitizeCompetitionEventData(data) {
+  const sanitized = sanitizeDiagnosticValue(data);
+  if (data.completenessAssessment != null && typeof data.completenessAssessment === "object") {
+    const pair = normalizePersistedCompletenessPair(
+      typeof data.completeness === "number" ? data.completeness : void 0,
+      data.completenessAssessment
+    );
+    sanitized.completeness = typeof pair.completeness === "number" && Number.isFinite(pair.completeness) ? pair.completeness : 0;
+    if (pair.completenessAssessment != null) {
+      sanitized.completenessAssessment = sanitizeDiagnosticValue(pair.completenessAssessment);
+    }
+    return sanitized;
+  }
+  if (typeof data.completeness === "number" && Number.isFinite(data.completeness)) {
+    sanitized.completeness = data.completeness;
+  }
+  return sanitized;
+}
+function appendCompetitionEvent(taskId, event, data = {}) {
+  try {
+    const eventsPath = getEventsPath(taskId);
+    fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
+    const record = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      seq: nextSeq(taskId, eventsPath),
+      taskId,
+      event,
+      data: sanitizeCompetitionEventData(data)
+    };
+    fs.appendFileSync(eventsPath, `${JSON.stringify(record)}
+`, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.debug(`[CompetitionHandle] event append failed for ${taskId}: ${msg}`);
+  }
+}
+function getBuildDir() {
+  return getExecutionContext().buildDir ?? path.join(resolveBuildRoot(process.cwd()), ".build-project");
+}
+function getBaseDir() {
+  const buildDir = getBuildDir();
+  const stateDir = LabPathResolver.getInstance().getStateDir(buildDir);
+  return path.join(stateDir, "competitions");
+}
+function getHandlePath(taskId) {
+  const safeTaskId = assertSafePathComponent(taskId, "evaluationId");
+  return path.join(getBaseDir(), `${safeTaskId}.json`);
+}
+var LOCK_RETRY_DELAY_MS = 25;
+var LOCK_IDENTITY_CHECK_AFTER_MS = 1e3;
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function parseLockOwner(raw) {
+  const text = raw.trim();
+  if (!text) return void 0;
+  if (/^\d+$/.test(text)) {
+    return { pid: Number.parseInt(text, 10) };
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return {
+      pid: typeof parsed.pid === "number" && Number.isFinite(parsed.pid) ? parsed.pid : void 0,
+      token: typeof parsed.token === "string" ? parsed.token : void 0,
+      identity: typeof parsed.identity === "string" ? parsed.identity : void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function reclaimStaleLock(lockPath, expectedRaw) {
+  const reclaimPath = `${lockPath}.reclaim.${process.pid}.${randomUUID()}`;
+  try {
+    fs.renameSync(lockPath, reclaimPath);
+  } catch {
+    return;
+  }
+  try {
+    if (fs.readFileSync(reclaimPath, "utf8") !== expectedRaw) {
+      try {
+        fs.linkSync(reclaimPath, lockPath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    fs.unlinkSync(reclaimPath);
+  } catch {
+  }
+}
+function tryAcquireLockOnce(lockPath, payload, staleMs, deadline) {
+  try {
+    fs.writeFileSync(lockPath, payload, { flag: "wx" });
+    return "acquired";
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    try {
+      const stat = fs.statSync(lockPath);
+      const raw = fs.readFileSync(lockPath, "utf8");
+      const owner = parseLockOwner(raw);
+      const ownerAlive = owner?.pid ? Date.now() - stat.mtimeMs < LOCK_IDENTITY_CHECK_AFTER_MS ? processIsAlive(owner.pid) : lockOwnerIsAlive(owner.pid, owner.identity) : true;
+      const staleWithoutKnownOwner = !owner?.pid && Date.now() - stat.mtimeMs > staleMs;
+      if (!ownerAlive || staleWithoutKnownOwner) {
+        reclaimStaleLock(lockPath, raw);
+        return "retry";
+      }
+    } catch {
+    }
+    if (Date.now() >= deadline) {
+      return "timeout";
+    }
+    return "wait";
+  }
+}
+function buildLockToken() {
+  const token = `${process.pid}:${randomUUID()}`;
+  const identity = readProcessIdentity(process.pid);
+  return { token, payload: JSON.stringify({ pid: process.pid, token, identity }) };
+}
+async function acquireLock(lockPath, staleMs = 3e4, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  const { token, payload } = buildLockToken();
+  while (true) {
+    const attempt = tryAcquireLockOnce(lockPath, payload, staleMs, deadline);
+    if (attempt === "acquired") return token;
+    if (attempt === "timeout") return void 0;
+    if (attempt === "wait") {
+      await sleep(LOCK_RETRY_DELAY_MS);
+    }
+  }
+}
+function acquireLockSync(lockPath, staleMs = 3e4, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  const { token, payload } = buildLockToken();
+  while (true) {
+    const attempt = tryAcquireLockOnce(lockPath, payload, staleMs, deadline);
+    if (attempt === "acquired") return token;
+    if (attempt === "timeout") return void 0;
+    if (attempt === "wait") {
+      sleepSync(LOCK_RETRY_DELAY_MS);
+    }
+  }
+}
+function releaseLock(lockPath, token) {
+  try {
+    const owner = parseLockOwner(fs.readFileSync(lockPath, "utf8"));
+    if (owner?.token !== token) {
+      return;
+    }
+    fs.unlinkSync(lockPath);
+  } catch {
+  }
+}
+async function initEvaluationHandleAsync(evaluationId, prompt, candidates, deliverableContract, runMetadata) {
+  const p = getHandlePath(evaluationId);
+  const lockPath = `${p}.lock`;
+  const lockToken = await acquireLock(lockPath);
+  if (!lockToken) {
+    throw new Error(`Timed out waiting for init lock on ${evaluationId}`);
+  }
+  try {
+    initEvaluationHandleLocked(
+      evaluationId,
+      prompt,
+      candidates,
+      deliverableContract,
+      runMetadata,
+      p
+    );
+  } finally {
+    releaseLock(lockPath, lockToken);
+  }
+}
+function initEvaluationHandleLocked(evaluationId, prompt, candidates, deliverableContract, runMetadata, handlePath) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const safePrompt = sanitizeHandlePrompt(prompt);
+  const labContext = LabPathResolver.getInstance().getContext();
+  const initialCandidates = candidates.map((c) => ({
+    provider: c.provider,
+    requestedProvider: c.requestedProvider,
+    executionMode: c.executionMode,
+    model: c.model,
+    requestedModel: c.requestedModel,
+    failoverFromProvider: c.failoverFromProvider,
+    failoverReason: c.failoverReason,
+    workspaceMode: c.workspaceMode,
+    ...c.workspaceModeRequested !== void 0 ? { workspaceModeRequested: c.workspaceModeRequested } : {},
+    variant: formatVariantIdentifier(c),
+    reasoningEffort: c.modelReasoningEffort,
+    cursorPromptProfile: c.cursorPromptProfile,
+    variantInstanceId: c.variantInstanceId
+  }));
+  const handle = {
+    taskId: evaluationId,
+    evaluationId,
+    prompt: safePrompt,
+    initiatedBy: resolveInitiatedBy(),
+    createdAt: now,
+    updatedAt: now,
+    status: "running",
+    checkoutRoot: resolveCheckoutRoot(getBuildDir()),
+    ...labContext ? { labId: labContext.labId, labRunId: labContext.runId } : {},
+    // Initialize candidate entries without results (populated during execution)
+    candidates: initialCandidates,
+    variants: initialCandidates,
+    // Store contract for downstream access (judges, gates, telemetry)
+    deliverableContract,
+    ...runMetadata ? { runMetadata } : {}
+  };
+  atomicWriteTextSync(handlePath, JSON.stringify(handle, null, 2));
+  appendCompetitionEvent(evaluationId, "competition.started", {
+    prompt: safePrompt,
+    candidateCount: initialCandidates.length,
+    candidates: initialCandidates.map((c) => ({
+      provider: c.provider,
+      executionMode: c.executionMode,
+      variant: c.variant
+    }))
+  });
+}
+function warnHandleFailure(action, evaluationId, error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  console.warn(`[CompetitionHandle] Failed to ${action} for ${evaluationId}: ${msg}`);
+}
+function updateEvaluationHandleWithResult(evaluationId, result) {
+  try {
+    const p = getHandlePath(evaluationId);
+    const lockPath = `${p}.lock`;
+    const lockToken = acquireLockSync(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for update lock on ${evaluationId}`);
+    }
+    try {
+      updateEvaluationHandleWithResultLocked(evaluationId, result, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("update handle", evaluationId, error);
+  }
+}
+async function updateEvaluationHandleWithResultAsync(evaluationId, result) {
+  try {
+    const p = getHandlePath(evaluationId);
+    const lockPath = `${p}.lock`;
+    const lockToken = await acquireLock(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for update lock on ${evaluationId}`);
+    }
+    try {
+      updateEvaluationHandleWithResultLocked(evaluationId, result, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("update handle", evaluationId, error);
+  }
+}
+function updateEvaluationHandleWithResultLocked(evaluationId, result, p) {
+  const raw = fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let handle;
+  if (raw) {
+    const parsed = parseJsonWithContext(raw, `Competition handle (${evaluationId})`);
+    if (parsed.status === "completed" || parsed.status === "failed") {
+      return;
+    }
+    handle = {
+      taskId: parsed.evaluationId || parsed.taskId || evaluationId,
+      evaluationId: parsed.evaluationId || parsed.taskId || evaluationId,
+      prompt: sanitizeHandlePrompt(parsed.prompt),
+      initiatedBy: parsed.initiatedBy,
+      checkoutRoot: parsed.checkoutRoot,
+      createdAt: parsed.createdAt || now,
+      updatedAt: parsed.updatedAt || now,
+      status: parsed.status,
+      outcome: parsed.outcome,
+      completedAt: parsed.completedAt,
+      errorMessage: parsed.errorMessage,
+      winner: parsed.winner,
+      candidates: parsed.candidates || parsed.variants || [],
+      variants: parsed.variants || parsed.candidates || [],
+      labId: parsed.labId,
+      labRunId: parsed.labRunId,
+      runMetadata: parsed.runMetadata,
+      deliverableContract: parsed.deliverableContract,
+      synthesis: parsed.synthesis,
+      application: parsed.application,
+      delivery: parseCompetitionDeliveryRecord(parsed.delivery),
+      verification: parsed.verification ?? parsed.winnerVerification
+    };
+  } else {
+    handle = {
+      taskId: evaluationId,
+      evaluationId,
+      createdAt: now,
+      updatedAt: now,
+      candidates: [],
+      variants: []
+    };
+  }
+  const resultWorkspaceMode = result.workspaceMode;
+  const resultWorkspaceModeRequestedRaw = result.workspaceModeRequested;
+  const resultWorkspaceModeIdentity = resultWorkspaceModeRequestedRaw ?? resultWorkspaceMode;
+  const parsedResultVariant = parseVariantIdentifier(String(result.variant ?? ""));
+  const resultReasoningEffort = parsedResultVariant.reasoningEffort ?? result.reasoningEffort;
+  const resultCursorPromptProfile = parsedResultVariant.cursorPromptProfile ?? result.cursorPromptProfile;
+  const resultTransport = parsedResultVariant.transport;
+  const resultVariantInstanceId = result.variantInstanceId;
+  const strictIdx = handle.candidates.findIndex(
+    (c) => c.provider === result.provider && c.executionMode === result.executionMode && strictIdentityFieldMatches(c.model, result.model) && strictIdentityFieldMatches(
+      c.workspaceModeRequested ?? c.workspaceMode,
+      resultWorkspaceModeIdentity
+    ) && strictIdentityFieldMatches(c.reasoningEffort, resultReasoningEffort) && strictIdentityFieldMatches(c.cursorPromptProfile, resultCursorPromptProfile) && strictIdentityFieldMatches(
+      parseVariantIdentifier(String(c.variant ?? "")).transport,
+      resultTransport
+    ) && strictIdentityFieldMatches(c.variantInstanceId, resultVariantInstanceId)
+  );
+  const idx = strictIdx >= 0 ? strictIdx : handle.candidates.findIndex(
+    (c) => c.provider === result.provider && c.executionMode === result.executionMode && strictIdentityFieldMatches(c.model, result.model) && lateBoundIdentityFieldMatches(
+      c.workspaceModeRequested ?? c.workspaceMode,
+      resultWorkspaceModeIdentity
+    ) && lateBoundIdentityFieldMatches(c.reasoningEffort, resultReasoningEffort) && lateBoundIdentityFieldMatches(c.cursorPromptProfile, resultCursorPromptProfile) && strictIdentityFieldMatches(
+      parseVariantIdentifier(String(c.variant ?? "")).transport,
+      resultTransport
+    ) && strictIdentityFieldMatches(c.variantInstanceId, resultVariantInstanceId)
+  );
+  const existingCandidate = idx >= 0 ? handle.candidates[idx] : void 0;
+  const resultWorkspaceModeRequested = resultWorkspaceModeRequestedRaw ?? existingCandidate?.workspaceModeRequested;
+  const resultPromptFingerprint = result.promptFingerprint ?? existingCandidate?.promptFingerprint;
+  const resultFinalPromptLength = result.finalPromptLength ?? existingCandidate?.finalPromptLength;
+  const resultVariant = typeof result.variant === "string" && result.variant.length > 0 ? formatVariantIdentifierFromResult(result) : existingCandidate?.variant;
+  const resultForOutcomeDerivation = result.isSynthesis === true ? { ...result, variant: resultVariant ?? result.variant } : (() => {
+    const { outcome: _staleOutcome, ...withoutOutcome } = result;
+    return { ...withoutOutcome, variant: resultVariant ?? result.variant };
+  })();
+  const derivedOutcome = result.isSynthesis === true && result.outcome ? result.outcome : deriveVariantOutcome(resultForOutcomeDerivation);
+  const { verification: outcomeVerification, delivery: outcomeDelivery } = derivedOutcome;
+  const resultHasChanges = result.hasChanges ?? outcomeDelivery.hasChanges ?? (typeof result.filesChanged === "number" ? result.filesChanged > 0 : void 0);
+  const { completeness: persistedCompleteness, completenessAssessment: persistedAssessment } = normalizePersistedCompletenessPair(result.completeness, result.completenessAssessment);
+  const patch = {
+    provider: result.provider,
+    requestedProvider: result.requestedProvider ?? existingCandidate?.requestedProvider,
+    executionMode: result.executionMode,
+    model: result.model,
+    requestedModel: result.requestedModel ?? existingCandidate?.requestedModel,
+    failoverFromProvider: result.failoverFromProvider ?? existingCandidate?.failoverFromProvider,
+    failoverReason: result.failoverReason ?? existingCandidate?.failoverReason,
+    workspaceMode: resultWorkspaceMode,
+    ...resultWorkspaceModeRequested !== void 0 ? { workspaceModeRequested: resultWorkspaceModeRequested } : {},
+    ...resultVariant !== void 0 ? { variant: resultVariant } : {},
+    ...resultPromptFingerprint !== void 0 ? { promptFingerprint: resultPromptFingerprint } : {},
+    ...resultFinalPromptLength !== void 0 ? { finalPromptLength: resultFinalPromptLength } : {},
+    reasoningEffort: resultReasoningEffort ?? existingCandidate?.reasoningEffort,
+    cursorPromptProfile: resultCursorPromptProfile ?? existingCandidate?.cursorPromptProfile,
+    variantInstanceId: resultVariantInstanceId ?? existingCandidate?.variantInstanceId,
+    resolvedModel: result.resolvedModel,
+    modelResolutionSource: result.modelResolutionSource,
+    providerCliVersion: normalizeProviderCliVersion(result.providerCliVersion),
+    submittedOnly: result.submittedOnly === true,
+    prNumber: result.prNumber,
+    prUrl: result.prUrl,
+    cloudTaskId: result.cloudTaskId,
+    success: result.success,
+    outcome: derivedOutcome,
+    retainedWorktreePath: result.retainedWorktreePath,
+    artifactPath: result.artifactPath,
+    completeness: persistedCompleteness,
+    completenessAssessment: persistedAssessment,
+    duration: result.duration,
+    errorMessage: sanitizeHandleErrorMessage(result.error?.message),
+    errorDetails: extractErrorDetails(result.error),
+    providerDiagnostics: result.providerDiagnostics ? sanitizeDiagnosticValue(
+      result.providerDiagnostics
+    ) : void 0,
+    authError: result.authError ? sanitizeDiagnosticValue(result.authError) : void 0,
+    timedOut: result.timedOut === true,
+    terminationReason: result.terminationReason,
+    inputSpecWarning: result.inputSpecWarning,
+    cursorMetadata: result.cursorMetadata,
+    contextInjection: result.contextInjection,
+    testsExecuted: redactPersistedTestsExecuted(result.testsExecuted),
+    buildStatus: result.buildStatus ?? outcomeVerification.buildStatus,
+    lintStatus: result.lintStatus ?? outcomeVerification.lintStatus,
+    // Candidate testStatus/filesChanged stay direct copies for legacy state readers.
+    testStatus: result.testStatus,
+    testMetrics: result.testMetrics,
+    judgeScore: result.judgeScore,
+    judgeEvaluation: result.judgeEvaluation,
+    artifactManifest: result.artifactManifest,
+    acceptedWorkspaceTreeSha: result.acceptedWorkspaceTreeSha,
+    gitMetrics: result.gitMetrics,
+    worktreeSummary: result.worktreeSummary,
+    ignoredPathEvidence: result.ignoredPathEvidence,
+    filesChanged: result.filesChanged,
+    hasChanges: resultHasChanges,
+    linesAdded: result.linesAdded,
+    linesRemoved: result.linesRemoved
+  };
+  patch.alsoFailingOnBase = failedGatesAlsoFailingOnBase(result.baselineComparison, patch);
+  if (idx >= 0) {
+    handle.candidates[idx] = { ...handle.candidates[idx], ...patch };
+  } else {
+    handle.candidates.push(patch);
+  }
+  handle.variants = handle.candidates;
+  handle.updatedAt = now;
+  atomicWriteTextSync(p, JSON.stringify(handle, null, 2));
+  const variantEventKind = result.success === true ? "variant.completed" : result.success === false || result.error ? "variant.failed" : "variant.completed";
+  appendCompetitionEvent(evaluationId, variantEventKind, {
+    provider: result.provider,
+    executionMode: result.executionMode,
+    model: result.model,
+    variant: resultVariant,
+    success: result.success,
+    completeness: persistedCompleteness,
+    completenessAssessment: persistedAssessment,
+    duration: result.duration,
+    timedOut: result.timedOut,
+    errorMessage: sanitizeHandleErrorMessage(result.error?.message),
+    errorDetails: extractErrorDetails(result.error),
+    providerDiagnostics: patch.providerDiagnostics,
+    authError: result.authError ? sanitizeDiagnosticValue(result.authError) : void 0,
+    terminationReason: result.terminationReason
+  });
+}
+function strictIdentityFieldMatches(existing, incoming) {
+  return existing === incoming || existing === void 0 && incoming === void 0;
+}
+function lateBoundIdentityFieldMatches(existing, incoming) {
+  return existing === incoming || existing === void 0 || incoming === void 0;
+}
+function candidatesDescribeSameVariant(candidate, other) {
+  return candidate.provider === other.provider && candidate.executionMode === other.executionMode && strictIdentityFieldMatches(candidate.model, other.model) && lateBoundIdentityFieldMatches(candidate.workspaceMode, other.workspaceMode) && lateBoundIdentityFieldMatches(candidate.reasoningEffort, other.reasoningEffort) && lateBoundIdentityFieldMatches(candidate.cursorPromptProfile, other.cursorPromptProfile) && strictIdentityFieldMatches(candidate.variantInstanceId, other.variantInstanceId);
+}
+function candidateHasCompletedPeer(candidate, candidates) {
+  return candidates.some(
+    (other) => other !== candidate && other.success !== void 0 && candidatesDescribeSameVariant(candidate, other)
+  );
+}
+function canonicalizeHandleWinner(winner) {
+  if (winner == null) return winner;
+  const variantSeed = typeof winner.variant === "string" ? winner.variant.trim() : "";
+  if (!variantSeed) {
+    return winner;
+  }
+  return {
+    ...winner,
+    variant: canonicalizeVariantIdentifier({
+      variant: variantSeed,
+      provider: winner.provider,
+      model: winner.model,
+      resolvedModel: winner.resolvedModel,
+      executionMode: winner.executionMode
+    })
+  };
+}
+function toEvaluationHandleWinnerMetadata(winner) {
+  if (winner === void 0) return void 0;
+  if (!winner) return null;
+  const winnerForOutcomeDerivation = winner.isSynthesis === true ? winner : (() => {
+    const { outcome: _staleOutcome, ...withoutOutcome } = winner;
+    return withoutOutcome;
+  })();
+  const outcome = winner.isSynthesis === true && winner.outcome ? winner.outcome : deriveVariantOutcome(winnerForOutcomeDerivation);
+  return {
+    provider: winner.provider,
+    model: winner.model,
+    resolvedModel: winner.resolvedModel,
+    modelResolutionSource: winner.modelResolutionSource,
+    executionMode: winner.executionMode,
+    variant: winner.variant,
+    variantInstanceId: winner.variantInstanceId,
+    winnerSelectionSource: winner.winnerSelectionSource,
+    winnerSelectionReason: winner.winnerSelectionReason,
+    buildStatus: winner.buildStatus ?? outcome.verification.buildStatus,
+    lintStatus: winner.lintStatus ?? outcome.verification.lintStatus,
+    // Explicit unsuccessful testStatus ('failed'/'error'/'timeout'/any
+    // non-neutral spelling — the field permits arbitrary strings the
+    // derivation logic cannot represent) is authoritative, EXCEPT when a
+    // trusted passing repair superseded it: the repair path intentionally
+    // preserves the original provider testStatus while deriveVariantOutcome
+    // recognizes the passing repair, so letting the stale explicit failure
+    // win there would persist a false failure on the handle. Synthesis
+    // winners have no repair path, so their explicit status always wins over
+    // the provider-supplied nested outcome (the failure-masking fix);
+    // the later tightening (derived beats a stale top-level 'passed')
+    // is preserved because only unsuccessful explicit statuses take
+    // precedence.
+    testStatus: (() => {
+      const explicitUnsuccessful = winner.testStatus !== void 0 && winner.testStatus !== "passed" && winner.testStatus !== "not_run" && winner.testStatus !== "skipped";
+      const supersededByPassingRepair = winner.isSynthesis !== true && repairOutcomeCanSupersedeRawTouchedFailure(winner);
+      return explicitUnsuccessful && !supersededByPassingRepair ? winner.testStatus : outcome.verification.testStatus;
+    })(),
+    testMetrics: winner.testMetrics,
+    testsExecuted: redactPersistedTestsExecuted(winner.testsExecuted),
+    filesChanged: winner.filesChanged ?? winner.gitMetrics?.filesChanged ?? winner.worktreeSummary?.filesChanged,
+    hasChanges: winner.hasChanges ?? outcome.delivery.hasChanges ?? (typeof winner.filesChanged === "number" ? winner.filesChanged > 0 : void 0)
+  };
+}
+function normalizeTerminalHandleErrorMessage(outcome, errorMessage) {
+  const sanitized = sanitizeHandleErrorMessage(errorMessage)?.trim();
+  return sanitized || `Competition ended with ${outcome}`;
+}
+function createEvaluationHandleFinalState(input) {
+  if (input.outcome === "winner_selected") {
+    if (!input.winner) {
+      throw new TypeError("winner_selected terminal state requires a winner");
+    }
+    return { ...input, status: "completed", outcome: "winner_selected", winner: input.winner };
+  }
+  if (input.outcome === "no_winner") {
+    return { ...input, status: "completed", outcome: "no_winner", winner: null };
+  }
+  if (input.outcome === "all_failed") {
+    return { ...input, status: "failed", outcome: "all_failed", winner: null };
+  }
+  if (input.outcome === "timed_out" || input.outcome === "error") {
+    return {
+      ...input,
+      status: "failed",
+      outcome: input.outcome,
+      winner: null,
+      errorMessage: normalizeTerminalHandleErrorMessage(input.outcome, input.errorMessage)
+    };
+  }
+  throw new TypeError(`Unsupported evaluation-handle terminal outcome: ${String(input.outcome)}`);
+}
+function isValidEvaluationHandleFinalState(state) {
+  if (state.status === "completed") {
+    return state.outcome === "winner_selected" && state.winner != null || state.outcome === "no_winner" && state.winner === null;
+  }
+  if (state.outcome === "all_failed") {
+    return state.winner === null;
+  }
+  return (state.outcome === "timed_out" || state.outcome === "error") && state.winner === null && typeof state.errorMessage === "string" && state.errorMessage.trim().length > 0;
+}
+function isDurableHandleCompletion(result, requested = "completed") {
+  return result.kind === "finalized" && result.status === requested || result.kind === "already_terminal" && result.status === requested;
+}
+var EvaluationHandleDurabilityError = class extends Error {
+  deliveredResult;
+  finalizationResult;
+  constructor(deliveredResult, finalizationResult) {
+    super(
+      `Required evaluation handle did not reach durable completed state (kind=${finalizationResult.kind})`
+    );
+    this.name = "EvaluationHandleDurabilityError";
+    this.deliveredResult = deliveredResult;
+    this.finalizationResult = finalizationResult;
+  }
+};
+async function deliverBeforeRequiredHandleDurabilityCheck(deliver, finalizationResult, options) {
+  const deliveredResult = await deliver();
+  if (options.required && !isDurableHandleCompletion(finalizationResult, options.requested ?? "completed")) {
+    throw new EvaluationHandleDurabilityError(deliveredResult, finalizationResult);
+  }
+  return deliveredResult;
+}
+function classifyFinalizePersistenceError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out waiting for finalize lock/i.test(message)) {
+    return { error: message, cause: "lock_timeout" };
+  }
+  if (error instanceof SyntaxError || /JSON|parse/i.test(message) || error instanceof Error && error.name === "SyntaxError") {
+    return { error: message, cause: "parse" };
+  }
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && String(error.code).startsWith("ERR_") === false && /E[A-Z]+/.test(String(error.code))) {
+    return { error: message, cause: "io" };
+  }
+  return { error: message, cause: "unknown" };
+}
+function finalizeEvaluationHandle(evaluationId, finalState) {
+  try {
+    if (!isValidEvaluationHandleFinalState(finalState)) {
+      throw new TypeError(
+        `Invalid evaluation-handle terminal pair: ${finalState.status}/${finalState.outcome}`
+      );
+    }
+    const p = getHandlePath(evaluationId);
+    if (!fs.existsSync(p)) {
+      return { kind: "absent" };
+    }
+    const lockPath = `${p}.lock`;
+    const lockToken = acquireLockSync(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for finalize lock on ${evaluationId}`);
+    }
+    try {
+      return finalizeEvaluationHandleLocked(evaluationId, finalState, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("finalize handle", evaluationId, error);
+    const classified = classifyFinalizePersistenceError(error);
+    return {
+      kind: "persistence_failed",
+      error: classified.error,
+      cause: classified.cause
+    };
+  }
+}
+async function finalizeEvaluationHandleAsync(evaluationId, finalState) {
+  try {
+    if (!isValidEvaluationHandleFinalState(finalState)) {
+      throw new TypeError(
+        `Invalid evaluation-handle terminal pair: ${finalState.status}/${finalState.outcome}`
+      );
+    }
+    const p = getHandlePath(evaluationId);
+    if (!fs.existsSync(p)) {
+      return { kind: "absent" };
+    }
+    const lockPath = `${p}.lock`;
+    const lockToken = await acquireLock(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for finalize lock on ${evaluationId}`);
+    }
+    try {
+      return finalizeEvaluationHandleLocked(evaluationId, finalState, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("finalize handle", evaluationId, error);
+    const classified = classifyFinalizePersistenceError(error);
+    return {
+      kind: "persistence_failed",
+      error: classified.error,
+      cause: classified.cause
+    };
+  }
+}
+function finalizeEvaluationHandleLocked(evaluationId, finalState, p) {
+  const raw = fs.readFileSync(p, "utf8");
+  const parsed = parseJsonWithContext(raw, `Competition handle (${evaluationId})`);
+  const parsedStatus = parsed.status;
+  const isCompletedReconciliation = parsedStatus === "completed" && finalState.status === "completed";
+  if (typeof parsed.status === "string" && TERMINAL_EVALUATION_STATUSES.has(parsedStatus) && !isCompletedReconciliation) {
+    return {
+      kind: "already_terminal",
+      status: parsedStatus,
+      requested: finalState.status
+    };
+  }
+  const completedAt = finalState.completedAt ?? (isCompletedReconciliation && typeof parsed.completedAt === "string" ? parsed.completedAt : (/* @__PURE__ */ new Date()).toISOString());
+  const candidates = parsed.candidates || parsed.variants || [];
+  const hasActiveCandidates = finalState.status === "completed" && candidates.some(
+    (candidate) => !candidateHasCompletedPeer(candidate, candidates) && (candidate.submittedOnly === true || candidate.success === void 0 && candidate.timedOut !== true && !candidate.errorMessage)
+  );
+  const effectiveStatus = hasActiveCandidates ? "running" : finalState.status;
+  const effectiveOutcome = hasActiveCandidates ? void 0 : finalState.outcome;
+  const effectiveCompletedAt = hasActiveCandidates ? void 0 : completedAt;
+  const effectiveErrorMessage = hasActiveCandidates ? void 0 : sanitizeHandleErrorMessage(
+    "errorMessage" in finalState ? finalState.errorMessage : void 0
+  );
+  const parsedWinner = canonicalizeHandleWinner(
+    parsed.winner ?? null
+  );
+  const finalWinner = canonicalizeHandleWinner(finalState.winner);
+  const effectiveWinner = finalState.status === "failed" ? null : hasActiveCandidates && finalState.winner === void 0 ? parsed.winner ?? null : isCompletedReconciliation && parsedWinner && finalState.winner !== null ? parsedWinner : finalWinner;
+  const resolvedWinner = finalState.status === "failed" ? null : effectiveWinner === void 0 ? parsedWinner : effectiveWinner;
+  const resolvedWinnerVerification = finalState.status === "failed" ? null : finalState.winnerVerification === void 0 ? parsed.winnerVerification ?? null : finalState.winnerVerification;
+  const handle = {
+    taskId: parsed.evaluationId || parsed.taskId || evaluationId,
+    evaluationId: parsed.evaluationId || parsed.taskId || evaluationId,
+    prompt: sanitizeHandlePrompt(parsed.prompt),
+    initiatedBy: parsed.initiatedBy,
+    checkoutRoot: parsed.checkoutRoot,
+    createdAt: parsed.createdAt || completedAt,
+    updatedAt: completedAt,
+    status: effectiveStatus,
+    outcome: effectiveOutcome,
+    completedAt: effectiveCompletedAt,
+    errorMessage: effectiveErrorMessage,
+    winner: resolvedWinner,
+    candidates,
+    variants: candidates,
+    labId: parsed.labId,
+    labRunId: parsed.labRunId,
+    runMetadata: finalState.runMetadata ?? parsed.runMetadata,
+    deliverableContract: parsed.deliverableContract,
+    winnerVerification: resolvedWinnerVerification,
+    verification: resolvedWinnerVerification,
+    completenessTelemetry: finalState.completenessTelemetry ?? parsed.completenessTelemetry,
+    decision: finalState.decision ?? parsed.decision,
+    judgeFailures: finalState.judgeFailures ?? parsed.judgeFailures,
+    tieBreak: finalState.tieBreak ?? parsed.tieBreak,
+    synthesis: parsed.synthesis,
+    application: parsed.application,
+    // A finalizer with no delivery to record must not erase one an earlier
+    // writer already persisted.
+    delivery: finalState.delivery ?? parseCompetitionDeliveryRecord(parsed.delivery)
+  };
+  atomicWriteTextSync(p, JSON.stringify(handle, null, 2));
+  if (isCompletedReconciliation) {
+    if (handle.status === "completed" || handle.status === "failed") {
+      return { kind: "finalized", status: handle.status };
+    }
+    return { kind: "not_terminal", status: "running", reason: "active_candidates" };
+  }
+  const finalEventKind = finalState.status === "failed" ? "competition.failed" : "competition.completed";
+  appendCompetitionEvent(evaluationId, finalEventKind, {
+    status: effectiveStatus,
+    outcome: effectiveOutcome,
+    errorMessage: effectiveErrorMessage,
+    winner: resolvedWinner ? {
+      provider: resolvedWinner.provider,
+      variant: resolvedWinner.variant
+    } : null
+  });
+  if (handle.status === "completed" || handle.status === "failed") {
+    return { kind: "finalized", status: handle.status };
+  }
+  return { kind: "not_terminal", status: "running", reason: "active_candidates" };
+}
+function updateEvaluationHandleWithSynthesisResult(evaluationId, result) {
+  try {
+    const p = getHandlePath(evaluationId);
+    const lockPath = `${p}.lock`;
+    const lockToken = acquireLockSync(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for synthesis update lock on ${evaluationId}`);
+    }
+    try {
+      updateEvaluationHandleWithSynthesisResultLocked(evaluationId, result, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("update synthesis metadata", evaluationId, error);
+  }
+}
+async function updateEvaluationHandleWithSynthesisResultAsync(evaluationId, result) {
+  try {
+    const p = getHandlePath(evaluationId);
+    const lockPath = `${p}.lock`;
+    const lockToken = await acquireLock(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for synthesis update lock on ${evaluationId}`);
+    }
+    try {
+      updateEvaluationHandleWithSynthesisResultLocked(evaluationId, result, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("update synthesis metadata", evaluationId, error);
+  }
+}
+function updateEvaluationHandleWithSynthesisResultLocked(evaluationId, result, p) {
+  const raw = fs.existsSync(p) ? fs.readFileSync(p, "utf8") : "";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const parsed = raw ? parseJsonWithContext(raw, `Competition handle (${evaluationId})`) : {};
+  const handle = {
+    taskId: parsed.evaluationId || parsed.taskId || evaluationId,
+    evaluationId: parsed.evaluationId || parsed.taskId || evaluationId,
+    prompt: sanitizeHandlePrompt(parsed.prompt),
+    initiatedBy: parsed.initiatedBy,
+    checkoutRoot: parsed.checkoutRoot,
+    createdAt: parsed.createdAt || now,
+    updatedAt: now,
+    status: parsed.status,
+    outcome: parsed.outcome,
+    completedAt: parsed.completedAt,
+    errorMessage: parsed.errorMessage,
+    winner: parsed.winner,
+    candidates: parsed.candidates || parsed.variants || [],
+    variants: parsed.variants || parsed.candidates || [],
+    labId: parsed.labId,
+    labRunId: parsed.labRunId,
+    runMetadata: parsed.runMetadata,
+    deliverableContract: parsed.deliverableContract,
+    winnerVerification: parsed.winnerVerification,
+    verification: parsed.verification ?? parsed.winnerVerification,
+    completenessTelemetry: parsed.completenessTelemetry,
+    application: parsed.application,
+    delivery: parseCompetitionDeliveryRecord(parsed.delivery),
+    synthesis: sanitizeSynthesisArtifactForPersistence({
+      success: result.success,
+      prNumber: result.prNumber,
+      prUrl: result.prUrl,
+      error: result.error,
+      mergedVariants: result.mergedVariants,
+      synthesisIntents: result.synthesisIntents,
+      donorProfiles: result.donorProfiles,
+      donorSelectionDecisions: result.donorSelectionDecisions,
+      intentFilteredHunkCount: result.intentFilteredHunkCount,
+      excludedHunkCount: result.excludedHunkCount,
+      unknownIncludedHunkCount: result.unknownIncludedHunkCount,
+      unknownExcludedHunkCount: result.unknownExcludedHunkCount,
+      intentMaterialSummaries: result.intentMaterialSummaries,
+      overlapRejectedHunkCount: result.overlapRejectedHunkCount,
+      deliverySucceeded: result.deliverySucceeded,
+      synthesisApplied: result.synthesisApplied,
+      winnerFallback: result.winnerFallback,
+      fallbackReason: result.fallbackReason,
+      patchApplyValidated: result.patchApplyValidated,
+      gatesPassed: result.gatesPassed,
+      gateFailureDetails: result.gateFailureDetails,
+      aiGuidedFallbackAttempted: result.aiGuidedFallbackAttempted,
+      aiGuidedFallbackOutcome: result.aiGuidedFallbackOutcome,
+      // Diagnostics that explain WHY a run carried the winner forward
+      // (agent timeout vs invalid response vs corrupt-patch apply vs
+      // deliberate no-pick). Previously only persisted to the richer
+      // .build-project/telemetry/synthesis/<id>.json sidecar, leaving all
+      // fallback reasons indistinguishable in competition state.
+      synthesisOutcomeStatus: result.synthesisOutcomeStatus,
+      synthesisDurationMs: result.synthesisDurationMs,
+      synthesisProvider: result.synthesisProvider,
+      synthesisModel: result.synthesisModel,
+      synthesisReasoningEffort: result.synthesisReasoningEffort,
+      synthesisProviderDurationMs: result.synthesisProviderDurationMs,
+      synthesisGateDurationMs: result.synthesisGateDurationMs,
+      winnerFirstReview: result.winnerFirstReview,
+      harvestManifest: result.harvestManifest,
+      donorMaterialDiagnostic: result.donorMaterialDiagnostic
+    })
+  };
+  atomicWriteTextSync(p, JSON.stringify(handle, null, 2));
+}
+function updateEvaluationHandleApplicationProvenance(evaluationId, provenance) {
+  try {
+    const p = getHandlePath(evaluationId);
+    const lockPath = `${p}.lock`;
+    const lockToken = acquireLockSync(lockPath);
+    if (!lockToken) {
+      throw new Error(`Timed out waiting for application update lock on ${evaluationId}`);
+    }
+    try {
+      updateEvaluationHandleApplicationProvenanceLocked(evaluationId, provenance, p);
+    } finally {
+      releaseLock(lockPath, lockToken);
+    }
+  } catch (error) {
+    warnHandleFailure("update application provenance", evaluationId, error);
+  }
+}
+function updateEvaluationHandleApplicationProvenanceLocked(evaluationId, provenance, p) {
+  if (!fs.existsSync(p)) {
+    return;
+  }
+  const raw = fs.readFileSync(p, "utf8");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const parsed = parseJsonWithContext(raw, `Competition handle (${evaluationId})`);
+  const candidates = parsed.candidates || parsed.variants || [];
+  const handle = {
+    ...parsed,
+    taskId: parsed.evaluationId || parsed.taskId || evaluationId,
+    evaluationId: parsed.evaluationId || parsed.taskId || evaluationId,
+    prompt: sanitizeHandlePrompt(parsed.prompt),
+    createdAt: parsed.createdAt || now,
+    updatedAt: now,
+    candidates,
+    variants: candidates,
+    application: provenance
+  };
+  atomicWriteTextSync(p, JSON.stringify(handle, null, 2));
+}
+
+// src/orchestrator/competition-final-outcome.ts
+function inferCompetitionFinalOutcome(winner, results) {
+  if (winner) {
+    return "winner_selected";
+  }
+  if (results.some(
+    (result) => (result.outcome ?? deriveVariantOutcome(result)).execution.status === "timed_out"
+  )) {
+    return "timed_out";
+  }
+  return results.some((result) => hasMeaningfulCompetitionProgress(result)) ? "no_winner" : "all_failed";
+}
+
+// src/core/providers/invocation/thrown-transport-streams.ts
+function coerceStreamBytes(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("utf8");
+  }
+  return void 0;
+}
+function readMaybeHiddenField(source, key) {
+  const desc = Object.getOwnPropertyDescriptor(source, key);
+  if (desc && "value" in desc) {
+    return desc.value;
+  }
+  return source[key];
+}
+function firstStreamField(source, keys) {
+  for (const key of keys) {
+    const coerced = coerceStreamBytes(readMaybeHiddenField(source, key));
+    if (coerced !== void 0) {
+      return coerced;
+    }
+  }
+  return void 0;
+}
+function extractThrownTransportStreams(error) {
+  if (error === null || error === void 0 || typeof error !== "object") {
+    return { stdout: "", stderr: "" };
+  }
+  const root = error;
+  const rootRecord = error;
+  const context = rootRecord.context !== null && typeof rootRecord.context === "object" && !Array.isArray(rootRecord.context) ? rootRecord.context : void 0;
+  const stdoutKeys = ["rawStdout", "stdout"];
+  const stderrKeys = ["rawStderr", "stderr"];
+  const stdout = firstStreamField(root, stdoutKeys) ?? (context ? firstStreamField(context, stdoutKeys) : void 0) ?? "";
+  const stderr = firstStreamField(root, stderrKeys) ?? (context ? firstStreamField(context, stderrKeys) : void 0) ?? "";
+  return { stdout, stderr };
+}
+function extractThrownExitCode(error) {
+  if (error === null || error === void 0 || typeof error !== "object") {
+    return null;
+  }
+  const exitCode = error.exitCode;
+  if (typeof exitCode === "number" && Number.isFinite(exitCode)) {
+    return exitCode;
+  }
+  const context = error.context;
+  if (context !== null && typeof context === "object" && !Array.isArray(context)) {
+    const nested = context.exitCode;
+    if (typeof nested === "number" && Number.isFinite(nested)) {
+      return nested;
+    }
+  }
+  return null;
+}
+
+export {
+  extractThrownTransportStreams,
+  extractThrownExitCode,
+  resolveSynthesisResultStatus,
+  resolveSynthesisDeliveryProjection,
+  markSynthesisResultRejected,
+  withSynthesisDeliveryFields,
+  undeliveredMessageFromResult,
+  formatUndeliveredWorkerLine,
+  undeliveredLineFromTelemetry,
+  undeliveredLineLookup,
+  inferCompetitionFinalOutcome,
+  appendCompetitionEvent,
+  initEvaluationHandleAsync,
+  updateEvaluationHandleWithResult,
+  updateEvaluationHandleWithResultAsync,
+  toEvaluationHandleWinnerMetadata,
+  createEvaluationHandleFinalState,
+  isDurableHandleCompletion,
+  deliverBeforeRequiredHandleDurabilityCheck,
+  finalizeEvaluationHandle,
+  finalizeEvaluationHandleAsync,
+  updateEvaluationHandleWithSynthesisResult,
+  updateEvaluationHandleWithSynthesisResultAsync,
+  updateEvaluationHandleApplicationProvenance
+};
+//# sourceMappingURL=chunk-NTD6CSI6.js.map