openpond 0.0.51 → 0.0.52

package/dist/chunks/{src-JOTV67WO.js → src-R5VKB33T.js}

@@ -117,10 +117,10 @@ import {
   workspaceHasHead,
   workspaceToolExperienceBlocker,
   writeWorkspaceFile
-} from "./chunk-UDTHREHB.js";
+} from "./chunk-KNKZSVGO.js";
 import {
   runOpenPondServerCli
-} from "./chunk-LYEXNSCO.js";
+} from "./chunk-3UPQUD6Y.js";
 import {
   createAppServer,
   runAgentCompaction
@@ -138,7 +138,7 @@ import {
   streamOpenPondHostedChatTurn,
   switchOpenPondAccount,
   updateOpenPondAccountConfig
-} from "./chunk-IGSEFSMA.js";
+} from "./chunk-EIRW6Z6S.js";
 import {
   appWorkspacePaths,
   checkWorkspaceGitAvailability,
@@ -166,7 +166,7 @@ import {
   runCommand,
   startMacOSCommandLineToolsInstall,
   workspaceImageContentType
-} from "./chunk-V3HADQL5.js";
+} from "./chunk-FFD2YSZR.js";
 import {
   APP_PREFERENCES_CACHE_KEY,
   APP_PREFERENCES_CACHE_TYPE,
@@ -178,7 +178,7 @@ import {
   isCliEntrypoint,
   now,
   textFromUnknown
-} from "./chunk-J4LLKY6E.js";
+} from "./chunk-C4DAHPVI.js";
 import {
   AccountStateSchema,
   AdapterValidationReceiptSchema,
@@ -244,7 +244,6 @@ import {
   ModelBindingRoleSchema,
   ModelBindingSchema,
   ModelEvaluationReceiptSchema,
-  ModelEvaluationStopReceiptSchema,
   ModelProjectSchema,
   ModelRunDraftSchema,
   ModelRunSchema,
@@ -412,7 +411,7 @@ import {
   workFormatCapabilityForContentType,
   workspacePathFromLocalPathWorkspaceId,
   writeSourceUploadCache
-} from "./chunk-3PYU3XCS.js";
+} from "./chunk-55KT7K5P.js";
 import {
   AttemptReceiptContentSchema,
   AttemptReceiptSchema,
@@ -452,7 +451,7 @@ import {
   workEvidenceReceiptRef,
   workSourceOpaqueRef,
   workWorkspaceOpaqueRef
-} from "./chunk-35OYRVVH.js";
+} from "./chunk-US7DOPAH.js";
 import {
   external_exports,
   yaml
@@ -2706,7 +2705,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash18 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash17 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -3374,7 +3373,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash18("sha1").update(key + GUID).digest("base64");
+        const digest = createHash17("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3743,7 +3742,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash18 } = __require("crypto");
+    var { createHash: createHash17 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -4050,7 +4049,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash18("sha1").update(key + GUID).digest("base64");
+        const digest = createHash17("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -48851,6 +48850,11 @@ function errorMessage4(error) {
 
 // ../server/src/training/harness-refiner-benchmark-protocol.ts
 function createHarnessRefinerExecutionPlan(input) {
+  if (input.seeds.length !== 1 || input.repetitions !== 1) {
+    throw new Error(
+      "Sequential Harness Refiner benchmarks require one admitted seed and one trajectory repetition."
+    );
+  }
   const benchmark = input.taskset.benchmark;
   if (!benchmark) throw new Error("Harness Refiner Taskset has no benchmark definition.");
   const heldOut = taskIdsForSplit(input.taskset, benchmark.evaluationSplit);
@@ -49029,7 +49033,7 @@ import { promises as fs23 } from "node:fs";
 import path56 from "node:path";
 function createResultManifest(input) {
   const core = {
-    schemaVersion: "openpond.harnessRefinerBenchmarkResult.v1",
+    schemaVersion: "openpond.harnessRefinerBenchmarkResult.v2",
     id: `benchmark-result-${input.modelRunId}`,
     modelRunId: input.modelRunId,
     benchmarkId: "harness-refiner",
@@ -49081,7 +49085,7 @@ async function loadLatestManagedResult(storeDir, modelRunId) {
     const value = JSON.parse(
       await fs23.readFile(path56.join(root, entry), "utf8")
     );
-    return value.schemaVersion === "openpond.harnessRefinerBenchmarkResult.v1" && value.modelRunId === modelRunId ? value : null;
+    return value.schemaVersion === "openpond.harnessRefinerBenchmarkResult.v2" && value.modelRunId === modelRunId ? value : null;
   }));
   return manifests.filter((value) => value !== null).sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0] ?? null;
 }
@@ -49180,7 +49184,6 @@ async function ensureBaseVersion(input) {
 }
 
 // ../server/src/training/harness-refiner-benchmark-service-support.ts
-import { createHash as createHash15 } from "node:crypto";
 import { promises as fs24 } from "node:fs";
 import path57 from "node:path";
 function completedStage(input) {
@@ -49322,6 +49325,30 @@ async function loadCompletedBenchmarkStage(input) {
   }));
   return { run, attempts: evidence };
 }
+async function loadBenchmarkAttemptEvidenceByIds(input) {
+  const wanted = new Set(input.attemptIds);
+  const [attempts, grades] = await Promise.all([
+    input.store.listTaskAttempts(input.tasksetId),
+    input.store.listGradeResultsForTaskset(input.tasksetId)
+  ]);
+  const selected = attempts.filter((attempt) => wanted.has(attempt.id));
+  if (selected.length !== wanted.size) {
+    throw new Error(
+      `Sequential adaptation evidence has ${selected.length}/${wanted.size} attempts.`
+    );
+  }
+  const gradesByAttempt = new Map(grades.map((grade) => [grade.attemptId, grade]));
+  return Promise.all(selected.map(async (attempt) => {
+    const grade = gradesByAttempt.get(attempt.id);
+    if (!grade) throw new Error(`Attempt ${attempt.id} has no durable grade.`);
+    return {
+      attempt,
+      grade,
+      artifacts: await input.store.listTaskAttemptArtifacts({ attemptId: attempt.id }),
+      receiptContentHash: portableReceiptContentHash(attempt)
+    };
+  }));
+}
 function attemptHarnessReleaseHash(attempt) {
   const capability = objectRecord(attempt.metadata.harnessCapabilityReceipt);
   const release = objectRecord(capability?.harnessRelease);
@@ -49605,47 +49632,6 @@ function attemptUsageSummary(rawUsage) {
     totalTokens: usage.totalTokens
   };
 }
-function attemptToolFailureCount(result) {
-  const value = result.attempt.output.toolFailureCount;
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.trunc(value) : 0;
-}
-async function benchmarkToolFailureEvidence(input) {
-  if (input.expectedCount === 0) return { failures: [], omittedCount: 0 };
-  const trace = input.artifacts.find((artifact) => artifact.kind === "runtime_trace");
-  if (!trace) {
-    throw new Error(`Attempt ${input.attemptId} has tool failures but no runtime trace.`);
-  }
-  const bytes2 = await fs24.readFile(trace.path);
-  const digest = createHash15("sha256").update(bytes2).digest("hex");
-  if (digest !== trace.sha256) {
-    throw new Error(`Attempt ${input.attemptId} runtime trace failed hash validation.`);
-  }
-  const parsed = objectRecord(JSON.parse(bytes2.toString("utf8")));
-  const steps = Array.isArray(parsed?.steps) ? parsed.steps.map((step) => objectRecord(step)).filter(Boolean) : [];
-  const failures = steps.flatMap((step, index) => {
-    if (step?.kind !== "tool" || step.ok !== false) return [];
-    const toolName = typeof step.name === "string" && step.name.trim() ? step.name.trim() : "unknown_tool";
-    const recoveredLater = steps.slice(index + 1).some(
-      (candidate2) => candidate2?.kind === "tool" && candidate2.name === toolName && candidate2.ok === true
-    );
-    return [{
-      toolName,
-      turn: typeof step.turn === "number" && Number.isInteger(step.turn) ? step.turn : null,
-      detail: typeof step.output === "string" ? step.output.slice(0, 1e3) : "Tool failed without textual output.",
-      recoveredLater
-    }];
-  });
-  if (failures.length !== input.expectedCount) {
-    throw new Error(
-      `Attempt ${input.attemptId} tool-failure count drifted between its receipt and runtime trace.`
-    );
-  }
-  const visible = failures.slice(0, 20);
-  return {
-    failures: visible,
-    omittedCount: failures.length - visible.length
-  };
-}
 function emptyUsageCategory() {
   return { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: null };
 }
@@ -49760,7 +49746,7 @@ function comparisonInvalidReasons(input) {
   for (const [label, run] of [
     ["held-out baseline", input.baseline],
     ["adaptation baseline", input.adaptation],
-    ["candidate adaptation replay", input.candidateAdaptation],
+    ["sequential adaptation treatment", input.candidateAdaptation],
     ["held-out candidate", input.candidate]
   ]) {
     if (run.terminalCount !== run.attemptCount) {
@@ -49773,7 +49759,7 @@ function comparisonInvalidReasons(input) {
   if (!input.harnessChanged) reasons.push("The candidate Harness is unchanged.");
   if (!input.lineageValid) reasons.push("Candidate Harness lineage is incomplete.");
   if (input.candidateAdaptation.passedCount !== input.candidateAdaptation.attemptCount) {
-    reasons.push("Candidate adaptation replay did not pass every case.");
+    reasons.push("Sequential adaptation treatment did not pass every case.");
   }
   if (input.candidate.passedCount !== input.candidate.attemptCount) {
     reasons.push("Candidate held-out quality did not pass every case.");
@@ -49808,7 +49794,7 @@ async function resumeHarnessRefinerComparison(input) {
     budget,
     totalAttempts
   } = input;
-  const [baseline, adaptation, priorCandidateAdaptation, priorCandidate] = await Promise.all([
+  const [baseline, adaptation, priorCandidate] = await Promise.all([
     loadCompletedBenchmarkStage({
       store: deps.store,
       modelRunId: modelRun.id,
@@ -49821,12 +49807,6 @@ async function resumeHarnessRefinerComparison(input) {
       tasksetId: taskset.id,
       plan: input.adaptationPlan
     }),
-    loadCompletedBenchmarkStage({
-      store: deps.store,
-      modelRunId: modelRun.id,
-      tasksetId: taskset.id,
-      plan: input.candidateAdaptationPlan
-    }),
     loadCompletedBenchmarkStage({
       store: deps.store,
       modelRunId: modelRun.id,
@@ -49838,6 +49818,12 @@ async function resumeHarnessRefinerComparison(input) {
   if (!priorManifest) {
     throw new Error("Comparison recovery requires the durable benchmark result manifest.");
   }
+  const sequentialAttemptIds = modelRun.evaluationProgress?.accounting?.attempts.filter((attempt) => attempt.phase === "candidate_adaptation").map((attempt) => attempt.attemptId) ?? [];
+  const candidateAdaptationAttempts = await loadBenchmarkAttemptEvidenceByIds({
+    store: deps.store,
+    tasksetId: taskset.id,
+    attemptIds: sequentialAttemptIds
+  });
   if (priorManifest.tasksetRelease.contentHash !== taskset.benchmark?.releaseHash || priorManifest.harness.baseline.contentHash !== baseline.run.harnessRelease.contentHash) {
     throw new Error("Comparison recovery manifest drifted from the admitted benchmark.");
   }
@@ -49922,12 +49908,6 @@ async function resumeHarnessRefinerComparison(input) {
       createdAt: deps.now()
     });
   };
-  const candidateAdaptation = await retryStage(
-    priorCandidateAdaptation,
-    input.candidateAdaptationPlan,
-    "candidate_adaptation",
-    "adaptation"
-  );
   const candidate2 = await retryStage(
     priorCandidate,
     input.candidatePlan,
@@ -49967,7 +49947,7 @@ async function resumeHarnessRefinerComparison(input) {
     baseline: baseline.run,
     adaptation: adaptation.run,
     refiner: priorManifest.refiner,
-    candidateAdaptation: candidateAdaptation.run,
+    candidateAdaptation: priorManifest.candidateAdaptation,
     candidate: candidate2.run,
     comparison,
     executionPlan,
@@ -49987,7 +49967,7 @@ async function resumeHarnessRefinerComparison(input) {
   const infrastructureValid = benchmarkAttemptsInfrastructureValid([
     ...baseline.attempts,
     ...adaptation.attempts,
-    ...candidateAdaptation.attempts,
+    ...candidateAdaptationAttempts,
     ...candidate2.attempts
   ]);
   const harnessChanged = baseline.run.harnessRelease.contentHash !== candidate2.run.harnessRelease.contentHash;
@@ -49996,7 +49976,7 @@ async function resumeHarnessRefinerComparison(input) {
     baseline: baseline.run,
     adaptation: adaptation.run,
     candidate: candidate2.run,
-    candidateAdaptation: candidateAdaptation.run,
+    candidateAdaptation: priorManifest.candidateAdaptation,
     harnessChanged,
     lineageValid: lineage.valid,
     infrastructureValid
@@ -50004,7 +49984,7 @@ async function resumeHarnessRefinerComparison(input) {
   const invalidReasons = comparisonInvalidReasons({
     baseline: baseline.run,
     adaptation: adaptation.run,
-    candidateAdaptation: candidateAdaptation.run,
+    candidateAdaptation: priorManifest.candidateAdaptation,
     candidate: candidate2.run,
     harnessChanged,
     lineageValid: lineage.valid,
@@ -50030,8 +50010,8 @@ async function resumeHarnessRefinerComparison(input) {
       baseline: { id: baseline.run.id, contentHash: baseline.run.contentHash },
       adaptation: { id: adaptation.run.id, contentHash: adaptation.run.contentHash },
       candidateAdaptation: {
-        id: candidateAdaptation.run.id,
-        contentHash: candidateAdaptation.run.contentHash
+        id: priorManifest.candidateAdaptation.id,
+        contentHash: priorManifest.candidateAdaptation.contentHash
       },
       refiner: {
         id: priorManifest.refiner.id,
@@ -50045,10 +50025,10 @@ async function resumeHarnessRefinerComparison(input) {
       baselinePassRate: comparison.baselinePassRate,
       candidatePassRate: comparison.candidatePassRate,
       adaptationBaselinePassRate: adaptation.run.passedCount / adaptation.run.attemptCount,
-      adaptationCandidatePassRate: candidateAdaptation.run.passedCount / candidateAdaptation.run.attemptCount,
-      adaptationCandidatePassed: candidateAdaptation.run.passedCount === candidateAdaptation.run.attemptCount,
+      adaptationCandidatePassRate: priorManifest.candidateAdaptation.passedCount / priorManifest.candidateAdaptation.attemptCount,
+      adaptationCandidatePassed: priorManifest.candidateAdaptation.passedCount === priorManifest.candidateAdaptation.attemptCount,
       heldOutCandidatePassed: candidate2.run.passedCount === candidate2.run.attemptCount,
-      passed: comparison.qualityPassed && candidateAdaptation.run.passedCount === candidateAdaptation.run.attemptCount && candidate2.run.passedCount === candidate2.run.attemptCount && infrastructureValid && terminalClassification !== "infrastructure_failure"
+      passed: comparison.qualityPassed && priorManifest.candidateAdaptation.passedCount === priorManifest.candidateAdaptation.attemptCount && candidate2.run.passedCount === candidate2.run.attemptCount && infrastructureValid && terminalClassification !== "infrastructure_failure"
     },
     foregroundTokenDelta: comparison.foregroundTokenDelta,
     foregroundTokenDeltaPercent: comparison.foregroundTokenDeltaPercent,
@@ -50090,385 +50070,307 @@ async function resumeHarnessRefinerComparison(input) {
   }));
 }
 
-// ../server/src/training/harness-refiner-benchmark-cohort-evidence.ts
-var MAX_REQUEST_CHARACTERS = 2500;
-var MAX_OUTPUT_CHARACTERS = 4e3;
-var BEHAVIOR_FAMILY_TAGS = [
-  "artifact-verification",
-  "research-efficiency",
-  "constraint-following"
-];
-function boundedText(value, limit) {
-  const text3 = typeof value === "string" ? value : "";
-  return {
-    text: text3.slice(0, limit),
-    truncated: text3.length > limit
-  };
-}
-function taskBehaviorFamily(task) {
-  const families = BEHAVIOR_FAMILY_TAGS.filter((tag) => task.tags.includes(tag));
-  if (families.length !== 1) {
-    throw new Error(`Adaptation task ${task.id} has no behavior-family contract.`);
-  }
-  return families[0];
-}
-function artifactResults(output) {
-  const requiredOutputs2 = Array.isArray(output.requiredOutputs) ? output.requiredOutputs : [];
-  return requiredOutputs2.flatMap((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
-    const item = value;
-    if (typeof item.path !== "string" || typeof item.mediaType !== "string" || typeof item.passed !== "boolean") return [];
-    return [{
-      path: item.path,
-      mediaType: item.mediaType,
-      passed: item.passed,
-      validationKinds: Array.isArray(item.validationKinds) ? item.validationKinds.filter((kind) => typeof kind === "string") : []
-    }];
-  });
-}
-function repeatedToolFailureGroups(attempts) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const attempt of attempts) {
-    for (const failure of attempt.toolFailures) {
-      const group = groups.get(failure.toolName) ?? {
-        occurrences: 0,
-        taskIds: /* @__PURE__ */ new Set()
-      };
-      group.occurrences += 1;
-      group.taskIds.add(attempt.taskId);
-      groups.set(failure.toolName, group);
-    }
-  }
-  return [...groups.entries()].map(([toolName, group]) => ({
-    toolName,
-    distinctTaskCount: group.taskIds.size,
-    occurrenceCount: group.occurrences,
-    taskIds: [...group.taskIds]
-  })).filter((group) => group.distinctTaskCount >= 2).sort(
-    (left, right) => right.distinctTaskCount - left.distinctTaskCount || right.occurrenceCount - left.occurrenceCount || left.toolName.localeCompare(right.toolName)
-  );
-}
-function selectPrimaryEvidenceAnchor(attempts, repeatedGroups) {
-  const repeatedTool = repeatedGroups[0]?.toolName;
-  if (repeatedTool) {
-    const ranked = attempts.map((attempt, index) => ({
-      attempt,
-      index,
-      matchingFailures: attempt.toolFailures.filter(
-        (failure) => failure.toolName === repeatedTool
-      ).length
-    })).filter((item) => item.matchingFailures > 0).sort(
-      (left, right) => right.matchingFailures - left.matchingFailures || left.attempt.toolFailureCount - right.attempt.toolFailureCount || left.index - right.index
-    );
-    const selected2 = ranked[0]?.attempt;
-    if (selected2) {
-      return {
-        attemptId: selected2.attemptId,
-        taskId: selected2.taskId,
-        reason: "repeated_cross_task_tool_failure"
-      };
-    }
-  }
-  const failed = attempts.find((attempt) => !attempt.passed);
-  if (failed) {
-    return {
-      attemptId: failed.attemptId,
-      taskId: failed.taskId,
-      reason: "failed_grade"
-    };
-  }
-  const selected = [...attempts].sort(
-    (left, right) => right.toolFailureCount - left.toolFailureCount || right.latencyMs - left.latencyMs
-  )[0];
-  if (!selected) throw new Error("Adaptation cohort produced no Refiner evidence.");
-  return {
-    attemptId: selected.attemptId,
-    taskId: selected.taskId,
-    reason: "highest_signal_attempt"
-  };
-}
-async function buildHarnessRefinerBenchmarkCohortEvidence(input) {
-  const attempts = await Promise.all(input.adaptationAttempts.map(async (result) => {
-    const task = input.taskset.tasks.find(
-      (candidate2) => candidate2.id === result.attempt.taskId
-    );
-    if (!task || task.split !== "validation") {
-      throw new Error(`Adaptation evidence task ${result.attempt.taskId} is unavailable.`);
-    }
-    const toolFailureCount = attemptToolFailureCount(result);
-    const toolFailureEvidence = await benchmarkToolFailureEvidence({
-      attemptId: result.attempt.id,
-      artifacts: result.artifacts,
-      expectedCount: toolFailureCount
-    });
-    const request = boundedText(taskPrompt2(task), MAX_REQUEST_CHARACTERS);
-    const assistantOutput = boundedText(
-      result.attempt.output.text,
-      MAX_OUTPUT_CHARACTERS
-    );
-    return {
-      attemptId: result.attempt.id,
-      taskId: result.attempt.taskId,
-      behaviorFamily: taskBehaviorFamily(task),
-      attemptReceiptHash: result.receiptContentHash,
-      gradeHash: contentHash(result.grade),
-      passed: result.grade.passed,
-      score: result.grade.score,
-      failureClass: result.grade.failureClass,
-      feedback: [...result.grade.feedback],
-      request: request.text,
-      requestTruncated: request.truncated,
-      assistantOutput: assistantOutput.text,
-      assistantOutputTruncated: assistantOutput.truncated,
-      evaluationCriteria: task.expectedOutput,
-      artifactResults: artifactResults(result.attempt.output),
-      outputsPassed: typeof result.attempt.output.outputsPassed === "boolean" ? result.attempt.output.outputsPassed : null,
-      toolFailureCount,
-      toolFailures: toolFailureEvidence.failures,
-      omittedToolFailureCount: toolFailureEvidence.omittedCount,
-      latencyMs: result.attempt.latencyMs,
-      usage: attemptUsageSummary(result.attempt.metadata.usage)
-    };
-  }));
-  const families = /* @__PURE__ */ new Map();
-  for (const attempt of attempts) {
-    const family = families.get(attempt.behaviorFamily) ?? [];
-    family.push(attempt);
-    families.set(attempt.behaviorFamily, family);
-  }
-  const behaviorFamilies = [...families.entries()].map(([behaviorFamily, familyAttempts]) => ({
-    behaviorFamily,
-    attemptCount: familyAttempts.length,
-    passedCount: familyAttempts.filter((attempt) => attempt.passed).length,
-    failedTaskIds: familyAttempts.filter((attempt) => !attempt.passed).map((attempt) => attempt.taskId),
-    taskIds: familyAttempts.map((attempt) => attempt.taskId),
-    toolFailureCount: familyAttempts.reduce(
-      (total, attempt) => total + attempt.toolFailureCount,
-      0
-    ),
-    tasksWithToolFailures: familyAttempts.filter(
-      (attempt) => attempt.toolFailureCount > 0
-    ).length
-  })).sort((left, right) => left.behaviorFamily.localeCompare(right.behaviorFamily));
-  const crossTaskToolFailureGroups = repeatedToolFailureGroups(attempts);
-  return {
-    schemaVersion: "openpond.harnessRefinerBenchmarkCohortEvidence.v2",
-    reviewScope: "adaptation_cohort",
-    recurrencePolicy: {
-      minimumDistinctAdaptationTasks: 2,
-      primaryTurnIsAnchorOnly: true
-    },
-    attemptCount: attempts.length,
-    passedCount: attempts.filter((attempt) => attempt.passed).length,
-    scoredAttemptCount: attempts.filter(
-      (attempt) => typeof attempt.score === "number"
-    ).length,
-    tasksWithToolFailures: attempts.filter(
-      (attempt) => attempt.toolFailureCount > 0
-    ).length,
-    totalToolFailureCount: attempts.reduce(
-      (total, attempt) => total + attempt.toolFailureCount,
-      0
-    ),
-    totalLatencyMs: attempts.reduce(
-      (total, attempt) => total + attempt.latencyMs,
-      0
-    ),
-    totalTokens: attempts.reduce(
-      (total, attempt) => total + attempt.usage.totalTokens,
-      0
-    ),
-    behaviorFamilies,
-    crossTaskToolFailureGroups,
-    primaryEvidenceAnchor: selectPrimaryEvidenceAnchor(
-      attempts,
-      crossTaskToolFailureGroups
-    ),
-    attempts
-  };
-}
-
 // ../server/src/training/harness-refiner-benchmark-refiner-stage.ts
-async function runHarnessRefinerBenchmarkRefinerStage(input) {
-  const refinerBoundaries = [];
-  const refinerUsage = emptyUsageCategory();
-  for (const result of input.adaptationAttempts) {
-    const attempt = result.attempt;
-    const sessionId = stringMetadata2(attempt.metadata, "sessionId");
-    const turnId = stringMetadata2(attempt.metadata, "turnId");
-    if (!sessionId || !turnId) continue;
-    const session = await input.store.getSession(sessionId);
-    if (!session) continue;
-    const overlay = await ensureLocalHarnessRunOverlay({
-      store: input.store,
-      runId: session.id,
-      workspace: input.baselineRuntime.workspace,
-      harnessRelease: {
-        id: input.baselineRuntime.release.harnessRelease.id,
-        contentHash: input.baselineRuntime.release.harnessRelease.contentHash
-      },
-      admittedAt: attempt.startedAt
-    });
-    const task = input.taskset.tasks.find((candidate2) => candidate2.id === attempt.taskId);
-    if (!task) continue;
-    const turn = TurnSchema.parse({
-      id: turnId,
-      sessionId: session.id,
-      providerTurnId: null,
-      modelRef: input.model,
-      prompt: taskPrompt2(task),
-      startedAt: attempt.startedAt,
-      completedAt: attempt.completedAt,
-      status: "completed",
-      error: null,
-      metadata: {
-        automatedTasksetWorkAttempt: true,
-        benchmarkId: "harness-refiner",
-        modelRunId: input.modelRun.id,
-        attemptId: attempt.id
-      },
-      harnessSnapshot: {
-        schemaVersion: "openpond.harnessTurnSnapshot.v1",
-        workspaceId: input.baselineRuntime.workspace.id,
-        workspaceRevision: input.baselineRuntime.workspace.revision,
-        sourceRevision: input.baselineRuntime.workspace.sourceRevision,
-        channelName: input.baselineRuntime.workspace.currentChannel.name,
-        channelRevision: input.baselineRuntime.workspace.currentChannel.revision,
-        harnessRelease: overlay.baseHarnessRelease,
-        overlay: {
-          id: overlay.id,
-          revision: overlay.revision,
-          contentHash: overlay.contentHash
-        }
-      }
-    });
-    if (!await input.store.getTurn(turn.id)) await input.store.insertTurn(turn);
-    const assistantOutput = attempt.output.text;
-    if (typeof assistantOutput === "string" && assistantOutput.trim()) {
-      await input.store.appendRuntimeEvent(event({
-        sessionId: session.id,
-        turnId: turn.id,
-        name: "assistant.delta",
-        source: "server",
-        appId: session.appId,
-        status: "completed",
-        output: assistantOutput
-      }));
-    }
-    const gradeEvidence = JSON.stringify({
-      schemaVersion: result.grade.schemaVersion,
-      id: result.grade.id,
-      passed: result.grade.passed,
-      score: result.grade.score,
-      failureClass: result.grade.failureClass,
-      rewardEligible: result.grade.rewardEligible,
-      feedback: result.grade.feedback,
-      evaluationCriteria: task.expectedOutput,
-      attempt: {
-        status: result.attempt.infrastructureError ? "infrastructure_failure" : "completed",
-        infrastructureError: result.attempt.infrastructureError,
-        outputPresent: typeof result.attempt.output.text === "string" && result.attempt.output.text.trim().length > 0,
-        artifactCount: result.artifacts.length,
-        runtimeEventCount: result.attempt.runtimeEventRefs.length,
-        latencyMs: result.attempt.latencyMs,
-        usage: attemptUsageSummary(result.attempt.metadata.usage)
-      }
-    });
+async function materializeBenchmarkRefinerBoundary(input) {
+  const attempt = input.result.attempt;
+  const sessionId = stringMetadata2(attempt.metadata, "sessionId");
+  const turnId = stringMetadata2(attempt.metadata, "turnId");
+  if (!sessionId || !turnId) return null;
+  const session = await input.store.getSession(sessionId);
+  if (!session) return null;
+  const overlay = await ensureLocalHarnessRunOverlay({
+    store: input.store,
+    runId: session.id,
+    workspace: input.runtime.workspace,
+    harnessRelease: {
+      id: input.runtime.release.harnessRelease.id,
+      contentHash: input.runtime.release.harnessRelease.contentHash
+    },
+    admittedAt: attempt.startedAt
+  });
+  const task = input.taskset.tasks.find((candidate2) => candidate2.id === attempt.taskId);
+  if (!task) return null;
+  const turn = TurnSchema.parse({
+    id: turnId,
+    sessionId: session.id,
+    providerTurnId: null,
+    modelRef: input.model,
+    prompt: taskPrompt2(task),
+    startedAt: attempt.startedAt,
+    completedAt: attempt.completedAt,
+    status: "completed",
+    error: null,
+    metadata: {
+      automatedTasksetWorkAttempt: true,
+      benchmarkId: "harness-refiner",
+      modelRunId: input.modelRun.id,
+      attemptId: attempt.id
+    },
+    harnessSnapshot: {
+      schemaVersion: "openpond.harnessTurnSnapshot.v1",
+      workspaceId: input.runtime.workspace.id,
+      workspaceRevision: input.runtime.workspace.revision,
+      sourceRevision: input.runtime.workspace.sourceRevision,
+      channelName: input.runtime.workspace.currentChannel.name,
+      channelRevision: input.runtime.workspace.currentChannel.revision,
+      harnessRelease: overlay.baseHarnessRelease,
+      overlay: {
+        id: overlay.id,
+        revision: overlay.revision,
+        contentHash: overlay.contentHash
+      }
+    }
+  });
+  if (!await input.store.getTurn(turn.id)) await input.store.insertTurn(turn);
+  const assistantOutput = attempt.output.text;
+  if (typeof assistantOutput === "string" && assistantOutput.trim()) {
     await input.store.appendRuntimeEvent(event({
       sessionId: session.id,
       turnId: turn.id,
-      name: "diagnostic",
+      name: "assistant.delta",
       source: "server",
       appId: session.appId,
-      action: "taskset_grade",
-      status: result.grade.passed ? "completed" : "failed",
-      output: gradeEvidence,
-      error: result.grade.passed ? void 0 : gradeEvidence,
-      data: {
-        result: {
-          output: gradeEvidence,
-          passed: result.grade.passed,
-          score: result.grade.score
-        }
-      }
+      status: "completed",
+      output: assistantOutput
     }));
-    refinerBoundaries.push({ session, turn, result });
   }
-  const cohortEvidence = await buildHarnessRefinerBenchmarkCohortEvidence({
-    taskset: input.taskset,
-    adaptationAttempts: input.adaptationAttempts
-  });
-  const primaryBoundary = refinerBoundaries.find(
-    (boundary) => boundary.result.attempt.id === cohortEvidence.primaryEvidenceAnchor.attemptId
-  );
-  if (!primaryBoundary) throw new Error("Adaptation cohort produced no Refiner evidence.");
+  const gradeEvidence = JSON.stringify({
+    schemaVersion: input.result.grade.schemaVersion,
+    id: input.result.grade.id,
+    passed: input.result.grade.passed,
+    score: input.result.grade.score,
+    failureClass: input.result.grade.failureClass,
+    rewardEligible: input.result.grade.rewardEligible,
+    feedback: input.result.grade.feedback,
+    evaluationCriteria: task.expectedOutput,
+    attempt: {
+      status: attempt.infrastructureError ? "infrastructure_failure" : "completed",
+      infrastructureError: attempt.infrastructureError,
+      outputPresent: typeof attempt.output.text === "string" && attempt.output.text.trim().length > 0,
+      artifactCount: input.result.artifacts.length,
+      runtimeEventCount: attempt.runtimeEventRefs.length,
+      modelRequestCount: Array.isArray(attempt.metadata.usage) ? attempt.metadata.usage.length : attempt.metadata.usage ? 1 : 0,
+      latencyMs: attempt.latencyMs,
+      usage: attemptUsageSummary(attempt.metadata.usage)
+    }
+  });
+  await input.store.appendRuntimeEvent(event({
+    sessionId: session.id,
+    turnId: turn.id,
+    name: "diagnostic",
+    source: "server",
+    appId: session.appId,
+    action: "taskset_grade",
+    status: input.result.grade.passed ? "completed" : "failed",
+    output: gradeEvidence,
+    error: input.result.grade.passed ? void 0 : gradeEvidence,
+    data: {
+      result: {
+        output: gradeEvidence,
+        passed: input.result.grade.passed,
+        score: input.result.grade.score
+      }
+    }
+  }));
+  return { session, turn, result: input.result };
+}
+async function runBenchmarkRefinerAfterAttempt(input) {
+  const boundary = await materializeBenchmarkRefinerBoundary(input);
+  if (!boundary) {
+    throw new Error(`Adaptation attempt ${input.result.attempt.id} has no Refiner boundary.`);
+  }
   const detection = await recordLocalHarnessImprovementBoundary({
     store: input.store,
-    session: primaryBoundary.session,
-    turn: primaryBoundary.turn,
+    session: boundary.session,
+    turn: boundary.turn,
     boundaryKind: "turn_completed",
     now: input.now
   });
-  if (!detection || detection.trigger.decision !== "queue_refiner") {
-    throw new Error("Adaptation cohort did not produce one Refiner trigger.");
+  if (!detection) {
+    throw new Error(`Adaptation attempt ${input.result.attempt.id} produced no Refiner detection.`);
   }
-  const refinerResults = [];
-  input.budget.assertAvailable(`Refiner cohort ${detection.trigger.id}`);
-  let refinerProviderInvoked = false;
-  let refinerResult;
+  if (detection.trigger.decision !== "queue_refiner") {
+    return { detection, result: null };
+  }
+  input.budget.assertAvailable(`Refiner turn ${detection.trigger.id}`);
+  const usage = emptyUsageCategory();
+  let providerInvoked = false;
   try {
-    refinerResult = await runLocalHarnessRefinerWorker({
+    const result = await runLocalHarnessRefinerWorker({
       store: input.store,
       storeDir: input.storeDir,
       trigger: detection.trigger,
-      additionalEvidence: cohortEvidence,
       stream: async function* (streamInput) {
-        refinerProviderInvoked = true;
+        providerInvoked = true;
         for await (const delta of input.refinerStream({
           ...streamInput,
           model: input.model,
           pricing: input.admittedPricing
         })) {
-          if (delta.usage !== void 0) {
-            addUsage(refinerUsage, delta.usage, delta.costUsd);
-          }
+          if (delta.usage !== void 0) addUsage(usage, delta.usage, delta.costUsd);
           if (delta.text) yield { text: delta.text };
         }
       },
       signal: input.signal,
       now: input.now
     });
+    return { detection, result };
   } finally {
-    if (refinerProviderInvoked) {
-      input.budget.charge(refinerUsage.costUsd, "Refiner");
+    if (providerInvoked) {
+      input.budget.charge(usage.costUsd, "Refiner");
       await checkpointRefinerUsage(
         input.store,
         input.modelRun.id,
-        refinerUsage,
+        usage,
         input.budget.observedSpendUsd
       );
     }
   }
-  refinerResults.push(refinerResult);
-  const candidateWorkspace = await input.store.getHarnessWorkspace(input.baselineRuntime.workspace.id);
-  if (!candidateWorkspace?.currentChannel.release) {
-    throw new Error("Isolated Harness candidate is unavailable.");
-  }
-  const candidateRecord = await input.store.getHarnessReleaseRecord(
-    candidateWorkspace.currentChannel.release.contentHash
-  );
-  if (!candidateRecord) throw new Error("Isolated Harness candidate release is unavailable.");
-  const candidateRuntime = await loadLocalHarnessRuntimeFromRelease({
-    workspace: candidateWorkspace,
-    release: candidateRecord
-  });
+}
+
+// ../server/src/training/harness-refiner-benchmark-sequential-stage.ts
+async function runSequentialHarnessAdaptation(input) {
+  const runRefinerAfterAttempt = input.adapters?.runRefinerAfterAttempt ?? runBenchmarkRefinerAfterAttempt;
+  const loadRuntimeFromRelease = input.adapters?.loadRuntimeFromRelease ?? loadLocalHarnessRuntimeFromRelease;
+  const buildLineage = input.adapters?.buildLineage ?? benchmarkLineage;
   await input.store.setHarnessBackgroundReviewSettings({
-    workspaceId: input.baselineRuntime.workspace.id,
-    enabled: false,
+    workspaceId: input.initialRuntime.workspace.id,
+    enabled: true,
     updatedAt: input.now()
   });
+  let runtime = input.initialRuntime;
+  const attempts = [];
+  const refinerResults = [];
+  const steps = [];
+  try {
+    for (const [ordinal, taskId] of input.taskIds.entries()) {
+      input.signal.throwIfAborted();
+      const before = {
+        id: runtime.release.harnessRelease.id,
+        contentHash: runtime.release.harnessRelease.contentHash
+      };
+      const executed = await input.evaluation.execute({
+        tasksetId: input.taskset.id,
+        taskId,
+        model: input.model,
+        reasoningEffort: input.reasoningEffort,
+        seed: input.seed,
+        attempt: 0,
+        sampling: { maxOutputTokens: 4096, temperature: 0, topP: 1 },
+        releasedHarness: releasedHarness(runtime.release, runtime.instructionContext),
+        hostedTokenPricing: input.admittedPricing,
+        parentModelRunId: input.modelRun.id,
+        signal: input.signal,
+        toolEvidence: frozenToolEvidence(input.evidenceSnapshot, "replay", "adaptation")
+      });
+      await input.onAttemptComplete(executed);
+      const evidence = {
+        attempt: executed.attempt,
+        grade: executed.grade,
+        artifacts: executed.artifacts,
+        receiptContentHash: executed.portable.receipt.contentHash
+      };
+      attempts.push(evidence);
+      const refined = await runRefinerAfterAttempt({
+        store: input.store,
+        storeDir: input.storeDir,
+        modelRun: input.modelRun,
+        model: input.model,
+        taskset: input.taskset,
+        runtime,
+        result: evidence,
+        budget: input.budget,
+        admittedPricing: input.admittedPricing,
+        refinerStream: input.refinerStream,
+        signal: input.signal,
+        now: input.now
+      });
+      if (refined.result) refinerResults.push(refined.result);
+      const workspace = await input.store.getHarnessWorkspace(runtime.workspace.id);
+      const releaseRef = workspace?.currentChannel.release;
+      if (!workspace || !releaseRef) {
+        throw new Error("Sequential Refiner did not retain a current Harness release.");
+      }
+      const release = await input.store.getHarnessReleaseRecord(releaseRef.contentHash);
+      if (!release) throw new Error("Sequential Refiner release is unavailable.");
+      runtime = await loadRuntimeFromRelease({ workspace, release });
+      const after = {
+        id: runtime.release.harnessRelease.id,
+        contentHash: runtime.release.harnessRelease.contentHash
+      };
+      steps.push({
+        ordinal,
+        taskId,
+        attemptId: evidence.attempt.id,
+        inputHarness: before,
+        outputHarness: after,
+        trigger: {
+          id: refined.detection.trigger.id,
+          contentHash: refined.detection.trigger.contentHash,
+          decision: refined.detection.trigger.decision
+        },
+        outcome: refined.result ? {
+          id: refined.result.outcome.id,
+          contentHash: refined.result.outcome.contentHash,
+          decision: refined.result.outcome.decision
+        } : null,
+        changed: before.contentHash !== after.contentHash
+      });
+    }
+  } finally {
+    await input.store.setHarnessBackgroundReviewSettings({
+      workspaceId: input.initialRuntime.workspace.id,
+      enabled: false,
+      updatedAt: input.now()
+    });
+  }
+  const usage = attempts.reduce(
+    (total, evidence) => {
+      const records = Array.isArray(evidence.attempt.metadata.usage) ? evidence.attempt.metadata.usage : [evidence.attempt.metadata.usage];
+      for (const value of records) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+        const record11 = value;
+        const inputTokens = numericToken(record11, ["promptTokens", "inputTokens"]);
+        const outputTokens = numericToken(record11, ["completionTokens", "outputTokens"]);
+        total.inputTokens += inputTokens;
+        total.outputTokens += outputTokens;
+        total.totalTokens += numericToken(record11, ["totalTokens"]) || inputTokens + outputTokens;
+      }
+      return total;
+    },
+    { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+  );
+  const costs = attempts.flatMap(
+    (evidence) => typeof evidence.attempt.costUsd === "number" ? [evidence.attempt.costUsd] : []
+  );
+  const initialHarness = {
+    id: input.initialRuntime.release.harnessRelease.id,
+    contentHash: input.initialRuntime.release.harnessRelease.contentHash
+  };
+  const finalHarness = {
+    id: runtime.release.harnessRelease.id,
+    contentHash: runtime.release.harnessRelease.contentHash
+  };
+  const summaryCore = {
+    schemaVersion: "openpond.sequentialHarnessAdaptation.v1",
+    id: `sequential-adaptation-${input.modelRun.id}`,
+    initialHarness,
+    finalHarness,
+    attemptCount: attempts.length,
+    passedCount: attempts.filter((evidence) => evidence.grade.passed).length,
+    terminalCount: attempts.filter((evidence) => !evidence.attempt.infrastructureError).length,
+    usage,
+    costUsd: costs.length ? costs.reduce((total, cost) => total + cost, 0) : null,
+    latencyMs: attempts.reduce((total, evidence) => total + evidence.attempt.latencyMs, 0),
+    steps,
+    createdAt: input.now()
+  };
+  const summary2 = {
+    ...summaryCore,
+    contentHash: contentHash(summaryCore)
+  };
   const outcomes = await input.store.listHarnessImprovementArtifacts(
-    input.baselineRuntime.workspace.id,
+    input.initialRuntime.workspace.id,
     "refiner_outcome",
     1e3
   );
@@ -50477,23 +50379,36 @@ async function runHarnessRefinerBenchmarkRefinerStage(input) {
     contentHash: contentHash(outcomes),
     outcomeCount: outcomes.length
   };
-  const lineage = await benchmarkLineage({
+  const lineage = await buildLineage({
     store: input.store,
-    workspaceId: input.baselineRuntime.workspace.id,
-    adaptationAttempts: input.adaptationAttempts,
+    workspaceId: input.initialRuntime.workspace.id,
+    adaptationAttempts: attempts,
     refinerResults,
-    candidateRelease: candidateRecord.harnessRelease,
-    refinerInputHash: contentHash(cohortEvidence)
+    candidateRelease: finalHarness,
+    refinerInputHash: contentHash(attempts.map((evidence) => ({
+      attempt: evidence.attempt.id,
+      receipt: evidence.receiptContentHash,
+      grade: contentHash(evidence.grade)
+    })))
   });
-  const frozenEvidence = input.evidenceSnapshot.manifest();
   return {
-    candidateRecord,
-    candidateRuntime,
+    attempts,
+    runtime,
+    summary: summary2,
     refinerStage,
     lineage,
-    frozenEvidence
+    refinerResults
   };
 }
+function numericToken(record11, keys) {
+  for (const key of keys) {
+    const value = record11[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      return Math.trunc(value);
+    }
+  }
+  return 0;
+}
 
 // ../server/src/training/harness-refiner-benchmark-service.ts
 var BenchmarkRunCancelledError = class extends Error {
@@ -50758,7 +50673,6 @@ function createHarnessRefinerBenchmarkService(deps) {
           executionPlan,
           baselinePlan,
           adaptationPlan,
-          candidateAdaptationPlan,
           candidatePlan,
           admittedPricing,
           budget,
@@ -50859,11 +50773,6 @@ function createHarnessRefinerBenchmarkService(deps) {
           completedAttempts: completedBeforeStage(executionPlan, "adaptation"),
           totalAttempts
         });
-        await deps.store.setHarnessBackgroundReviewSettings({
-          workspaceId: isolated.workspace.id,
-          enabled: true,
-          updatedAt: now2()
-        });
         const executedAdaptation = await deps.evaluation.executeBenchmark({
           tasksetId: taskset.id,
           phase: "baseline",
@@ -50895,168 +50804,47 @@ function createHarnessRefinerBenchmarkService(deps) {
           totalAttempts
         });
       }
-      if (resumeFromRefiner) {
-        const priorOutcomes = await deps.store.listHarnessImprovementArtifacts(
-          isolated.workspace.id,
-          "refiner_outcome",
-          1e3
+      if (resumeFromRefiner && !modelRun.evaluationProgress?.evidenceSnapshot) {
+        throw new Error(
+          "Sequential adaptation cannot resume because the interrupted run did not preserve its exact frozen evidence snapshot. Start a new run to preserve a valid causal comparison."
         );
-        const currentWorkspace = await deps.store.getHarnessWorkspace(isolated.workspace.id);
-        const currentReleaseRef = currentWorkspace?.currentChannel.release;
-        if (priorOutcomes.length > 0 && currentReleaseRef && currentReleaseRef.contentHash === baseline.run.harnessRelease.contentHash) {
-          await deps.store.setHarnessBackgroundReviewSettings({
-            workspaceId: isolated.workspace.id,
-            enabled: false,
-            updatedAt: now2()
-          });
-          const latestRun2 = await deps.store.getModelRun(modelRun.id) ?? modelRun;
-          const accounting = latestRun2.evaluationProgress?.accounting ?? emptyEvaluationAccounting();
-          const frozenEvidence2 = evidenceSnapshot.manifest();
-          const refinerStage2 = {
-            id: `benchmark-refiner-${modelRun.id}`,
-            contentHash: contentHash(priorOutcomes),
-            outcomeCount: priorOutcomes.length
-          };
-          const receiptCore2 = {
-            schemaVersion: "openpond.modelEvaluationStopReceipt.v1",
-            benchmarkId: "harness-refiner",
-            terminalClassification: "inconclusive",
-            stopReason: "candidate_harness_unchanged",
-            reason: "Refiner produced no changed Harness candidate. Candidate replay was skipped because no effect can be attributed to refinement.",
-            stoppedAfter: "refiner",
-            baselineHarness: baseline.run.harnessRelease,
-            candidateHarness: currentReleaseRef,
-            refiner: refinerStage2,
-            usage: accounting.usage,
-            budget: {
-              maximumSpendUsd: budget.maximumSpendUsd,
-              observedSpendUsd: accounting.observedSpendUsd,
-              enforced: true
-            },
-            evidenceSnapshot: {
-              id: frozenEvidence2.id,
-              contentHash: frozenEvidence2.contentHash
-            },
-            attempts: accounting.attempts
-          };
-          const receipt2 = ModelEvaluationStopReceiptSchema.parse({
-            ...receiptCore2,
-            contentHash: contentHash(receiptCore2)
-          });
-          const completedAt2 = now2();
-          return deps.store.saveModelRun(ModelRunSchema.parse({
-            ...latestRun2,
-            status: "succeeded",
-            receipt: receipt2,
-            failure: null,
-            completedAt: completedAt2,
-            updatedAt: completedAt2
-          }));
-        }
       }
-      const {
-        candidateRecord,
-        candidateRuntime,
-        refinerStage,
-        lineage,
-        frozenEvidence
-      } = await runHarnessRefinerBenchmarkRefinerStage({
+      await updateProgress(deps.store, modelRun.id, {
+        stage: "candidate_adaptation",
+        completedAttempts: completedBeforeStage(executionPlan, "candidate_adaptation"),
+        totalAttempts
+      });
+      const candidateAdaptation = await runSequentialHarnessAdaptation({
         store: deps.store,
         storeDir: deps.storeDir,
+        evaluation: deps.evaluation,
         modelRun,
         model: input.model,
+        reasoningEffort: input.reasoningEffort,
         taskset,
-        baselineRuntime,
-        adaptationAttempts,
+        taskIds: candidateAdaptationPlan.taskIds,
+        seed: input.seeds[0],
+        initialRuntime: baselineRuntime,
         evidenceSnapshot,
         budget,
         admittedPricing,
         refinerStream: deps.refinerStream,
         signal: context.signal,
+        onAttemptComplete: observeStageAttempts(
+          "candidate_adaptation",
+          "sequential adaptation treatment"
+        ),
         now: now2
       });
-      const harnessChanged = baseline.run.harnessRelease.contentHash !== candidateRecord.harnessRelease.contentHash;
-      if (!harnessChanged || !lineage.valid) {
-        const stopReason = harnessChanged ? "candidate_lineage_invalid" : "candidate_harness_unchanged";
-        const reason = harnessChanged ? "Refiner produced a candidate whose causal lineage did not validate. Candidate replay was skipped." : "Refiner produced no changed Harness candidate. Candidate replay was skipped because no effect can be attributed to refinement.";
-        const latestRun2 = await deps.store.getModelRun(modelRun.id) ?? modelRun;
-        const accounting = latestRun2.evaluationProgress?.accounting ?? emptyEvaluationAccounting();
-        const receiptCore2 = {
-          schemaVersion: "openpond.modelEvaluationStopReceipt.v1",
-          benchmarkId: "harness-refiner",
-          terminalClassification: "inconclusive",
-          stopReason,
-          reason,
-          stoppedAfter: "refiner",
-          baselineHarness: baseline.run.harnessRelease,
-          candidateHarness: {
-            id: candidateRecord.harnessRelease.id,
-            contentHash: candidateRecord.harnessRelease.contentHash
-          },
-          refiner: refinerStage,
-          usage: accounting.usage,
-          budget: {
-            maximumSpendUsd: budget.maximumSpendUsd,
-            observedSpendUsd: budget.observedSpendUsd,
-            enforced: true
-          },
-          evidenceSnapshot: {
-            id: frozenEvidence.id,
-            contentHash: frozenEvidence.contentHash
-          },
-          attempts: accounting.attempts
-        };
-        const receipt2 = ModelEvaluationStopReceiptSchema.parse({
-          ...receiptCore2,
-          contentHash: contentHash(receiptCore2)
-        });
-        const completedAt2 = now2();
-        return deps.store.saveModelRun(ModelRunSchema.parse({
-          ...latestRun2,
-          status: "succeeded",
-          receipt: receipt2,
-          failure: null,
-          completedAt: completedAt2,
-          updatedAt: completedAt2
-        }));
-      }
-      if (resumeFromRefiner && !modelRun.evaluationProgress?.evidenceSnapshot) {
-        throw new Error(
-          "Candidate replay cannot resume because the interrupted run did not preserve its exact frozen evidence snapshot. Start a new run to preserve a valid causal comparison."
-        );
-      }
-      await updateProgress(deps.store, modelRun.id, {
-        stage: "candidate_adaptation",
-        completedAttempts: completedBeforeStage(executionPlan, "candidate_adaptation"),
-        totalAttempts
-      });
+      const candidateRuntime = candidateAdaptation.runtime;
+      const refinerStage = candidateAdaptation.refinerStage;
+      const lineage = candidateAdaptation.lineage;
+      const frozenEvidence = evidenceSnapshot.manifest();
+      const harnessChanged = baseline.run.harnessRelease.contentHash !== candidateAdaptation.summary.finalHarness.contentHash;
       const candidateHarness = releasedHarness(
         candidateRuntime.release,
         candidateRuntime.instructionContext
       );
-      const candidateAdaptation = await deps.evaluation.executeBenchmark({
-        tasksetId: taskset.id,
-        phase: "candidate",
-        model: input.model,
-        reasoningEffort: input.reasoningEffort,
-        seeds: input.seeds,
-        repetitions: input.repetitions,
-        split: candidateAdaptationPlan.split,
-        taskIds: candidateAdaptationPlan.taskIds,
-        sampling: { maxOutputTokens: 4096, temperature: 0, topP: 1 },
-        releasedHarness: candidateHarness,
-        hostedTokenPricing: admittedPricing,
-        parentModelRunId: modelRun.id,
-        signal: context.signal,
-        toolEvidence: frozenToolEvidence(evidenceSnapshot, "replay", "adaptation"),
-        onAttemptComplete: observeStageAttempts(
-          "candidate_adaptation",
-          "candidate adaptation replay"
-        )
-      });
-      if (!candidateAdaptation.comparison) {
-        throw new Error("Adaptation replay comparison was not produced.");
-      }
       await updateProgress(deps.store, modelRun.id, {
         stage: "candidate",
         completedAttempts: completedBeforeStage(executionPlan, "candidate"),
@@ -51093,7 +50881,7 @@ function createHarnessRefinerBenchmarkService(deps) {
         baseline: baseline.run,
         adaptation: adaptation.run,
         refiner: refinerStage,
-        candidateAdaptation: candidateAdaptation.run,
+        candidateAdaptation: candidateAdaptation.summary,
         candidate: candidate2.run,
         comparison: candidate2.comparison,
         executionPlan,
@@ -51128,17 +50916,17 @@ function createHarnessRefinerBenchmarkService(deps) {
         baseline: baseline.run,
         adaptation: adaptation.run,
         candidate: candidate2.run,
-        harnessChanged: baseline.run.harnessRelease.contentHash !== candidate2.run.harnessRelease.contentHash,
-        candidateAdaptation: candidateAdaptation.run,
+        harnessChanged,
+        candidateAdaptation: candidateAdaptation.summary,
         lineageValid: lineage.valid,
         infrastructureValid
       });
       const invalidReasons = comparisonInvalidReasons({
         baseline: baseline.run,
         adaptation: adaptation.run,
-        candidateAdaptation: candidateAdaptation.run,
+        candidateAdaptation: candidateAdaptation.summary,
         candidate: candidate2.run,
-        harnessChanged: baseline.run.harnessRelease.contentHash !== candidate2.run.harnessRelease.contentHash,
+        harnessChanged,
         lineageValid: lineage.valid,
         infrastructureValid
       });
@@ -51169,8 +50957,8 @@ function createHarnessRefinerBenchmarkService(deps) {
             contentHash: adaptation.run.contentHash
           },
           candidateAdaptation: {
-            id: candidateAdaptation.run.id,
-            contentHash: candidateAdaptation.run.contentHash
+            id: candidateAdaptation.summary.id,
+            contentHash: candidateAdaptation.summary.contentHash
           },
           refiner: { id: refinerStage.id, contentHash: refinerStage.contentHash },
           candidate: { id: candidate2.run.id, contentHash: candidate2.run.contentHash },
@@ -51184,10 +50972,10 @@ function createHarnessRefinerBenchmarkService(deps) {
           baselinePassRate: candidate2.comparison.baselinePassRate,
           candidatePassRate: candidate2.comparison.candidatePassRate,
           adaptationBaselinePassRate: adaptation.run.passedCount / adaptation.run.attemptCount,
-          adaptationCandidatePassRate: candidateAdaptation.run.passedCount / candidateAdaptation.run.attemptCount,
-          adaptationCandidatePassed: candidateAdaptation.run.passedCount === candidateAdaptation.run.attemptCount,
+          adaptationCandidatePassRate: candidateAdaptation.summary.passedCount / candidateAdaptation.summary.attemptCount,
+          adaptationCandidatePassed: candidateAdaptation.summary.passedCount === candidateAdaptation.summary.attemptCount,
           heldOutCandidatePassed: candidate2.run.passedCount === candidate2.run.attemptCount,
-          passed: candidate2.comparison.qualityPassed && candidateAdaptation.run.passedCount === candidateAdaptation.run.attemptCount && candidate2.run.passedCount === candidate2.run.attemptCount && infrastructureValid && terminalClassification !== "infrastructure_failure"
+          passed: candidate2.comparison.qualityPassed && candidateAdaptation.summary.passedCount === candidateAdaptation.summary.attemptCount && candidate2.run.passedCount === candidate2.run.attemptCount && infrastructureValid && terminalClassification !== "infrastructure_failure"
         },
         foregroundTokenDelta: candidate2.comparison.foregroundTokenDelta,
         foregroundTokenDeltaPercent: candidate2.comparison.foregroundTokenDeltaPercent,
@@ -51336,14 +51124,14 @@ async function loadTaskAttemptGraderEvidence(input) {
         return {
           ...base,
           extraction: "pdf_text",
-          content: boundedText2(stdout)
+          content: boundedText(stdout)
         };
       }
       if (isTextArtifact(artifact.mediaType)) {
         return {
           ...base,
           extraction: "text",
-          content: boundedText2(await readFile15(artifact.path, "utf8"))
+          content: boundedText(await readFile15(artifact.path, "utf8"))
         };
       }
       return { ...base, extraction: "metadata_only" };
@@ -51361,7 +51149,7 @@ function isTextArtifact(mediaType) {
     mediaType?.startsWith("text/") || mediaType === "application/json" || mediaType === "application/xml"
   );
 }
-function boundedText2(value) {
+function boundedText(value) {
   return value.length <= MAX_EXTRACTED_CHARS ? value : `${value.slice(0, MAX_EXTRACTED_CHARS)}
 [truncated]`;
 }
@@ -51421,7 +51209,7 @@ function usageCost(usage, pricing) {
 }
 
 // ../server/src/training/benchmark-tasksets.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile7 } from "node:fs/promises";
 import path58 from "node:path";
 var BUILTIN_DEFINITION_ID = "harness-refiner";
@@ -51474,8 +51262,8 @@ function definitionForRelease(release) {
   return createBenchmarkDefinition({
     schemaVersion: "openpond.benchmarkDefinition.v1",
     id: BUILTIN_DEFINITION_ID,
-    title: "Harness Refiner",
-    description: "Measures whether evidence-driven Harness improvements preserve quality while reducing held-out foreground tokens.",
+    title: "Harness Refiner 08112026",
+    description: "Measures whether sequential, evidence-driven Harness improvements preserve quality while reducing future-task foreground tokens.",
     tasksetRelease: { id: release.id, contentHash: release.contentHash },
     adaptationSplit: "validation",
     evaluationSplit: "frozen_eval",
@@ -51485,7 +51273,7 @@ function definitionForRelease(release) {
       adaptation: release.tasks.filter((task) => task.split === "validation").length,
       evaluation: release.tasks.filter((task) => task.split === "frozen_eval").length
     },
-    metadata: { builtin: true }
+    metadata: { builtin: true, protocol: "sequential_product_lifecycle" }
   });
 }
 async function projectRelease(input) {
@@ -51516,7 +51304,7 @@ async function projectRelease(input) {
     managedAssetById.set(asset.id, {
       artifactRef,
       fileName,
-      sha256: createHash16("sha256").update(contents).digest("hex"),
+      sha256: createHash15("sha256").update(contents).digest("hex"),
       sizeBytes: Buffer.byteLength(contents),
       mediaType: asset.mediaType
     });
@@ -51809,7 +51597,7 @@ function stringValue11(value) {
 
 // ../server/src/training/local-taskset-work-runtime.ts
 import { execFile as execFile8 } from "node:child_process";
-import { createHash as createHash17, randomUUID as randomUUID24 } from "node:crypto";
+import { createHash as createHash16, randomUUID as randomUUID24 } from "node:crypto";
 import { existsSync as existsSync12, promises as fs25 } from "node:fs";
 import os9 from "node:os";
 import path59 from "node:path";
@@ -51976,11 +51764,11 @@ async function executeLocalWorkspaceTool(input) {
       await fs25.writeFile(destination, bytes2, { mode: 384 });
       const outputRef = FileOutputRefSchema.parse({
         kind: "file",
-        id: `output-${createHash17("sha256").update(destination).digest("hex").slice(0, 24)}`,
+        id: `output-${createHash16("sha256").update(destination).digest("hex").slice(0, 24)}`,
         title,
         contentType: contentType2,
         sizeBytes: bytes2.byteLength,
-        sha256: createHash17("sha256").update(bytes2).digest("hex"),
+        sha256: createHash16("sha256").update(bytes2).digest("hex"),
         sourceTaskId: input.session.id,
         sourceTurnId: input.turnId ?? `local-work-${input.session.id}`,
         revision: 1,
@@ -52105,7 +51893,7 @@ function runCommand5(command, cwd, timeoutMs) {
 function localStatus(root, state = "running") {
   return {
     sandbox: {
-      id: `desktop-local:${createHash17("sha256").update(root).digest("hex").slice(0, 16)}`,
+      id: `desktop-local:${createHash16("sha256").update(root).digest("hex").slice(0, 16)}`,
       state,
       provider: "desktop-local"
     },
@@ -52117,7 +51905,7 @@ function fileData(target, bytes2) {
   return {
     path: target,
     sizeBytes: bytes2.byteLength,
-    sha256: createHash17("sha256").update(bytes2).digest("hex")
+    sha256: createHash16("sha256").update(bytes2).digest("hex")
   };
 }
 function validationEvidence(value) {