openpond 0.0.60 → 0.0.61

package/dist/chunks/{src-E2UCLY54.js → src-O5QXOQ5H.js}

@@ -9,6 +9,7 @@ import {
   appDataDir,
   asRecord,
   attachModelTargetRefs,
+  autoTitlePromptFromPayload,
   booleanValue,
   chatAttachmentContext,
   chatAttachmentImageContentType,
@@ -43,6 +44,7 @@ import {
   createScriptedOpenPondChatStream,
   createServerWorkQueues,
   createSessionStore,
+  createSessionTitleService,
   createTaskCreatorService,
   createTaskEvaluationService,
   createTasksetRef,
@@ -137,10 +139,11 @@ import {
   upsertInternalSandboxProject,
   validateOpenAiCompatibleProvider,
   waitForWorkReceiptSettlement,
+  withPendingAutoTitle,
   workspaceHasHead,
   workspaceToolExperienceBlocker,
   writeWorkspaceFile
-} from "./chunk-XFZYNYRI.js";
+} from "./chunk-BQQS5RRI.js";
 import {
   appWorkspacePaths,
   checkWorkspaceGitAvailability,
@@ -166,14 +169,14 @@ import {
   runCommand,
   startMacOSCommandLineToolsInstall,
   workspaceImageContentType
-} from "./chunk-LDRWEAOB.js";
+} from "./chunk-NPEWMLRH.js";
 import {
   runOpenPondServerCli
-} from "./chunk-AHILPQXV.js";
+} from "./chunk-5HMXXGWZ.js";
 import {
   createAppServer,
   runAgentCompaction
-} from "./chunk-NFNEENNR.js";
+} from "./chunk-OYWTQABY.js";
 import {
   APP_PREFERENCES_CACHE_KEY,
   APP_PREFERENCES_CACHE_TYPE,
@@ -185,7 +188,7 @@ import {
   isCliEntrypoint,
   now,
   textFromUnknown
-} from "./chunk-TOCZQEPW.js";
+} from "./chunk-6RMGHEFF.js";
 import {
   createOpenPondRepoApp,
   getBundledRuntimeVersion,
@@ -199,7 +202,7 @@ import {
   streamOpenPondHostedChatTurn,
   switchOpenPondAccount,
   updateOpenPondAccountConfig
-} from "./chunk-LMQ4MPQI.js";
+} from "./chunk-32R4GQD3.js";
 import {
   AccountStateSchema,
   AdapterValidationReceiptSchema,
@@ -432,17 +435,20 @@ import {
   workFormatCapabilityForContentType,
   workspacePathFromLocalPathWorkspaceId,
   writeSourceUploadCache
-} from "./chunk-PVGJXCAK.js";
+} from "./chunk-L5JTI6LQ.js";
 import "./chunk-QETF6ILG.js";
 import {
+  ArtifactManifestSchema,
   AttemptReceiptContentSchema,
   AttemptReceiptSchema,
   BenchmarkDefinitionSchema,
   CONNECTED_APP_INTEGRATION_SKILLS,
   DEFAULT_REFINER_MAX_OUTPUT_TOKENS,
   EvidenceArtifactRefSchema,
+  ImmutableAssetRefSchema,
   ImmutableReleaseRefSchema,
   OPENPOND_MANIFEST_FILE_NAME,
+  RewardReceiptSchema,
   SANDBOX_TEMPLATE_BUILD_PLAN_FILE_NAME,
   SANDBOX_TEMPLATE_PREVIEW_PORT_MAX,
   SANDBOX_TEMPLATE_PREVIEW_PORT_MIN,
@@ -470,17 +476,19 @@ import {
   sandboxTemplateScaffoldFiles,
   sha256,
   validateSandboxTemplateYaml,
+  verifyArtifactManifest,
+  verifyRewardReceipt,
   workEvidenceReceiptRef,
   workSourceOpaqueRef,
   workWorkspaceOpaqueRef
-} from "./chunk-VG4H4TQG.js";
+} from "./chunk-TOMMZN6V.js";
 import {
   external_exports,
   yaml
 } from "./chunk-WYDVQOBL.js";
 import {
   withVercelProtectionBypass
-} from "./chunk-DXSHQ6TO.js";
+} from "./chunk-XSHMPOQV.js";
 import {
   __commonJS,
   __require,
@@ -13333,9 +13341,9 @@ var require_dist = __commonJS({
 });
 
 // ../server/src/index.ts
-import path61 from "node:path";
+import path62 from "node:path";
 import { randomUUID as randomUUID24 } from "node:crypto";
-import { promises as fs25 } from "node:fs";
+import { promises as fs26 } from "node:fs";
 
 // ../../packages/codex-provider/dist/client.js
 import { spawn } from "node:child_process";
@@ -15351,6 +15359,12 @@ var FALLBACK_PROVIDER_PRESETS = [
         contextWindow: 1048576,
         capabilities: REASONING_MODEL_CAPABILITIES
       },
+      {
+        id: "accounts/fireworks/models/nemotron-lightning-3p5-30b-a3b",
+        displayName: "Nemotron Lightning 3.5 30B A3B",
+        contextWindow: 262144,
+        capabilities: REASONING_MODEL_CAPABILITIES
+      },
       {
         id: "accounts/fireworks/models/minimax-m3",
         displayName: "MiniMax M3",
@@ -20740,9 +20754,19 @@ function agentSdkRunScriptCommand(packageManager, scriptName) {
     return `bun run ${scriptName}`;
   return `pnpm run ${scriptName}`;
 }
+function agentSdkRunJsonScriptCommand(packageManager, scriptName) {
+  if (packageManager === "pnpm")
+    return `pnpm --silent run ${scriptName}`;
+  if (packageManager === "yarn")
+    return `yarn --silent ${scriptName}`;
+  if (packageManager === "npm")
+    return `npm run --silent ${scriptName}`;
+  if (packageManager === "bun")
+    return `bun run --silent ${scriptName}`;
+  return `pnpm --silent run ${scriptName}`;
+}
 
 // ../../packages/cloud/dist/profile/project-source-upload-agent-sdk.js
-var OPENPOND_PNPM_PACKAGE_MANAGER = "pnpm@11.13.0";
 var AGENT_SDK_VENDOR_TARBALL_PATH = ".openpond/vendor/openpond-agent-sdk.tgz";
 var AGENT_SDK_VENDOR_NPM_DEPENDENCY_DIR = ".openpond/vendor/npm";
 var AGENT_SDK_MATERIALIZED_DEPENDENCY_SPEC = `file:${AGENT_SDK_VENDOR_TARBALL_PATH}`;
@@ -20772,6 +20796,8 @@ async function buildAgentSdkMaterializedDependency(projectPath, packageJson) {
     const sdkDependencyTarballs = await packAgentSdkRuntimeDependencyTarballs({
       sdkPackageJson: sdkSource.packageJson,
       dependencyBaseDir: sdkSource.dependencyBaseDir,
+      projectPackageJson: packageJson,
+      projectPath,
       tempDir
     });
     const packageManager = detectAgentSdkPackageManager(projectPath, packageJson);
@@ -20832,21 +20858,34 @@ ${details}` : ""}`);
   return fs9.readFile(path15.join(tempDir, tarballName));
 }
 async function packAgentSdkRuntimeDependencyTarballs(params) {
-  const dependencies = recordStringMap(params.sdkPackageJson.dependencies);
-  const pending = Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)).map(([packageName, versionSpec]) => ({ packageName, versionSpec }));
+  const sdkDependencies = recordStringMap(params.sdkPackageJson.dependencies);
+  const projectDependencies = recordStringMap(params.projectPackageJson.dependencies);
+  delete projectDependencies["openpond-agent-sdk"];
+  const pending = [
+    ...Object.entries(sdkDependencies).map(([packageName, versionSpec]) => ({
+      packageName,
+      versionSpec,
+      dependencyBaseDir: params.dependencyBaseDir
+    })),
+    ...Object.entries(projectDependencies).map(([packageName, versionSpec]) => ({
+      packageName,
+      versionSpec,
+      dependencyBaseDir: params.projectPath
+    }))
+  ].sort((left, right) => left.packageName.localeCompare(right.packageName));
   const seen = /* @__PURE__ */ new Set();
   const tarballs = [];
   while (pending.length > 0) {
-    const { packageName, versionSpec } = pending.shift();
+    const { packageName, versionSpec, dependencyBaseDir } = pending.shift();
     if (seen.has(packageName))
       continue;
     seen.add(packageName);
     const packTarget = npmPackTargetForDependency({
       packageName,
       versionSpec,
-      dependencyBaseDir: params.dependencyBaseDir
+      dependencyBaseDir
     });
-    const pack = await runCommand2("npm", ["pack", "--silent", "--pack-destination", params.tempDir, packTarget], { cwd: params.dependencyBaseDir });
+    const pack = await runCommand2("npm", ["pack", "--silent", "--pack-destination", params.tempDir, packTarget], { cwd: dependencyBaseDir });
     if (pack.code !== 0) {
       const details = [pack.stderr.trim(), pack.stdout.trim()].filter(Boolean).join("\n");
       throw new Error(`failed to pack openpond-agent-sdk dependency ${packageName}${details ? `:
@@ -20868,12 +20907,20 @@ ${details}` : ""}`);
       sizeBytes: contents.byteLength
     });
     for (const [dependencyName, dependencySpec] of Object.entries(recordStringMap(packedPackageJson.dependencies))) {
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+      pending.push({
+        packageName: dependencyName,
+        versionSpec: dependencySpec,
+        dependencyBaseDir
+      });
     }
     for (const [dependencyName, dependencySpec] of Object.entries(recordStringMap(packedPackageJson.optionalDependencies))) {
       if (!isSupportedSandboxOptionalDependency(dependencyName))
         continue;
-      pending.push({ packageName: dependencyName, versionSpec: dependencySpec });
+      pending.push({
+        packageName: dependencyName,
+        versionSpec: dependencySpec,
+        dependencyBaseDir
+      });
     }
   }
   return tarballs.sort((left, right) => left.packageName.localeCompare(right.packageName));
@@ -21008,8 +21055,8 @@ function rewriteAgentSdkPackageJsonForMaterialization(packageJson, dependencyTar
   if (Object.keys(overrides).length > 0) {
     rewritten.overrides = overrides;
   }
-  if (packageManager === "unknown") {
-    rewritten.packageManager = OPENPOND_PNPM_PACKAGE_MANAGER;
+  if (packageManager === "pnpm" || packageManager === "unknown") {
+    delete rewritten.packageManager;
   }
   for (const key of ["devDependencies", "peerDependencies"]) {
     const entries = recordCopy(rewritten[key]);
@@ -21484,18 +21531,18 @@ function readAgentSdkProjectPackageJson(projectPath) {
 }
 function buildAgentSdkCommandHints(packageJson, packageManager) {
   return {
-    inspect: buildAgentSdkCommandHint(packageJson, packageManager, "agent:inspect", "openpond-agent inspect --json"),
+    inspect: buildAgentSdkCommandHint(packageJson, packageManager, "agent:inspect", "openpond-agent inspect --json", true),
     build: buildAgentSdkCommandHint(packageJson, packageManager, "agent:build", "openpond-agent build"),
     validate: buildAgentSdkCommandHint(packageJson, packageManager, "agent:validate", "openpond-agent validate"),
     eval: buildAgentSdkCommandHint(packageJson, packageManager, "agent:eval", "openpond-agent eval")
   };
 }
-function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback) {
+function buildAgentSdkCommandHint(packageJson, packageManager, scriptName, fallback, jsonOutput = false) {
   const scripts = packageJson.scripts;
   const hasScript = scripts && typeof scripts === "object" && !Array.isArray(scripts) && typeof scripts[scriptName] === "string";
   if (!hasScript)
     return fallback;
-  return agentSdkRunScriptCommand(packageManager, scriptName);
+  return jsonOutput ? agentSdkRunJsonScriptCommand(packageManager, scriptName) : agentSdkRunScriptCommand(packageManager, scriptName);
 }
 function readOpenPondAgentSdkVersionSpec2(packageJson) {
   for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
@@ -25413,11 +25460,11 @@ async function communityRequestPayload(action, dependencies = {}) {
   const payload = await requestCommunityApi(request.path, request.init, dependencies);
   return schemaForAction(action).parse(payload);
 }
-async function requestCommunityApi(path62, init = {}, dependencies = {}) {
+async function requestCommunityApi(path63, init = {}, dependencies = {}) {
   const access5 = await resolveHostedApiAccess(dependencies);
   const headers = hostedApiAuthHeaders(access5.token);
   headers.set("Content-Type", "application/json");
-  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path62}`, {
+  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path63}`, {
     ...init,
     headers
   });
@@ -25586,11 +25633,11 @@ async function uploadCommunityAttachment(action, dependencies) {
     )
   );
 }
-function post(path62, body) {
-  return jsonRequest(path62, "POST", body);
+function post(path63, body) {
+  return jsonRequest(path63, "POST", body);
 }
-function jsonRequest(path62, method, body) {
-  return { path: path62, init: { method, body: JSON.stringify(body) } };
+function jsonRequest(path63, method, body) {
+  return { path: path63, init: { method, body: JSON.stringify(body) } };
 }
 
 // ../server/src/api/routes/community-routes.ts
@@ -25962,13 +26009,13 @@ function verifySignedWorkspaceImageRequest(requestUrl, token) {
   if (!appId || !rawPath || !expiresRaw || !signature) {
     return { ok: false, status: 401, error: "Signed asset URL is missing required claims." };
   }
-  const path62 = normalizeSignedWorkspaceImagePath(rawPath);
+  const path63 = normalizeSignedWorkspaceImagePath(rawPath);
   const expiresAt = Number(expiresRaw);
-  if (!path62 || !Number.isInteger(expiresAt)) {
+  if (!path63 || !Number.isInteger(expiresAt)) {
     return { ok: false, status: 401, error: "Signed asset URL is invalid." };
   }
   if (expiresAt < Date.now()) return { ok: false, status: 401, error: "Signed asset URL expired." };
-  const claims = { appId: appId.trim(), path: path62, expiresAt };
+  const claims = { appId: appId.trim(), path: path63, expiresAt };
   if (!safeSignatureEqual(signature, signWorkspaceImageClaims(claims, token))) {
     return { ok: false, status: 401, error: "Signed asset URL signature is invalid." };
   }
@@ -26062,9 +26109,9 @@ function requiredSearchParam(requestUrl, name) {
 }
 function normalizeSignedWorkspaceImagePath(value) {
   if (/^file:\/\//i.test(value) || /^\//.test(value) || /^[A-Za-z]:[\\/]/.test(value)) return null;
-  const path62 = normalizeWorkspaceFilePath(value);
-  if (!path62 || !workspaceImageContentType(path62)) return null;
-  return path62;
+  const path63 = normalizeWorkspaceFilePath(value);
+  if (!path63 || !workspaceImageContentType(path63)) return null;
+  return path63;
 }
 function normalizeSignedLocalImagePath(value) {
   const cleaned = normalizeSignedLocalAssetPath(value);
@@ -31602,7 +31649,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
     0,
     patchPaths.length - SANDBOX_SOURCE_READBACK_MAX_FILES
   );
-  for (const path62 of patchPaths.slice(0, SANDBOX_SOURCE_READBACK_MAX_FILES)) {
+  for (const path63 of patchPaths.slice(0, SANDBOX_SOURCE_READBACK_MAX_FILES)) {
     const remainingBytes = SANDBOX_SOURCE_READBACK_MAX_TOTAL_BYTES - totalReturnedBytes;
     if (remainingBytes <= 0) {
       skippedFiles += 1;
@@ -31617,7 +31664,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
         await sandboxRequestPayload({
           type: "download_file",
           sandboxId: input.sandboxId,
-          payload: { path: path62, maxBytes }
+          payload: { path: path63, maxBytes }
         })
       );
       const file = asRecord9(downloadPayload.file);
@@ -31625,7 +31672,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
       const returnedBytes = numberValue3(file.returnedBytes);
       const sizeBytes = numberValue3(file.totalSizeBytes) ?? numberValue3(file.sizeBytes);
       const entry = {
-        path: path62,
+        path: path63,
         sizeBytes,
         returnedBytes,
         isBinary,
@@ -31644,7 +31691,7 @@ async function captureSandboxSourceReadbackArtifact(input) {
       files.push(entry);
     } catch (error) {
       files.push({
-        path: path62,
+        path: path63,
         sizeBytes: null,
         returnedBytes: null,
         isBinary: false,
@@ -31846,10 +31893,10 @@ ${message2}` : message2;
     const file = asRecord9(payload.file);
     const contentsBase64 = typeof file.contentsBase64 === "string" ? file.contentsBase64 : "";
     const text3 = contentsBase64 ? Buffer11.from(contentsBase64, "base64").toString("utf8") : "";
-    const path62 = typeof file.path === "string" ? file.path : "file";
-    return text3 ? `${path62}
+    const path63 = typeof file.path === "string" ? file.path : "file";
+    return text3 ? `${path63}
 
-${text3}` : `Read ${path62}`;
+${text3}` : `Read ${path63}`;
   }
   if (action === "sandbox_exec") {
     const command = asRecord9(payload.command);
@@ -31886,31 +31933,31 @@ ${output}` : `Action ${actionName} ${status}`;
   }
   if (action === "sandbox_upload_file") {
     const file = asRecord9(payload.file);
-    const path62 = typeof file.path === "string" ? file.path : "file";
-    return appendPreservation(`Uploaded ${path62}.`);
+    const path63 = typeof file.path === "string" ? file.path : "file";
+    return appendPreservation(`Uploaded ${path63}.`);
   }
   if (action === "sandbox_write_file") {
     const file = asRecord9(payload.file);
-    const path62 = typeof file.path === "string" ? file.path : "file";
-    return appendPreservation(`Wrote ${path62}.`);
+    const path63 = typeof file.path === "string" ? file.path : "file";
+    return appendPreservation(`Wrote ${path63}.`);
   }
   if (action === "sandbox_edit_file") {
     const edit = asRecord9(payload.edit);
-    const path62 = typeof edit.path === "string" ? edit.path : "file";
+    const path63 = typeof edit.path === "string" ? edit.path : "file";
     const replacements = typeof edit.replacements === "number" ? edit.replacements : 0;
     return appendPreservation(
-      `Edited ${path62} with ${replacements} replacement${replacements === 1 ? "" : "s"}.`
+      `Edited ${path63} with ${replacements} replacement${replacements === 1 ? "" : "s"}.`
     );
   }
   if (action === "sandbox_delete_file") {
     const deleted = asRecord9(payload.deleted);
-    const path62 = typeof deleted.path === "string" ? deleted.path : "file";
-    return appendPreservation(`Deleted ${path62}.`);
+    const path63 = typeof deleted.path === "string" ? deleted.path : "file";
+    return appendPreservation(`Deleted ${path63}.`);
   }
   if (action === "sandbox_mkdir") {
     const directory = asRecord9(payload.directory);
-    const path62 = typeof directory.path === "string" ? directory.path : "directory";
-    return appendPreservation(`Created directory ${path62}.`);
+    const path63 = typeof directory.path === "string" ? directory.path : "directory";
+    return appendPreservation(`Created directory ${path63}.`);
   }
   if (action === "sandbox_move_file") {
     const moved = asRecord9(payload.moved);
@@ -36120,7 +36167,7 @@ async function openTailscaleApp() {
 
 // ../server/src/voice-transcription.ts
 import { Buffer as Buffer12 } from "node:buffer";
-import { spawn as spawn5 } from "node:child_process";
+import { execFile as execFile6, spawn as spawn5 } from "node:child_process";
 import { constants as fsConstants, promises as fs20 } from "node:fs";
 import os7 from "node:os";
 import path36 from "node:path";
@@ -36131,17 +36178,23 @@ var TRANSCRIPTION_TIMEOUT_MS = 12e4;
 var MODEL_MIN_BYTES = 10 * 1024 * 1024;
 var MODEL_MAX_BYTES = 2 * 1024 * 1024 * 1024;
 var PROCESS_OUTPUT_MAX_CHARS = 64 * 1024;
+var WHISPER_CPP_VERSION = "v1.9.2";
+var WHISPER_CPP_RELEASE_BASE = `https://github.com/ggml-org/whisper.cpp/releases/download/${WHISPER_CPP_VERSION}`;
+var BINARY_DIR_NAME = "voice-binaries";
+var BINARY_MIN_BYTES = 5e5;
+var BINARY_MAX_BYTES = 1e8;
 function createVoiceTranscriptionService(input) {
   const modelName = normalizedModelName(process.env.OPENPOND_WHISPER_MODEL_NAME);
   const modelPath = process.env.OPENPOND_WHISPER_MODEL?.trim() || path36.join(input.storeDir, "voice-models", `ggml-${modelName}.bin`);
   let modelDownload = null;
+  let binaryDownload = null;
   const closeController = new AbortController();
   const activeProcesses = /* @__PURE__ */ new Set();
   const activeTranscriptions = /* @__PURE__ */ new Set();
   let closing = false;
   let closePromise = null;
   async function status() {
-    const binaryPath = await resolveWhisperBinary();
+    const binaryPath = await ensureBinary();
     const modelReady = await fileExists4(modelPath);
     return {
       available: Boolean(binaryPath && (modelReady || canDownloadDefaultModel())),
@@ -36153,6 +36206,30 @@ function createVoiceTranscriptionService(input) {
       installHint: binaryPath ? null : whisperInstallHint()
     };
   }
+  async function ensureBinary() {
+    const resolved = await resolveWhisperBinary();
+    if (resolved) return resolved;
+    const assetInfo = getPlatformAssetInfo();
+    if (!assetInfo) return null;
+    const binaryDir = path36.join(input.storeDir, BINARY_DIR_NAME);
+    const binaryPath = path36.join(binaryDir, "whisper-cli");
+    if (await fileExists4(binaryPath)) {
+      const isExec = await executableExists2(binaryPath);
+      if (isExec) return binaryPath;
+    }
+    if (!binaryDownload) {
+      binaryDownload = downloadAndExtractWhisperBinary(
+        binaryDir,
+        binaryPath,
+        assetInfo,
+        input.logger,
+        closeController.signal
+      ).finally(() => {
+        binaryDownload = null;
+      });
+    }
+    return binaryDownload;
+  }
   async function ensureModel() {
     if (await fileExists4(modelPath)) return modelPath;
     if (process.env.OPENPOND_WHISPER_MODEL?.trim()) {
@@ -36182,7 +36259,7 @@ function createVoiceTranscriptionService(input) {
   }
   async function runTranscription(payload) {
     const request = parseVoiceTranscriptionRequest(payload);
-    const binaryPath = await resolveWhisperBinary();
+    const binaryPath = await ensureBinary();
     if (!binaryPath) throw new Error(whisperInstallHint());
     const audio = Buffer12.from(request.audioBase64, "base64");
     if (audio.byteLength === 0) throw new Error("No voice audio was recorded.");
@@ -36229,7 +36306,7 @@ function createVoiceTranscriptionService(input) {
     closing = true;
     closeController.abort();
     for (const child of activeProcesses) stopVoiceProcess(child);
-    closePromise = Promise.allSettled([...activeTranscriptions, ...modelDownload ? [modelDownload] : []]).then(() => {
+    closePromise = Promise.allSettled([...activeTranscriptions, ...modelDownload ? [modelDownload] : [], ...binaryDownload ? [binaryDownload] : []]).then(() => {
       if (activeProcesses.size > 0) {
         throw new Error(`Voice transcription leaked ${activeProcesses.size} process(es).`);
       }
@@ -36274,7 +36351,14 @@ async function runWhisper(input) {
       reject(new Error("Voice transcription service is closed."));
       return;
     }
-    const child = spawn5(input.binaryPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn5(input.binaryPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        // Ensure whisper-cli can find shared libraries bundled alongside it
+        LD_LIBRARY_PATH: [path36.dirname(input.binaryPath), process.env.LD_LIBRARY_PATH].filter(Boolean).join(":")
+      }
+    });
     input.activeProcesses.add(child);
     let stderr = "";
     let stdout = "";
@@ -36447,13 +36531,158 @@ async function fileExists4(filePath) {
   }
 }
 function whisperInstallHint() {
+  if (process.platform === "darwin" || process.platform === "linux") {
+    return "Could not auto-download whisper.cpp. Install it manually (e.g. `brew install whisper-cpp` on macOS or build from github.com/ggml-org/whisper.cpp), or set OPENPOND_WHISPER_CPP_BIN to the binary path.";
+  }
+  return "Local dictation requires whisper.cpp on macOS or Linux.";
+}
+function getPlatformAssetInfo() {
   if (process.platform === "darwin") {
-    return "Install whisper.cpp with `brew install whisper-cpp`, then try dictation again.";
+    return { assetName: "whisper-bin-x64.zip", archiveType: "zip" };
   }
   if (process.platform === "linux") {
-    return "Install whisper.cpp and make `whisper-cli` available on PATH, or set OPENPOND_WHISPER_CPP_BIN.";
+    if (process.arch === "arm64") {
+      return { assetName: "whisper-bin-ubuntu-arm64.tar.gz", archiveType: "tar.gz" };
+    }
+    if (process.arch === "x64") {
+      return { assetName: "whisper-bin-ubuntu-x64.tar.gz", archiveType: "tar.gz" };
+    }
+  }
+  return null;
+}
+async function downloadAndExtractWhisperBinary(binaryDir, finalBinaryPath, assetInfo, logger, signal) {
+  const url = `${WHISPER_CPP_RELEASE_BASE}/${assetInfo.assetName}`;
+  await fs20.mkdir(binaryDir, { recursive: true });
+  const tempArchive = path36.join(binaryDir, `whisper-archive.${process.pid}.${Date.now()}.tmp`);
+  const extractDir = path36.join(binaryDir, `extract-${process.pid}-${Date.now()}`);
+  logger.info("downloading whisper binary", { url, targetDir: binaryDir });
+  try {
+    const response = await fetch(url, { signal, redirect: "follow" });
+    if (!response.ok || !response.body) {
+      throw new Error(`Unable to download whisper binary: ${response.status} ${response.statusText}`.trim());
+    }
+    const sizeBytes = await streamBinaryResponseToFile({
+      response,
+      targetPath: tempArchive,
+      signal,
+      minBytes: BINARY_MIN_BYTES,
+      maxBytes: BINARY_MAX_BYTES
+    });
+    logger.info("whisper binary downloaded", { sizeBytes, extracting: true });
+    await fs20.mkdir(extractDir, { recursive: true });
+    if (assetInfo.archiveType === "tar.gz") {
+      await runExtractionCommand("tar", ["xzf", tempArchive, "-C", extractDir], signal);
+    } else {
+      await runExtractionCommand("unzip", ["-o", tempArchive, "-d", extractDir], signal);
+    }
+    const foundBinary = await findWhisperBinaryInDirectory(extractDir);
+    if (!foundBinary) {
+      throw new Error("whisper-cli binary not found in downloaded archive.");
+    }
+    const binaryParentDir = path36.dirname(foundBinary);
+    await fs20.mkdir(binaryDir, { recursive: true });
+    await moveAllFiles(binaryParentDir, binaryDir);
+    await fs20.chmod(finalBinaryPath, 493).catch(() => void 0);
+    logger.info("whisper binary installed", { binaryPath: finalBinaryPath });
+    return finalBinaryPath;
+  } finally {
+    await Promise.all([
+      fs20.rm(tempArchive, { force: true }),
+      fs20.rm(extractDir, { force: true, recursive: true })
+    ]);
+  }
+}
+async function streamBinaryResponseToFile(input) {
+  const declaredBytes = Number(input.response.headers.get("content-length"));
+  if (Number.isFinite(declaredBytes) && declaredBytes > input.maxBytes) {
+    throw new Error("Whisper binary download exceeds the configured byte limit.");
+  }
+  const reader = input.response.body?.getReader();
+  if (!reader) throw new Error("Whisper binary download did not return a response body.");
+  const file = await fs20.open(input.targetPath, "wx", 384);
+  let sizeBytes = 0;
+  try {
+    try {
+      while (true) {
+        if (input.signal.aborted) throw new Error("Whisper binary download was cancelled.");
+        const { done, value } = await reader.read();
+        if (done) break;
+        sizeBytes += value.byteLength;
+        if (sizeBytes > input.maxBytes) {
+          throw new Error("Whisper binary download exceeds the configured byte limit.");
+        }
+        await file.write(value);
+      }
+    } catch (error) {
+      await reader.cancel().catch(() => void 0);
+      throw error;
+    } finally {
+      await file.close();
+    }
+  } catch (error) {
+    await fs20.rm(input.targetPath, { force: true });
+    throw error;
+  }
+  if (sizeBytes < input.minBytes) {
+    await fs20.rm(input.targetPath, { force: true });
+    throw new Error("Downloaded whisper binary is incomplete.");
+  }
+  await fs20.chmod(input.targetPath, 384).catch(() => void 0);
+  return sizeBytes;
+}
+async function runExtractionCommand(command, args, signal) {
+  await new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Whisper binary extraction was cancelled."));
+      return;
+    }
+    const child = execFile6(command, args, { signal, maxBuffer: 10 * 1024 * 1024 }, (error) => {
+      if (error) {
+        reject(new Error(`Whisper binary extraction failed: ${error.message}`));
+        return;
+      }
+      resolve();
+    });
+    if (child.exitCode === null && child.signalCode === null && signal.aborted) {
+      child.kill("SIGTERM");
+    }
+  });
+}
+async function findWhisperBinaryInDirectory(directory) {
+  const entries = await fs20.readdir(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path36.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      const found = await findWhisperBinaryInDirectory(fullPath);
+      if (found) return found;
+    } else if (entry.isFile() && (entry.name === "whisper-cli" || entry.name === "whisper-cpp")) {
+      if (await executableExists2(fullPath)) return fullPath;
+    }
+  }
+  return null;
+}
+async function moveAllFiles(srcDir, destDir) {
+  const entries = await fs20.readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path36.join(srcDir, entry.name);
+    const destPath = path36.join(destDir, entry.name);
+    if (entry.isSymbolicLink()) {
+      const linkTarget = await fs20.readlink(srcPath);
+      await fs20.symlink(linkTarget, destPath).catch(() => void 0);
+      await fs20.rm(srcPath, { force: true }).catch(() => void 0);
+    } else if (entry.isDirectory()) {
+      await fs20.mkdir(destPath, { recursive: true });
+      await moveAllFiles(srcPath, destPath);
+      await fs20.rmdir(srcPath).catch(() => void 0);
+    } else if (entry.isFile()) {
+      await fs20.rename(srcPath, destPath);
+      if (entry.name === "whisper-cli" || entry.name === "whisper-cpp") {
+        await fs20.chmod(destPath, 493).catch(() => void 0);
+      } else if (entry.name.endsWith(".so") || entry.name.includes(".so.")) {
+        await fs20.chmod(destPath, 493).catch(() => void 0);
+      }
+    }
   }
-  return "Local dictation requires whisper.cpp on macOS or Linux.";
 }
 
 // ../server/src/openpond/browser-control-queue.ts
@@ -36705,7 +36934,7 @@ function headerValue2(value) {
 
 // ../server/src/agents/local-agent-scheduler.ts
 var import_cron_parser = __toESM(require_dist(), 1);
-import { execFile as execFile6 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { randomUUID as randomUUID14 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
 import path37 from "node:path";
@@ -36764,7 +36993,7 @@ function trimOutput2(value) {
 }
 
 // ../server/src/agents/local-agent-scheduler.ts
-var execFileAsync4 = promisify4(execFile6);
+var execFileAsync4 = promisify4(execFile7);
 var DEFAULT_TICK_MS = 15e3;
 var DEFAULT_RECONCILE_MS = 6e4;
 var INSPECT_TIMEOUT_MS = 6e4;
@@ -37530,11 +37759,11 @@ async function teamChatRequestPayload(action, dependencies = {}) {
   const payload = await requestTeamChatApi(request.path, request.init, dependencies);
   return schemaForAction2(action).parse(payload);
 }
-async function requestTeamChatApi(path62, init = {}, dependencies = {}) {
+async function requestTeamChatApi(path63, init = {}, dependencies = {}) {
   const access5 = await resolveHostedApiAccess(dependencies);
   const headers = hostedApiAuthHeaders(access5.token);
   headers.set("Content-Type", "application/json");
-  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path62}`, {
+  const response = await (dependencies.fetchImpl ?? fetch)(`${access5.apiBaseUrl}${path63}`, {
     ...init,
     headers
   });
@@ -37766,11 +37995,11 @@ async function uploadTeamChatAttachment(action, dependencies) {
     )
   );
 }
-function post2(path62, body) {
-  return jsonRequest2(path62, "POST", body);
+function post2(path63, body) {
+  return jsonRequest2(path63, "POST", body);
 }
-function jsonRequest2(path62, method, body) {
-  return { path: path62, init: { method, body: JSON.stringify(body) } };
+function jsonRequest2(path63, method, body) {
+  return { path: path63, init: { method, body: JSON.stringify(body) } };
 }
 
 // ../server/src/openpond/team-chat-executor.ts
@@ -40839,25 +41068,25 @@ var ManagedRlLocalRolloutExecutor = class {
     }
     throw lastError;
   }
-  async userRequest(path62, init) {
+  async userRequest(path63, init) {
     const headers = hostedApiAuthHeaders(this.input.access.token);
     headers.set("accept", "application/json");
     headers.set("content-type", "application/json");
     headers.set("x-openpond-team-id", this.input.access.teamId);
-    const requestUrl = `${this.input.access.apiBaseUrl}${path62}`;
+    const requestUrl = `${this.input.access.apiBaseUrl}${path63}`;
     return requestJson(this.input.fetchImpl ?? fetch, requestUrl, {
       ...init,
       headers: withVercelProtectionBypass(requestUrl, headers, this.input.env),
       signal: this.abortController.signal
     });
   }
-  policyRequest(path62, token, request, signal = this.abortController.signal) {
+  policyRequest(path63, token, request, signal = this.abortController.signal) {
     const headers = new Headers({
       accept: "application/json",
       authorization: `Bearer ${token}`,
       "content-type": "application/json"
     });
-    const requestUrl = `${this.input.access.apiBaseUrl}${path62}`;
+    const requestUrl = `${this.input.access.apiBaseUrl}${path63}`;
     return requestJson(
       this.input.fetchImpl ?? fetch,
       requestUrl,
@@ -41065,7 +41294,7 @@ function managedRunEvidence(detail, syncedAt) {
   );
   const finalGroup = [...detail.rolloutGroups].filter((group) => group.rewardMean != null).sort((left, right) => left.groupIndex - right.groupIndex).at(-1);
   const lease = [...detail.gpuLeases].sort((left, right) => left.id.localeCompare(right.id)).at(-1);
-  const checkpoint = [...detail.checkpoints].filter((candidate2) => candidate2.state === "ready").sort(
+  const checkpoint2 = [...detail.checkpoints].filter((candidate2) => candidate2.state === "ready").sort(
     (left, right) => Number(right.isFinal) - Number(left.isFinal) || Number(right.isLatest) - Number(left.isLatest) || right.policyVersion - left.policyVersion
   ).at(0);
   return ManagedTrainingRunEvidenceSchema.parse({
@@ -41102,11 +41331,11 @@ function managedRunEvidence(detail, syncedAt) {
     cost: {
       totalUsd: decimal(detail.job.accruedSpendUsd)
     },
-    checkpoint: checkpoint ? {
-      id: checkpoint.id,
-      policyVersion: checkpoint.policyVersion,
-      sha256: checkpoint.adapterSha256 ?? null,
-      sizeBytes: checkpoint.sizeBytes ?? null
+    checkpoint: checkpoint2 ? {
+      id: checkpoint2.id,
+      policyVersion: checkpoint2.policyVersion,
+      sha256: checkpoint2.adapterSha256 ?? null,
+      sizeBytes: checkpoint2.sizeBytes ?? null
     } : null,
     evaluations: detail.evaluations.map((evaluation) => ({
       kind: evaluation.kind,
@@ -41211,19 +41440,19 @@ function managedTrainingEvents(input) {
       }
     });
   }
-  for (const checkpoint of input.detail.checkpoints.filter(
+  for (const checkpoint2 of input.detail.checkpoints.filter(
     (candidate2) => candidate2.state === "ready"
   )) {
     candidates.push({
-      identity: `checkpoint:${checkpoint.id}`,
-      timestamp: checkpoint.readyAt ?? checkpoint.updatedAt,
+      identity: `checkpoint:${checkpoint2.id}`,
+      timestamp: checkpoint2.readyAt ?? checkpoint2.updatedAt,
       type: "checkpoint",
       payload: {
-        checkpointId: checkpoint.id,
-        policyVersion: checkpoint.policyVersion,
-        sha256: checkpoint.adapterSha256 ?? null,
-        sizeBytes: checkpoint.sizeBytes ?? null,
-        final: checkpoint.isFinal
+        checkpointId: checkpoint2.id,
+        policyVersion: checkpoint2.policyVersion,
+        sha256: checkpoint2.adapterSha256 ?? null,
+        sizeBytes: checkpoint2.sizeBytes ?? null,
+        final: checkpoint2.isFinal
       }
     });
   }
@@ -41237,7 +41466,7 @@ function managedTrainingEvents(input) {
       payload: {
         state: input.detail.job.state,
         artifactCount: input.detail.checkpoints.filter(
-          (checkpoint) => checkpoint.state === "ready"
+          (checkpoint2) => checkpoint2.state === "ready"
         ).length,
         optimizerUpdates: input.detail.trainingSteps.filter(
           (step) => step.state === "committed"
@@ -46740,8 +46969,8 @@ ${split.split}`) ?? {
     inspectedAt: (/* @__PURE__ */ new Date()).toISOString(),
     metadata: {
       sourceSchemaHash: contentHash(
-        columns.map(({ path: path62, logicalType: logicalType2, nullable }) => ({
-          path: path62,
+        columns.map(({ path: path63, logicalType: logicalType2, nullable }) => ({
+          path: path63,
           logicalType: logicalType2,
           nullable
         }))
@@ -46790,10 +47019,10 @@ function parquetSourceFile(value, repositoryId, revision) {
   if (item?.dataset !== repositoryId || typeof item.config !== "string" || typeof item.split !== "string" || typeof item.filename !== "string" || !item.filename.toLowerCase().endsWith(".parquet")) {
     return [];
   }
-  const path62 = [item.config, item.split, item.filename].flatMap((segment) => segment.split("/")).map((segment) => segment.trim()).filter(Boolean).join("/");
-  if (!path62 || path62.split("/").includes("..")) return [];
+  const path63 = [item.config, item.split, item.filename].flatMap((segment) => segment.split("/")).map((segment) => segment.trim()).filter(Boolean).join("/");
+  if (!path63 || path63.split("/").includes("..")) return [];
   return [{
-    path: path62,
+    path: path63,
     configuration: item.config,
     split: item.split,
     revision,
@@ -46866,8 +47095,8 @@ function sourceColumns(features, rows) {
       });
     }
   }
-  return [...paths.entries()].map(([path62, value]) => ({
-    path: path62,
+  return [...paths.entries()].map(([path63, value]) => ({
+    path: path63,
     logicalType: value.type,
     nullable: value.nullable,
     sampleValues: value.values.slice(0, 5)
@@ -46885,21 +47114,21 @@ function flattenRecord(value, prefix, paths, rows) {
     return;
   }
   for (const [key, child] of Object.entries(value)) {
-    const path62 = prefix ? `${prefix}.${key}` : key;
+    const path63 = prefix ? `${prefix}.${key}` : key;
     if (child && typeof child === "object" && !Array.isArray(child)) {
-      flattenRecord(child, path62, paths, rows);
+      flattenRecord(child, path63, paths, rows);
     } else {
-      paths.set(path62, {
+      paths.set(path63, {
         type: logicalType(child),
-        nullable: rows.some((row) => nestedValue(row, path62) == null),
-        values: rows.map((row) => nestedValue(row, path62)).filter((item) => item != null)
+        nullable: rows.some((row) => nestedValue(row, path63) == null),
+        values: rows.map((row) => nestedValue(row, path63)).filter((item) => item != null)
       });
     }
   }
 }
-function nestedValue(value, path62) {
+function nestedValue(value, path63) {
   let current = value;
-  for (const segment of path62.split(".")) {
+  for (const segment of path63.split(".")) {
     const record11 = asRecord15(current);
     if (!record11) return null;
     current = record11[segment];
@@ -47225,7 +47454,7 @@ function graderFixtures(taskId, expected, split) {
     output: fixture.output,
     infrastructureError: fixture.infrastructureError,
     expectedPassed: fixture.expectedPassed,
-    expectedRewardEligible: fixture.expectedPassed,
+    expectedRewardEligible: fixture.label !== "infrastructure_failure",
     metadata: {
       artifactBacked: true,
       artifactSplit: split
@@ -48089,6 +48318,8 @@ function errorMessage4(error) {
 }
 
 // ../server/src/training/harness-refiner-benchmark-protocol.ts
+var HARNESS_REFINER_BENCHMARK_MAX_INVOCATIONS_PER_TASK = 2;
+var HARNESS_REFINER_BENCHMARK_REFINER_TIMEOUT_MS = 18e4;
 function createHarnessRefinerExecutionPlan(input) {
   if (input.seeds.length !== 1 || input.repetitions !== 1) {
     throw new Error(
@@ -48101,8 +48332,8 @@ function createHarnessRefinerExecutionPlan(input) {
   const adaptation = taskIdsForSplit(input.taskset, benchmark.adaptationSplit);
   const multiplier = input.seeds.length * input.repetitions;
   return [
-    planItem("baseline", benchmark.evaluationSplit, heldOut, multiplier),
     planItem("adaptation", benchmark.adaptationSplit, adaptation, multiplier),
+    planItem("baseline", benchmark.evaluationSplit, heldOut, multiplier),
     planItem("candidate_adaptation", benchmark.adaptationSplit, adaptation, multiplier),
     planItem("candidate", benchmark.evaluationSplit, heldOut, multiplier)
   ];
@@ -48291,7 +48522,8 @@ function createResultManifest(input) {
     evidenceSnapshot: input.evidenceSnapshot,
     lineage: input.lineage,
     publicationPolicy: {
-      judgeCalibration: "required_pass",
+      primaryReward: "deterministic_output_contract",
+      supplementaryJudge: "not_executed_uncalibrated",
       diagnosticPasses: 1,
       confirmationPasses: 1,
       uncertainty: "paired_per_case_descriptive"
@@ -48433,7 +48665,9 @@ function completedStage(input) {
       attempt: result.attempt,
       grade: result.grade,
       artifacts: result.artifacts,
-      receiptContentHash: result.portable.receipt.contentHash
+      receiptContentHash: result.portable.receipt.contentHash,
+      artifactManifest: result.portable.artifactManifest,
+      rewardReceipt: result.portable.rewardReceipt
     }))
   };
 }
@@ -48461,7 +48695,9 @@ async function combineRetriedBenchmarkStage(input) {
         attempt: result.attempt,
         grade: result.grade,
         artifacts: result.artifacts,
-        receiptContentHash: result.portable.receipt.contentHash
+        receiptContentHash: result.portable.receipt.contentHash,
+        artifactManifest: result.portable.artifactManifest,
+        rewardReceipt: result.portable.rewardReceipt
       },
       receipt: result.portable.receipt
     }
@@ -48560,7 +48796,8 @@ async function loadCompletedBenchmarkStage(input) {
       attempt,
       grade,
       artifacts: await input.store.listTaskAttemptArtifacts({ attemptId: attempt.id }),
-      receiptContentHash: portableReceiptContentHash(attempt)
+      receiptContentHash: portableReceiptContentHash(attempt),
+      ...portableCanonicalReceipts(attempt)
     };
   }));
   return { run, attempts: evidence };
@@ -48577,15 +48814,19 @@ async function loadBenchmarkAttemptEvidenceByIds(input) {
       `Sequential adaptation evidence has ${selected.length}/${wanted.size} attempts.`
     );
   }
+  const selectedById = new Map(selected.map((attempt) => [attempt.id, attempt]));
   const gradesByAttempt = new Map(grades.map((grade) => [grade.attemptId, grade]));
-  return Promise.all(selected.map(async (attempt) => {
+  return Promise.all(input.attemptIds.map(async (attemptId) => {
+    const attempt = selectedById.get(attemptId);
+    if (!attempt) throw new Error(`Sequential adaptation attempt ${attemptId} is unavailable.`);
     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)
+      receiptContentHash: portableReceiptContentHash(attempt),
+      ...portableCanonicalReceipts(attempt)
     };
   }));
 }
@@ -48602,6 +48843,25 @@ function portableReceiptContentHash(attempt) {
   }
   return hash3;
 }
+function portableCanonicalReceipts(attempt) {
+  try {
+    const artifactManifest = ArtifactManifestSchema.parse(
+      attempt.metadata.portableArtifactManifest
+    );
+    const rewardReceipt = RewardReceiptSchema.parse(
+      attempt.metadata.portableRewardReceipt
+    );
+    if (!verifyArtifactManifest(artifactManifest) || !verifyRewardReceipt(rewardReceipt)) {
+      throw new Error("Canonical reward evidence failed content-hash verification.");
+    }
+    return { artifactManifest, rewardReceipt };
+  } catch (error) {
+    throw new Error(
+      `Attempt ${attempt.id} has no valid durable canonical reward evidence.`,
+      { cause: error }
+    );
+  }
+}
 function objectRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -48929,58 +49189,6 @@ function frozenToolEvidence(snapshot, mode, cohort) {
     }
   };
 }
-async function benchmarkLineage(input) {
-  const [outcomes, validations, applyReceipts] = await Promise.all([
-    input.store.listHarnessImprovementArtifacts(
-      input.workspaceId,
-      "refiner_outcome",
-      1e3
-    ),
-    input.store.listHarnessImprovementArtifacts(
-      input.workspaceId,
-      "targeted_validation",
-      1e4
-    ),
-    input.store.listHarnessImprovementArtifacts(
-      input.workspaceId,
-      "apply_receipt",
-      1e3
-    )
-  ]);
-  const adaptationEvidenceHash = contentHash(input.adaptationAttempts.map((result) => ({
-    attempt: result.attempt.id,
-    receipt: result.receiptContentHash,
-    grade: contentHash(result.grade)
-  })));
-  const proposalResults = input.refinerResults.filter((result) => result.proposal);
-  const requiredValidationsPassed = proposalResults.every(
-    (result) => result.proposal.validationPlan.filter((plan) => plan.required).every((plan) => result.validations.some(
-      (validation) => validation.validationId === plan.id && validation.status === "passed"
-    ))
-  );
-  const proposalHashes = new Set(
-    proposalResults.map((result) => result.proposal.contentHash)
-  );
-  const appliedProposalHashes = new Set(applyReceipts.flatMap((artifact) => {
-    const proposal = "proposal" in artifact ? artifact.proposal : null;
-    return proposal && typeof proposal === "object" && "contentHash" in proposal ? [String(proposal.contentHash)] : [];
-  }));
-  const everyProposalHasReceipt = [...proposalHashes].every(
-    (hash3) => appliedProposalHashes.has(hash3)
-  );
-  return {
-    adaptationEvidenceHash,
-    refinerInputHash: input.refinerInputHash,
-    refinerOutcomeHash: contentHash(outcomes),
-    validationHash: contentHash(validations),
-    applyReceiptHash: contentHash(applyReceipts),
-    candidateRelease: {
-      id: input.candidateRelease.id,
-      contentHash: input.candidateRelease.contentHash
-    },
-    valid: outcomes.length === input.refinerResults.length && requiredValidationsPassed && everyProposalHasReceipt
-  };
-}
 function comparisonInvalidReasons(input) {
   const reasons = [];
   for (const [label, run] of [
@@ -49064,7 +49272,7 @@ async function resumeHarnessRefinerComparison(input) {
     tasksetId: taskset.id,
     attemptIds: sequentialAttemptIds
   });
-  if (priorManifest.tasksetRelease.contentHash !== taskset.benchmark?.releaseHash || priorManifest.harness.baseline.contentHash !== baseline.run.harnessRelease.contentHash) {
+  if (priorManifest.tasksetRelease.id !== baseline.run.tasksetRelease.id || priorManifest.tasksetRelease.contentHash !== baseline.run.tasksetRelease.contentHash || priorManifest.harness.baseline.contentHash !== baseline.run.harnessRelease.contentHash) {
     throw new Error("Comparison recovery manifest drifted from the admitted benchmark.");
   }
   const currentReleaseRef = workspace.currentChannel.release;
@@ -49310,7 +49518,106 @@ async function resumeHarnessRefinerComparison(input) {
   }));
 }
 
+// ../server/src/training/harness-refiner-benchmark-lineage.ts
+async function benchmarkLineage(input) {
+  const [outcomes, rawProposals, rawValidations, applyReceipts] = await Promise.all([
+    input.store.listHarnessImprovementArtifacts(
+      input.workspaceId,
+      "refiner_outcome",
+      1e3
+    ),
+    input.store.listHarnessImprovementArtifacts(
+      input.workspaceId,
+      "proposal",
+      1e3
+    ),
+    input.store.listHarnessImprovementArtifacts(
+      input.workspaceId,
+      "targeted_validation",
+      1e4
+    ),
+    input.store.listHarnessImprovementArtifacts(
+      input.workspaceId,
+      "apply_receipt",
+      1e3
+    )
+  ]);
+  const proposals = rawProposals;
+  const validations = rawValidations;
+  const adaptationEvidenceHash = contentHash(input.adaptationAttempts.map((result) => ({
+    attempt: result.attempt.id,
+    receipt: result.receiptContentHash,
+    grade: contentHash(result.grade)
+  })));
+  const requiredValidationsPassed = proposals.every(
+    (proposal) => proposal.validationPlan.filter((plan) => plan.required).every((plan) => validations.some(
+      (validation) => validation.validationId === plan.id && validation.status === "passed"
+    ))
+  );
+  const proposalHashes = new Set(
+    proposals.map((proposal) => proposal.contentHash)
+  );
+  const appliedProposalHashes = new Set(applyReceipts.flatMap((artifact) => {
+    const proposal = "proposal" in artifact ? artifact.proposal : null;
+    return proposal && typeof proposal === "object" && "contentHash" in proposal ? [String(proposal.contentHash)] : [];
+  }));
+  const everyProposalHasReceipt = [...proposalHashes].every(
+    (hash3) => appliedProposalHashes.has(hash3)
+  );
+  return {
+    adaptationEvidenceHash,
+    refinerInputHash: input.refinerInputHash,
+    refinerOutcomeHash: contentHash(outcomes),
+    validationHash: contentHash(validations),
+    applyReceiptHash: contentHash(applyReceipts),
+    candidateRelease: {
+      id: input.candidateRelease.id,
+      contentHash: input.candidateRelease.contentHash
+    },
+    valid: outcomes.length === input.completedSteps.filter((step) => step.outcome).length && requiredValidationsPassed && everyProposalHasReceipt
+  };
+}
+
 // ../server/src/training/harness-refiner-benchmark-refiner-stage.ts
+var MAX_REFINER_ARTIFACT_MANIFEST_ENTRIES = 100;
+var BenchmarkRefinerInvocationError = class extends Error {
+  constructor(message2, details, options) {
+    super(message2, options);
+    this.details = details;
+  }
+  details;
+  name = "BenchmarkRefinerInvocationError";
+};
+function benchmarkRefinerRewardPacket(input) {
+  const manifestEntries = input.artifactManifest.entries.slice(
+    0,
+    MAX_REFINER_ARTIFACT_MANIFEST_ENTRIES
+  );
+  return {
+    schemaVersion: "openpond.refinerRewardPacket.v1",
+    attemptRef: input.rewardReceipt.attemptRef,
+    artifactManifest: {
+      ref: {
+        id: input.artifactManifest.id,
+        contentHash: input.artifactManifest.contentHash
+      },
+      entries: manifestEntries,
+      entryCount: input.artifactManifest.entries.length,
+      truncated: manifestEntries.length < input.artifactManifest.entries.length
+    },
+    rewardReceipt: input.rewardReceipt,
+    attempt: {
+      status: input.rewardReceipt.outcomeClass,
+      infrastructureError: input.attempt.infrastructureError,
+      outputPresent: typeof input.attempt.output.text === "string" && input.attempt.output.text.trim().length > 0,
+      artifactCount: input.artifactCount,
+      runtimeEventCount: input.attempt.runtimeEventRefs.length,
+      modelRequestCount: Array.isArray(input.attempt.metadata.usage) ? input.attempt.metadata.usage.length : input.attempt.metadata.usage ? 1 : 0,
+      latencyMs: input.attempt.latencyMs,
+      usage: attemptUsageSummary(input.attempt.metadata.usage)
+    }
+  };
+}
 async function materializeBenchmarkRefinerBoundary(input) {
   const attempt = input.result.attempt;
   const sessionId = stringMetadata2(attempt.metadata, "sessionId");
@@ -49361,7 +49668,17 @@ async function materializeBenchmarkRefinerBoundary(input) {
       }
     }
   });
-  if (!await input.store.getTurn(turn.id)) await input.store.insertTurn(turn);
+  const existingTurn = await input.store.getTurn(turn.id);
+  if (!existingTurn) {
+    await input.store.insertTurn(turn);
+  } else {
+    await input.store.updateTurn(turn.id, (current) => TurnSchema.parse({
+      ...current,
+      modelRef: turn.modelRef,
+      metadata: { ...current.metadata, ...turn.metadata },
+      harnessSnapshot: turn.harnessSnapshot
+    }));
+  }
   const assistantOutput = attempt.output.text;
   if (typeof assistantOutput === "string" && assistantOutput.trim()) {
     await input.store.appendRuntimeEvent(event({
@@ -49374,26 +49691,14 @@ async function materializeBenchmarkRefinerBoundary(input) {
       output: assistantOutput
     }));
   }
-  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)
-    }
+  const rewardPacket = benchmarkRefinerRewardPacket({
+    attempt,
+    artifactManifest: input.result.artifactManifest,
+    rewardReceipt: input.result.rewardReceipt,
+    artifactCount: input.result.artifacts.length
   });
+  const rewardEvidence = JSON.stringify(rewardPacket);
+  const rewardPassed = input.result.rewardReceipt.status === "scored" && input.result.rewardReceipt.passed;
   await input.store.appendRuntimeEvent(event({
     sessionId: session.id,
     turnId: turn.id,
@@ -49401,14 +49706,23 @@ async function materializeBenchmarkRefinerBoundary(input) {
     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,
+    status: rewardPassed ? "completed" : "failed",
+    output: rewardEvidence,
+    error: rewardPassed ? void 0 : rewardEvidence,
     data: {
       result: {
-        output: gradeEvidence,
-        passed: input.result.grade.passed,
-        score: input.result.grade.score
+        output: rewardEvidence,
+        passed: rewardPassed,
+        status: input.result.rewardReceipt.status,
+        reward: input.result.rewardReceipt.reward,
+        rewardReceiptRef: {
+          id: input.result.rewardReceipt.id,
+          contentHash: input.result.rewardReceipt.contentHash
+        },
+        artifactManifestRef: {
+          id: input.result.artifactManifest.id,
+          contentHash: input.result.artifactManifest.contentHash
+        }
       }
     }
   }));
@@ -49419,7 +49733,12 @@ async function runBenchmarkRefinerAfterAttempt(input) {
   if (!boundary) {
     throw new Error(`Adaptation attempt ${input.result.attempt.id} has no Refiner boundary.`);
   }
-  const detection = await recordLocalHarnessImprovementBoundary({
+  const existingTrigger = await queuedTriggerForTurn({
+    store: input.store,
+    workspaceId: input.runtime.workspace.id,
+    turnId: boundary.turn.id
+  });
+  const detection = existingTrigger ? { observations: [], trigger: existingTrigger } : await recordLocalHarnessImprovementBoundary({
     store: input.store,
     session: boundary.session,
     turn: boundary.turn,
@@ -49435,37 +49754,274 @@ async function runBenchmarkRefinerAfterAttempt(input) {
   input.budget.assertAvailable(`Refiner turn ${detection.trigger.id}`);
   const usage = emptyUsageCategory();
   let providerInvoked = false;
+  let providerRequestCount = 0;
+  let requestsWithAuthoritativeCost = 0;
+  let estimatedCostUsd = 0;
+  const startedAt = input.now();
+  let result = null;
+  let failure = null;
   try {
-    const result = await runLocalHarnessRefinerWorker({
+    result = await runLocalHarnessRefinerWorker({
       store: input.store,
       storeDir: input.storeDir,
       trigger: detection.trigger,
       stream: async function* (streamInput) {
         providerInvoked = true;
-        for await (const delta of input.refinerStream({
-          ...streamInput,
-          model: input.model,
-          pricing: input.admittedPricing
-        })) {
-          if (delta.usage !== void 0) addUsage(usage, delta.usage, delta.costUsd);
-          if (delta.text) yield { text: delta.text };
+        providerRequestCount += 1;
+        let requestHadAuthoritativeCost = false;
+        estimatedCostUsd += conservativeRefinerRequestCost(
+          streamInput.messages,
+          input.admittedPricing
+        );
+        try {
+          for await (const delta of input.refinerStream({
+            ...streamInput,
+            model: input.model,
+            pricing: input.admittedPricing
+          })) {
+            if (typeof delta.costUsd === "number") requestHadAuthoritativeCost = true;
+            if (delta.usage !== void 0 || delta.costUsd !== void 0) {
+              addUsage(usage, delta.usage, delta.costUsd);
+            }
+            if (delta.text) yield { text: delta.text };
+          }
+        } finally {
+          if (requestHadAuthoritativeCost) requestsWithAuthoritativeCost += 1;
         }
       },
       signal: input.signal,
+      timeoutMs: HARNESS_REFINER_BENCHMARK_REFINER_TIMEOUT_MS,
       now: input.now
     });
-    return { detection, result };
-  } finally {
-    if (providerInvoked) {
-      input.budget.charge(usage.costUsd, "Refiner");
+  } catch (error) {
+    failure = error;
+  }
+  const completedAt = input.now();
+  const costBasis = providerInvoked ? usage.costUsd !== null && requestsWithAuthoritativeCost === providerRequestCount ? "authoritative" : "estimated" : "none";
+  const chargedCost = costBasis === "authoritative" ? usage.costUsd : costBasis === "estimated" ? Math.max(usage.costUsd ?? 0, estimatedCostUsd) : null;
+  if (providerInvoked) {
+    try {
+      input.budget.charge(chargedCost, "Refiner");
       await checkpointRefinerUsage(
         input.store,
         input.modelRun.id,
         usage,
         input.budget.observedSpendUsd
       );
+    } catch (error) {
+      failure ??= error;
+    }
+  }
+  if (failure) {
+    const message2 = failure instanceof Error ? failure.message : String(failure);
+    const failureKind = benchmarkRefinerFailureKind(failure, input.signal);
+    const retryable = failureKind !== "cancelled";
+    await input.store.appendRuntimeEvent(event({
+      sessionId: boundary.session.id,
+      turnId: boundary.turn.id,
+      name: "harness.refiner.failed",
+      source: "server",
+      appId: boundary.session.appId,
+      status: "failed",
+      output: message2,
+      data: {
+        trigger: {
+          id: detection.trigger.id,
+          contentHash: detection.trigger.contentHash
+        },
+        benchmark: true,
+        modelRunId: input.modelRun.id,
+        attemptId: input.result.attempt.id,
+        failureKind,
+        retryable,
+        costBasis,
+        estimatedCostUsd: costBasis === "estimated" ? estimatedCostUsd : null
+      }
+    })).catch(() => void 0);
+    throw new BenchmarkRefinerInvocationError(message2, {
+      trigger: detection.trigger,
+      usage,
+      costBasis,
+      estimatedCostUsd: costBasis === "estimated" ? estimatedCostUsd : null,
+      failureKind,
+      retryable,
+      startedAt,
+      completedAt
+    }, { cause: failure });
+  }
+  return {
+    detection,
+    result,
+    invocation: {
+      usage,
+      costBasis,
+      estimatedCostUsd: costBasis === "estimated" ? estimatedCostUsd : null,
+      startedAt,
+      completedAt
     }
+  };
+}
+async function queuedTriggerForTurn(input) {
+  const triggers = await input.store.listHarnessImprovementArtifacts(
+    input.workspaceId,
+    "trigger_decision",
+    1e3
+  );
+  return triggers.find(
+    (trigger) => trigger.turnId === input.turnId && trigger.decision === "queue_refiner"
+  ) ?? null;
+}
+function conservativeRefinerRequestCost(messages, pricing) {
+  const inputCharacters = messages.reduce(
+    (total, message2) => total + message2.content.length,
+    0
+  );
+  const estimatedInputTokens = Math.ceil(inputCharacters / 3);
+  return (estimatedInputTokens * pricing.inputUsdPerMillionTokens + DEFAULT_REFINER_MAX_OUTPUT_TOKENS * pricing.outputUsdPerMillionTokens) / 1e6;
+}
+function benchmarkRefinerFailureKind(error, signal) {
+  if (signal.aborted) return "cancelled";
+  const message2 = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message2)) return "timeout";
+  if (/invalid structured output|response limit|JSON/i.test(message2)) {
+    return "invalid_output";
   }
+  if (/provider|rate limit|billing|signed out|network|fetch/i.test(message2)) {
+    return "provider_failure";
+  }
+  return "unknown";
+}
+
+// ../server/src/training/harness-refiner-benchmark-sequential-checkpoint.ts
+import { promises as fs24 } from "node:fs";
+import path57 from "node:path";
+function createBenchmarkRefinerInvocationReceipt(input) {
+  const core = {
+    schemaVersion: "openpond.benchmarkRefinerInvocation.v1",
+    id: `benchmark-refiner-invocation-${contentHash({
+      taskId: input.taskId,
+      attemptId: input.attemptId,
+      invocationOrdinal: input.invocationOrdinal,
+      trigger: input.trigger,
+      status: input.status,
+      startedAt: input.startedAt
+    }).slice(0, 24)}`,
+    ...input
+  };
+  return { ...core, contentHash: contentHash(core) };
+}
+async function loadSequentialAdaptationCheckpoint(input) {
+  const filePath = checkpointPath(input.storeDir, input.modelRunId);
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs24.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+  return parseCheckpoint(parsed, input.modelRunId);
+}
+async function initializeSequentialAdaptationCheckpoint(input) {
+  const existing = await loadSequentialAdaptationCheckpoint(input);
+  if (existing) {
+    if (!sameRef(existing.initialHarness, input.initialHarness)) {
+      throw new Error("Sequential adaptation checkpoint changed its initial Harness release.");
+    }
+    return existing;
+  }
+  return writeSequentialAdaptationCheckpoint({
+    storeDir: input.storeDir,
+    checkpoint: checkpoint({
+      modelRunId: input.modelRunId,
+      initialHarness: input.initialHarness,
+      steps: [],
+      invocations: [],
+      updatedAt: input.now
+    })
+  });
+}
+async function appendSequentialAdaptationInvocation(input) {
+  const current = await initializeSequentialAdaptationCheckpoint({
+    storeDir: input.storeDir,
+    modelRunId: input.modelRunId,
+    initialHarness: input.initialHarness,
+    now: input.now
+  });
+  if (!input.invocation && !input.step) {
+    throw new Error("A sequential checkpoint append requires an invocation or step.");
+  }
+  const invocations = input.invocation ? [
+    ...current.invocations.filter((item) => item.id !== input.invocation.id),
+    input.invocation
+  ] : current.invocations;
+  const steps = input.step ? [
+    ...current.steps.filter((item) => item.taskId !== input.step.taskId),
+    input.step
+  ].sort((left, right) => left.ordinal - right.ordinal) : current.steps;
+  return writeSequentialAdaptationCheckpoint({
+    storeDir: input.storeDir,
+    checkpoint: checkpoint({
+      modelRunId: current.modelRunId,
+      initialHarness: current.initialHarness,
+      steps,
+      invocations,
+      updatedAt: input.now
+    })
+  });
+}
+function checkpoint(input) {
+  const core = {
+    schemaVersion: "openpond.sequentialAdaptationCheckpoint.v1",
+    ...input
+  };
+  return { ...core, contentHash: contentHash(core) };
+}
+async function writeSequentialAdaptationCheckpoint(input) {
+  const filePath = checkpointPath(input.storeDir, input.checkpoint.modelRunId);
+  const directory = path57.dirname(filePath);
+  await fs24.mkdir(directory, { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.tmp`;
+  await fs24.writeFile(
+    temporaryPath,
+    `${JSON.stringify(input.checkpoint, null, 2)}
+`,
+    "utf8"
+  );
+  await fs24.rename(temporaryPath, filePath);
+  return input.checkpoint;
+}
+function parseCheckpoint(value, modelRunId) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Sequential adaptation checkpoint is malformed.");
+  }
+  const record11 = value;
+  if (record11.schemaVersion !== "openpond.sequentialAdaptationCheckpoint.v1" || record11.modelRunId !== modelRunId || !record11.initialHarness || !Array.isArray(record11.steps) || !Array.isArray(record11.invocations) || typeof record11.updatedAt !== "string" || typeof record11.contentHash !== "string") {
+    throw new Error("Sequential adaptation checkpoint is malformed.");
+  }
+  const { contentHash: admittedHash, ...core } = record11;
+  if (contentHash(core) !== admittedHash) {
+    throw new Error("Sequential adaptation checkpoint failed content-hash validation.");
+  }
+  const parsed = record11;
+  for (const invocation of parsed.invocations) {
+    const { contentHash: invocationHash, ...invocationCore } = invocation;
+    if (contentHash(invocationCore) !== invocationHash) {
+      throw new Error(`Refiner invocation ${invocation.id} failed content-hash validation.`);
+    }
+  }
+  return parsed;
+}
+function checkpointPath(storeDir, modelRunId) {
+  return path57.join(
+    storeDir,
+    "training",
+    "harness-refiner-benchmarks",
+    modelRunId,
+    "sequential-adaptation.json"
+  );
+}
+function sameRef(left, right) {
+  return left.id === right.id && left.contentHash === right.contentHash;
 }
 
 // ../server/src/training/harness-refiner-benchmark-sequential-stage.ts
@@ -49473,58 +50029,143 @@ async function runSequentialHarnessAdaptation(input) {
   const runRefinerAfterAttempt = input.adapters?.runRefinerAfterAttempt ?? runBenchmarkRefinerAfterAttempt;
   const loadRuntimeFromRelease = input.adapters?.loadRuntimeFromRelease ?? loadLocalHarnessRuntimeFromRelease;
   const buildLineage = input.adapters?.buildLineage ?? benchmarkLineage;
+  const loadAttemptEvidenceByIds = input.adapters?.loadAttemptEvidenceByIds ?? loadBenchmarkAttemptEvidenceByIds;
   await input.store.setHarnessBackgroundReviewSettings({
     workspaceId: input.initialRuntime.workspace.id,
     enabled: true,
     updatedAt: input.now()
   });
-  let runtime = input.initialRuntime;
-  const attempts = [];
+  const initialHarness = {
+    id: input.initialRuntime.release.harnessRelease.id,
+    contentHash: input.initialRuntime.release.harnessRelease.contentHash
+  };
+  let checkpoint2 = await initializeSequentialAdaptationCheckpoint({
+    storeDir: input.storeDir,
+    modelRunId: input.modelRun.id,
+    initialHarness,
+    now: input.now()
+  });
+  assertCheckpointTaskOrder(checkpoint2.steps, input.taskIds);
+  let runtime = await restoreCheckpointRuntime({
+    store: input.store,
+    initialRuntime: input.initialRuntime,
+    steps: checkpoint2.steps,
+    loadRuntimeFromRelease
+  });
+  const attempts = checkpoint2.steps.length ? await loadAttemptEvidenceByIds({
+    store: input.store,
+    tasksetId: input.taskset.id,
+    attemptIds: checkpoint2.steps.map((step) => step.attemptId)
+  }) : [];
+  const attemptsById = new Map(attempts.map((attempt) => [attempt.attempt.id, attempt]));
   const refinerResults = [];
-  const steps = [];
+  const steps = [...checkpoint2.steps];
   try {
     for (const [ordinal, taskId] of input.taskIds.entries()) {
+      if (ordinal < steps.length) continue;
       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
-      });
+      const priorInvocations = checkpoint2.invocations.filter(
+        (invocation2) => invocation2.taskId === taskId
+      );
+      const lastInvocation = priorInvocations.at(-1);
+      if (lastInvocation?.status === "failed" && priorInvocations.length >= HARNESS_REFINER_BENCHMARK_MAX_INVOCATIONS_PER_TASK) {
+        throw new Error(
+          `Sequential Refiner exhausted ${HARNESS_REFINER_BENCHMARK_MAX_INVOCATIONS_PER_TASK} admitted invocations for ${taskId}.`
+        );
+      }
+      let evidence = lastInvocation?.status === "failed" ? attemptsById.get(lastInvocation.attemptId) : void 0;
+      if (!evidence && lastInvocation?.status === "failed") {
+        [evidence] = await loadAttemptEvidenceByIds({
+          store: input.store,
+          tasksetId: input.taskset.id,
+          attemptIds: [lastInvocation.attemptId]
+        });
+        if (evidence) {
+          attempts.push(evidence);
+          attemptsById.set(evidence.attempt.id, evidence);
+        }
+      }
+      if (!evidence) {
+        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);
+        evidence = {
+          attempt: executed.attempt,
+          grade: executed.grade,
+          artifacts: executed.artifacts,
+          receiptContentHash: executed.portable.receipt.contentHash,
+          artifactManifest: executed.portable.artifactManifest,
+          rewardReceipt: executed.portable.rewardReceipt
+        };
+        attempts.push(evidence);
+        attemptsById.set(evidence.attempt.id, evidence);
+      }
+      let refined;
+      try {
+        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
+        });
+      } catch (error) {
+        if (error instanceof BenchmarkRefinerInvocationError) {
+          checkpoint2 = await appendSequentialAdaptationInvocation({
+            storeDir: input.storeDir,
+            modelRunId: input.modelRun.id,
+            initialHarness,
+            invocation: createBenchmarkRefinerInvocationReceipt({
+              taskId,
+              attemptId: evidence.attempt.id,
+              invocationOrdinal: priorInvocations.length,
+              trigger: {
+                id: error.details.trigger.id,
+                contentHash: error.details.trigger.contentHash
+              },
+              status: "failed",
+              outcome: null,
+              failure: {
+                kind: error.details.failureKind,
+                message: error.message.slice(0, 2e3),
+                retryable: error.details.retryable
+              },
+              inputHarness: before,
+              outputHarness: before,
+              usage: error.details.usage,
+              costBasis: error.details.costBasis,
+              estimatedCostUsd: error.details.estimatedCostUsd,
+              startedAt: error.details.startedAt,
+              completedAt: error.details.completedAt
+            }),
+            now: error.details.completedAt
+          });
+        }
+        throw error;
+      }
       if (refined.result) refinerResults.push(refined.result);
       const workspace = await input.store.getHarnessWorkspace(runtime.workspace.id);
       const releaseRef = workspace?.currentChannel.release;
@@ -49538,7 +50179,7 @@ async function runSequentialHarnessAdaptation(input) {
         id: runtime.release.harnessRelease.id,
         contentHash: runtime.release.harnessRelease.contentHash
       };
-      steps.push({
+      const step = {
         ordinal,
         taskId,
         attemptId: evidence.attempt.id,
@@ -49555,6 +50196,38 @@ async function runSequentialHarnessAdaptation(input) {
           decision: refined.result.outcome.decision
         } : null,
         changed: before.contentHash !== after.contentHash
+      };
+      steps.push(step);
+      const invocation = refined.result && refined.invocation ? createBenchmarkRefinerInvocationReceipt({
+        taskId,
+        attemptId: evidence.attempt.id,
+        invocationOrdinal: priorInvocations.length,
+        trigger: {
+          id: refined.detection.trigger.id,
+          contentHash: refined.detection.trigger.contentHash
+        },
+        status: "completed",
+        outcome: {
+          id: refined.result.outcome.id,
+          contentHash: refined.result.outcome.contentHash,
+          decision: refined.result.outcome.decision
+        },
+        failure: null,
+        inputHarness: before,
+        outputHarness: after,
+        usage: refined.invocation.usage,
+        costBasis: refined.invocation.costBasis,
+        estimatedCostUsd: refined.invocation.estimatedCostUsd,
+        startedAt: refined.invocation.startedAt,
+        completedAt: refined.invocation.completedAt
+      }) : void 0;
+      checkpoint2 = await appendSequentialAdaptationInvocation({
+        storeDir: input.storeDir,
+        modelRunId: input.modelRun.id,
+        initialHarness,
+        invocation,
+        step,
+        now: input.now()
       });
     }
   } finally {
@@ -49593,10 +50266,6 @@ async function runSequentialHarnessAdaptation(input) {
   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
@@ -49633,7 +50302,7 @@ async function runSequentialHarnessAdaptation(input) {
     store: input.store,
     workspaceId: input.initialRuntime.workspace.id,
     adaptationAttempts: attempts,
-    refinerResults,
+    completedSteps: steps,
     candidateRelease: finalHarness,
     refinerInputHash: contentHash(attempts.map((evidence) => ({
       attempt: evidence.attempt.id,
@@ -49650,6 +50319,26 @@ async function runSequentialHarnessAdaptation(input) {
     refinerResults
   };
 }
+function assertCheckpointTaskOrder(steps, taskIds) {
+  for (const [index, step] of steps.entries()) {
+    if (step.ordinal !== index || step.taskId !== taskIds[index]) {
+      throw new Error("Sequential adaptation checkpoint drifted from the admitted task order.");
+    }
+  }
+}
+async function restoreCheckpointRuntime(input) {
+  const last = input.steps.at(-1);
+  if (!last) return input.initialRuntime;
+  const workspace = await input.store.getHarnessWorkspace(input.initialRuntime.workspace.id);
+  if (!workspace?.currentChannel.release || workspace.currentChannel.release.id !== last.outputHarness.id || workspace.currentChannel.release.contentHash !== last.outputHarness.contentHash) {
+    throw new Error("Sequential adaptation workspace drifted from its durable checkpoint.");
+  }
+  const release = await input.store.getHarnessReleaseRecord(last.outputHarness.contentHash);
+  if (!release || release.harnessRelease.id !== last.outputHarness.id) {
+    throw new Error("Sequential adaptation checkpoint release is unavailable.");
+  }
+  return input.loadRuntimeFromRelease({ workspace, release });
+}
 function numericToken(record11, keys) {
   for (const key of keys) {
     const value = record11[key];
@@ -49680,7 +50369,7 @@ function createHarnessRefinerBenchmarkService(deps) {
     });
     if (!taskset.benchmark) throw new Error("Harness Refiner Taskset is unavailable.");
     if (taskset.graders.some(
-      (grader) => grader.kind === "model_judge" && grader.calibrationStatus !== "passed"
+      (grader) => grader.kind === "model_judge" && grader.rewardEligible && grader.calibrationStatus !== "passed"
     )) {
       const calibration = await deps.evaluation.calibrateModelJudges(taskset.id);
       if (!calibration.passed) {
@@ -49755,7 +50444,7 @@ function createHarnessRefinerBenchmarkService(deps) {
         attemptPlan: executionPlan
       },
       evaluationProgress: {
-        stage: "baseline",
+        stage: "adaptation",
         completedAttempts: 0,
         totalAttempts: totalPlannedAttempts(executionPlan),
         accounting: emptyEvaluationAccounting()
@@ -49802,13 +50491,23 @@ function createHarnessRefinerBenchmarkService(deps) {
     }
     if (activeRuns.has(modelRunId) || run.status === "running") return run;
     const canResumeFromRefiner = run.evaluationProgress?.stage === "refiner" && run.evaluationProgress?.completedAttempts === completedBeforeStage(run.evaluation.attemptPlan, "candidate_adaptation");
+    const candidateAdaptationStart = completedBeforeStage(
+      run.evaluation.attemptPlan,
+      "candidate_adaptation"
+    );
+    const candidateAdaptationEnd = candidateAdaptationStart + requirePlanStage(run.evaluation.attemptPlan, "candidate_adaptation").attemptCount;
+    const sequentialCheckpoint = await loadSequentialAdaptationCheckpoint({
+      storeDir: deps.storeDir,
+      modelRunId: run.id
+    });
+    const canResumeFromCandidateAdaptation = run.evaluationProgress?.stage === "candidate_adaptation" && run.evaluationProgress.completedAttempts >= candidateAdaptationStart && run.evaluationProgress.completedAttempts <= candidateAdaptationEnd && Boolean(sequentialCheckpoint);
     const hasCompletedComparisonCheckpoint = ["candidate_adaptation", "candidate", "comparison"].includes(
       run.evaluationProgress?.stage ?? ""
     ) && run.evaluationProgress?.completedAttempts === totalPlannedAttempts(run.evaluation.attemptPlan);
     const canResumeFromComparison = hasCompletedComparisonCheckpoint && Boolean(await loadLatestManagedResult(deps.storeDir, run.id));
-    if (!["failed", "cancelled"].includes(run.status) || !canResumeFromRefiner && !canResumeFromComparison) {
+    if (!["failed", "cancelled"].includes(run.status) || !canResumeFromRefiner && !canResumeFromCandidateAdaptation && !canResumeFromComparison) {
       throw new Error(
-        "Only a Harness Refiner run with a durable Refiner or comparison checkpoint can resume."
+        "Only a Harness Refiner run with a durable Refiner, sequential adaptation, or comparison checkpoint can resume."
       );
     }
     const project = await requireModelProject(deps.store, run.modelId, run.profileId);
@@ -49899,12 +50598,22 @@ function createHarnessRefinerBenchmarkService(deps) {
       );
       const candidatePlan = requirePlanStage(executionPlan, "candidate");
       const resumeFromRefiner = modelRun.evaluationProgress?.stage === "refiner" && modelRun.evaluationProgress.completedAttempts === completedBeforeStage(executionPlan, "candidate_adaptation");
+      const candidateAdaptationStart = completedBeforeStage(
+        executionPlan,
+        "candidate_adaptation"
+      );
+      const candidateAdaptationEnd = candidateAdaptationStart + candidateAdaptationPlan.attemptCount;
+      const sequentialCheckpoint = await loadSequentialAdaptationCheckpoint({
+        storeDir: deps.storeDir,
+        modelRunId: modelRun.id
+      });
+      const resumeFromCandidateAdaptation = modelRun.evaluationProgress?.stage === "candidate_adaptation" && modelRun.evaluationProgress.completedAttempts >= candidateAdaptationStart && modelRun.evaluationProgress.completedAttempts <= candidateAdaptationEnd && Boolean(sequentialCheckpoint);
       const resumeFromComparison = ["candidate_adaptation", "candidate", "comparison"].includes(
         modelRun.evaluationProgress?.stage ?? ""
       ) && modelRun.evaluationProgress?.completedAttempts === totalAttempts;
       const budget = new BenchmarkSpendBudget(
         input.maximumSpendUsd,
-        resumeFromRefiner || resumeFromComparison ? modelRun.evaluationProgress?.accounting?.observedSpendUsd ?? 0 : 0
+        resumeFromRefiner || resumeFromCandidateAdaptation || resumeFromComparison ? modelRun.evaluationProgress?.accounting?.observedSpendUsd ?? 0 : 0
       );
       if (resumeFromComparison) {
         return resumeHarnessRefinerComparison({
@@ -49931,7 +50640,7 @@ function createHarnessRefinerBenchmarkService(deps) {
       }
       let evidenceSnapshot = new BenchmarkEvidenceSnapshot();
       const observeStageAttempts = (stage, label) => {
-        let completedInStage = 0;
+        let completedInStage = modelRun.evaluationProgress?.accounting?.attempts.filter((attempt) => attempt.phase === stage).length ?? 0;
         return async (result) => {
           context.signal.throwIfAborted();
           budget.assertAvailable(label);
@@ -49960,7 +50669,7 @@ function createHarnessRefinerBenchmarkService(deps) {
       let baseline;
       let adaptation;
       let adaptationAttempts;
-      if (resumeFromRefiner) {
+      if (resumeFromRefiner || resumeFromCandidateAdaptation) {
         baseline = await loadCompletedBenchmarkStage({
           store: deps.store,
           modelRunId: modelRun.id,
@@ -49984,33 +50693,34 @@ function createHarnessRefinerBenchmarkService(deps) {
           ]
         });
       } else {
-        const executedBaseline = await deps.evaluation.executeBenchmark({
+        const executedAdaptation = await deps.evaluation.executeBenchmark({
           tasksetId: taskset.id,
           phase: "baseline",
           model: input.model,
           reasoningEffort: input.reasoningEffort,
           seeds: input.seeds,
           repetitions: input.repetitions,
-          split: baselinePlan.split,
-          taskIds: baselinePlan.taskIds,
+          split: adaptationPlan.split,
+          taskIds: adaptationPlan.taskIds,
           sampling: { maxOutputTokens: 4096, temperature: 0, topP: 1 },
           releasedHarness: baselineHarness,
           hostedTokenPricing: admittedPricing,
           parentModelRunId: modelRun.id,
           signal: context.signal,
-          toolEvidence: frozenToolEvidence(evidenceSnapshot, "record", "held_out"),
-          onAttemptComplete: observeStageAttempts("baseline", "held-out baseline")
+          toolEvidence: frozenToolEvidence(evidenceSnapshot, "record", "adaptation"),
+          onAttemptComplete: observeStageAttempts("adaptation", "adaptation baseline")
         });
-        baseline = completedStage(executedBaseline);
+        adaptation = completedStage(executedAdaptation);
+        adaptationAttempts = adaptation.attempts;
         await ensureBaseVersion({
           store: deps.store,
           project: context.project,
           modelRun,
           model: input.model,
-          baseline: executedBaseline.attempts[0]
+          baseline: executedAdaptation.attempts[0]
         });
-        if (baseline.run.harnessRelease.id !== modelRun.harnessRelease.id || baseline.run.harnessRelease.contentHash !== modelRun.harnessRelease.contentHash) {
-          throw new Error("Baseline execution drifted from the admitted Harness release.");
+        if (adaptation.run.harnessRelease.id !== modelRun.harnessRelease.id || adaptation.run.harnessRelease.contentHash !== modelRun.harnessRelease.contentHash) {
+          throw new Error("Adaptation baseline drifted from the admitted Harness release.");
         }
         await checkpointEvidenceSnapshot(
           deps.store,
@@ -50019,29 +50729,31 @@ function createHarnessRefinerBenchmarkService(deps) {
           evidenceSnapshot.manifest()
         );
         await updateProgress(deps.store, modelRun.id, {
-          stage: "adaptation",
-          completedAttempts: completedBeforeStage(executionPlan, "adaptation"),
+          stage: "baseline",
+          completedAttempts: completedBeforeStage(executionPlan, "baseline"),
           totalAttempts
         });
-        const executedAdaptation = await deps.evaluation.executeBenchmark({
+        const executedBaseline = await deps.evaluation.executeBenchmark({
           tasksetId: taskset.id,
           phase: "baseline",
           model: input.model,
           reasoningEffort: input.reasoningEffort,
           seeds: input.seeds,
           repetitions: input.repetitions,
-          split: adaptationPlan.split,
-          taskIds: adaptationPlan.taskIds,
+          split: baselinePlan.split,
+          taskIds: baselinePlan.taskIds,
           sampling: { maxOutputTokens: 4096, temperature: 0, topP: 1 },
           releasedHarness: baselineHarness,
           hostedTokenPricing: admittedPricing,
           parentModelRunId: modelRun.id,
           signal: context.signal,
-          toolEvidence: frozenToolEvidence(evidenceSnapshot, "record", "adaptation"),
-          onAttemptComplete: observeStageAttempts("adaptation", "adaptation baseline")
+          toolEvidence: frozenToolEvidence(evidenceSnapshot, "record", "held_out"),
+          onAttemptComplete: observeStageAttempts("baseline", "held-out baseline")
         });
-        adaptation = completedStage(executedAdaptation);
-        adaptationAttempts = adaptation.attempts;
+        baseline = completedStage(executedBaseline);
+        if (baseline.run.harnessRelease.id !== modelRun.harnessRelease.id || baseline.run.harnessRelease.contentHash !== modelRun.harnessRelease.contentHash) {
+          throw new Error("Held-out baseline drifted from the admitted Harness release.");
+        }
         await checkpointEvidenceSnapshot(
           deps.store,
           deps.storeDir,
@@ -50054,16 +50766,18 @@ function createHarnessRefinerBenchmarkService(deps) {
           totalAttempts
         });
       }
-      if (resumeFromRefiner && !modelRun.evaluationProgress?.evidenceSnapshot) {
+      if ((resumeFromRefiner || resumeFromCandidateAdaptation) && !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."
         );
       }
-      await updateProgress(deps.store, modelRun.id, {
-        stage: "candidate_adaptation",
-        completedAttempts: completedBeforeStage(executionPlan, "candidate_adaptation"),
-        totalAttempts
-      });
+      if (!resumeFromCandidateAdaptation) {
+        await updateProgress(deps.store, modelRun.id, {
+          stage: "candidate_adaptation",
+          completedAttempts: candidateAdaptationStart,
+          totalAttempts
+        });
+      }
       const candidateAdaptation = await runSequentialHarnessAdaptation({
         store: deps.store,
         storeDir: deps.storeDir,
@@ -50295,13 +51009,13 @@ function createHarnessRefinerBenchmarkService(deps) {
 }
 
 // ../server/src/training/task-attempt-grader-evidence.ts
-import { execFile as execFile7 } from "node:child_process";
+import { execFile as execFile8 } from "node:child_process";
 import { readFile as readFile15 } from "node:fs/promises";
 import { promisify as promisify5 } from "node:util";
 var MAX_ARTIFACTS = 5;
 var MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
 var MAX_EXTRACTED_CHARS = 4e4;
-var execFileAsync5 = promisify5(execFile7);
+var execFileAsync5 = promisify5(execFile8);
 function createTaskAttemptModelJudge(input) {
   return async ({ grader, task, attempt }) => {
     const usages = [];
@@ -50377,6 +51091,18 @@ async function loadTaskAttemptGraderEvidence(input) {
           content: boundedText(stdout)
         };
       }
+      if (isOpenXmlArtifact(artifact.mediaType)) {
+        const extracted = await extractOpenXmlArtifact(
+          artifact.path,
+          artifact.mediaType
+        );
+        return {
+          ...base,
+          extraction: "open_xml_text",
+          content: boundedText(extracted.content),
+          structure: extracted.structure
+        };
+      }
       if (isTextArtifact(artifact.mediaType)) {
         return {
           ...base,
@@ -50396,8 +51122,73 @@ async function loadTaskAttemptGraderEvidence(input) {
 }
 function isTextArtifact(mediaType) {
   return Boolean(
-    mediaType?.startsWith("text/") || mediaType === "application/json" || mediaType === "application/xml"
+    mediaType?.startsWith("text/") || mediaType === "application/json" || mediaType === "application/javascript" || mediaType === "application/sql" || mediaType === "application/xml" || mediaType === "application/yaml"
+  );
+}
+function isOpenXmlArtifact(mediaType) {
+  return mediaType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mediaType === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || mediaType === "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+}
+async function extractOpenXmlArtifact(artifactPath2, mediaType) {
+  const options = {
+    env: { ...process.env, PATH: executableSearchPath() },
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 15e3
+  };
+  const { stdout: listing } = await execFileAsync5(
+    "unzip",
+    ["-Z1", artifactPath2],
+    options
   );
+  const entries = listing.split(/\r?\n/).filter(Boolean);
+  const selected = openXmlTextEntries(entries, mediaType).slice(0, 250);
+  const parts = [];
+  for (const entry of selected) {
+    const { stdout } = await execFileAsync5(
+      "unzip",
+      ["-p", artifactPath2, entry],
+      options
+    );
+    const text3 = readableXmlText(stdout);
+    if (text3) parts.push(`[${entry}]
+${text3}`);
+  }
+  return {
+    content: parts.join("\n\n"),
+    structure: {
+      archiveEntryCount: entries.length,
+      extractedEntryCount: selected.length,
+      sheetCount: entries.filter((entry) => /^xl\/worksheets\/sheet\d+\.xml$/.test(entry)).length,
+      slideCount: entries.filter((entry) => /^ppt\/slides\/slide\d+\.xml$/.test(entry)).length,
+      chartCount: entries.filter((entry) => /\/charts\/chart\d+\.xml$/.test(entry)).length,
+      imageCount: entries.filter((entry) => /\/media\//.test(entry)).length
+    }
+  };
+}
+function openXmlTextEntries(entries, mediaType) {
+  if (mediaType.includes("wordprocessingml")) {
+    return entries.filter(
+      (entry) => /^word\/(?:document|header\d+|footer\d+|footnotes|endnotes|comments)\.xml$/.test(entry)
+    );
+  }
+  if (mediaType.includes("spreadsheetml")) {
+    return entries.filter(
+      (entry) => entry === "xl/workbook.xml" || entry === "xl/sharedStrings.xml" || /^xl\/worksheets\/sheet\d+\.xml$/.test(entry) || /^xl\/charts\/chart\d+\.xml$/.test(entry)
+    );
+  }
+  return entries.filter(
+    (entry) => /^ppt\/(?:slides\/slide\d+|notesSlides\/notesSlide\d+|charts\/chart\d+)\.xml$/.test(entry)
+  ).sort(naturalEntryOrder);
+}
+function naturalEntryOrder(left, right) {
+  return left.localeCompare(right, void 0, { numeric: true });
+}
+function readableXmlText(value) {
+  return decodeXmlEntities(
+    value.replace(/<\/?(?:w:p|a:p|row|si|sheetData|c)(?:\s[^>]*)?>/g, "\n").replace(/<(?:w:tab|a:br)(?:\s[^>]*)?\/?\s*>/g, "	").replace(/<[^>]+>/g, " ")
+  ).split(/\r?\n/).map((line) => line.replace(/[\t ]+/g, " ").trim()).filter(Boolean).join("\n");
+}
+function decodeXmlEntities(value) {
+  return value.replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))).replace(/&#(\d+);/g, (_, decimal2) => String.fromCodePoint(Number.parseInt(decimal2, 10))).replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
 }
 function boundedText(value) {
   return value.length <= MAX_EXTRACTED_CHARS ? value : `${value.slice(0, MAX_EXTRACTED_CHARS)}
@@ -50468,7 +51259,7 @@ function usageCost(usage, pricing) {
 // ../server/src/training/benchmark-tasksets.ts
 import { createHash as createHash15 } from "node:crypto";
 import { mkdir as mkdir11, readFile as readFile16, writeFile as writeFile7 } from "node:fs/promises";
-import path57 from "node:path";
+import path58 from "node:path";
 var BUILTIN_DEFINITION_ID = "harness-refiner";
 function createBenchmarkTasksetService(input) {
   const now2 = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -50478,7 +51269,7 @@ function createBenchmarkTasksetService(input) {
     if (existing?.benchmark?.releaseId === harnessRefinerBenchmarkRelease.id && existing.benchmark.releaseHash === harnessRefinerBenchmarkRelease.contentHash) {
       return existing;
     }
-    const tasksetRoot = path57.join(
+    const tasksetRoot = path58.join(
       input.storeDir,
       "training",
       "tasksets",
@@ -50498,7 +51289,7 @@ function createBenchmarkTasksetService(input) {
   }
   async function releaseForTaskset(taskset) {
     if (taskset.purpose !== "benchmark" || !taskset.benchmark) return null;
-    const releasePath = path57.resolve(
+    const releasePath = path58.resolve(
       input.storeDir,
       "training",
       "tasksets",
@@ -50519,18 +51310,23 @@ function definitionForRelease(release) {
   return createBenchmarkDefinition({
     schemaVersion: "openpond.benchmarkDefinition.v1",
     id: BUILTIN_DEFINITION_ID,
-    title: "Harness Refiner 08112026",
-    description: "Measures whether sequential, evidence-driven Harness improvements preserve quality while reducing future-task foreground tokens.",
+    title: "Harness Refiner 20260818 v2",
+    description: "Measures whether sequential, evidence-driven Harness improvements change verified reward on a frozen cohort; foreground tokens are secondary.",
     tasksetRelease: { id: release.id, contentHash: release.contentHash },
     adaptationSplit: "validation",
     evaluationSplit: "frozen_eval",
-    primaryMetric: "foreground_tokens",
+    primaryMetric: "success_rate",
     qualityGate: "non_regression",
     caseCounts: {
       adaptation: release.tasks.filter((task) => task.split === "validation").length,
       evaluation: release.tasks.filter((task) => task.split === "frozen_eval").length
     },
-    metadata: { builtin: true, protocol: "sequential_product_lifecycle" }
+    metadata: {
+      builtin: true,
+      protocol: "sequential_product_lifecycle_v3",
+      orderSeed: "harness-refiner-20260818-order-v1",
+      secondaryMetrics: ["foreground_tokens"]
+    }
   });
 }
 async function projectRelease(input) {
@@ -50541,12 +51337,12 @@ async function projectRelease(input) {
     input.release.tasks.flatMap((task) => task.artifactRefs)
   );
   const managedAssetById = /* @__PURE__ */ new Map();
-  await mkdir11(path57.join(input.tasksetRoot, "assets"), { recursive: true });
-  await mkdir11(path57.join(input.tasksetRoot, "benchmark"), { recursive: true });
-  await mkdir11(path57.join(input.tasksetRoot, "rubrics"), { recursive: true });
-  await mkdir11(path57.join(input.tasksetRoot, "verifiers"), { recursive: true });
+  await mkdir11(path58.join(input.tasksetRoot, "assets"), { recursive: true });
+  await mkdir11(path58.join(input.tasksetRoot, "benchmark"), { recursive: true });
+  await mkdir11(path58.join(input.tasksetRoot, "rubrics"), { recursive: true });
+  await mkdir11(path58.join(input.tasksetRoot, "verifiers"), { recursive: true });
   await writeFile7(
-    path57.join(input.tasksetRoot, "benchmark", "taskset.release.json"),
+    path58.join(input.tasksetRoot, "benchmark", "taskset.release.json"),
     JSON.stringify(input.release),
     "utf8"
   );
@@ -50555,9 +51351,9 @@ async function projectRelease(input) {
     if (contentHash(contents) !== asset.contentHash) {
       throw new Error(`Benchmark asset ${asset.path} failed its content hash.`);
     }
-    const fileName = `${asset.id}-${path57.basename(asset.path)}`;
-    const artifactRef = path57.posix.join("assets", fileName);
-    await writeFile7(path57.join(input.tasksetRoot, artifactRef), contents, "utf8");
+    const fileName = `${asset.id}-${path58.basename(asset.path)}`;
+    const artifactRef = path58.posix.join("assets", fileName);
+    await writeFile7(path58.join(input.tasksetRoot, artifactRef), contents, "utf8");
     managedAssetById.set(asset.id, {
       artifactRef,
       fileName,
@@ -50566,19 +51362,17 @@ async function projectRelease(input) {
       mediaType: asset.mediaType
     });
   }
-  const rubricGrader = input.release.graders.find(
-    (grader) => grader.kind === "model_judge"
-  );
   const verifierGrader = input.release.graders.find(
     (grader) => grader.kind === "custom_verifier"
   );
-  if (!rubricGrader || !verifierGrader) {
-    throw new Error("Benchmark release requires a model judge and custom verifier.");
+  const supplementaryJudge = supplementaryModelJudge(input.release);
+  if (!verifierGrader) {
+    throw new Error("Benchmark release requires a custom verifier.");
   }
-  const rubric = await copyVerifierAsset(
+  await copyVerifierAsset(
     input.assets,
     input.tasksetRoot,
-    rubricGrader.rubricRef
+    supplementaryJudge.rubricRef
   );
   await copyVerifierAsset(
     input.assets,
@@ -50587,10 +51381,6 @@ async function projectRelease(input) {
   );
   const sourceId = `source-${input.tasksetId}`;
   const tasks = input.release.tasks.map((task) => {
-    const deliverable = stringValue11(task.expectedOutput?.deliverable);
-    const validationKinds = Array.isArray(task.expectedOutput?.validation) ? task.expectedOutput.validation.filter(
-      (value) => typeof value === "string"
-    ) : [];
     return {
       schemaVersion: "openpond.taskData.v1",
       id: task.id,
@@ -50616,9 +51406,18 @@ async function projectRelease(input) {
           metadata: { portableContentHash: asset.contentHash }
         };
       }),
-      requiredOutputs: requiredOutputs(task.id, deliverable, validationKinds),
+      requiredOutputs: (task.requiredOutputs ?? []).map((output) => ({
+        path: output.path,
+        mediaType: output.mediaType,
+        schemaRef: output.schemaRef?.id ?? null,
+        maxBytes: output.maxBytes ?? void 0,
+        metadata: output.metadata
+      })),
       tags: task.tags,
-      metadata: { portableTaskId: task.id }
+      metadata: {
+        portableTaskId: task.id,
+        portableTaskRecord: task
+      }
     };
   });
   const sourceFileHashes = [...managedAssetById.values()].map((asset) => asset.sha256);
@@ -50636,29 +51435,9 @@ async function projectRelease(input) {
       exportName: "verify",
       timeoutMs: verifierGrader.timeoutMs,
       networkPolicy: "none",
-      metadata: { portableVerifierHash: verifierGrader.verifierRef.contentHash }
-    },
-    {
-      id: rubricGrader.id,
-      version: rubricGrader.version,
-      label: "Task quality",
-      kind: "model_judge",
-      weight: rubricGrader.weight,
-      hardGate: rubricGrader.hardGate,
-      rewardEligible: false,
-      privileged: rubricGrader.privileged,
-      rubric,
-      judge: { providerId: "openpond", modelId: "openpond-chat" },
-      calibrationFixtureRefs: [
-        "benchmark-positive",
-        "benchmark-negative",
-        "benchmark-boundary"
-      ],
-      calibrationStatus: "pending",
-      temperature: 0,
       metadata: {
-        portableRubricHash: rubricGrader.rubricRef.contentHash,
-        requestedRewardEligible: rubricGrader.rewardEligible
+        portableVerifierHash: verifierGrader.verifierRef.contentHash,
+        portableVerifierRef: verifierGrader.verifierRef
       }
     }
   ];
@@ -50719,6 +51498,7 @@ async function projectRelease(input) {
       networkPolicy: input.release.environment.networkPolicy,
       metadata: {
         portableEnvironmentHash: contentHash(input.release.environment),
+        portableTools: input.release.tools,
         maxToolTurns: 40
       }
     },
@@ -50727,7 +51507,7 @@ async function projectRelease(input) {
       taskKind: "single_agent",
       supportedSignals: [],
       compatibleMethods: ["none"],
-      rewardKinds: ["deterministic", "model_judge"],
+      rewardKinds: ["deterministic"],
       requiresTools: true,
       requiresState: true,
       requiresPrivilegedGrading: true,
@@ -50768,7 +51548,16 @@ async function projectRelease(input) {
       portableTasksetRelease: {
         id: input.release.id,
         contentHash: input.release.contentHash
-      }
+      },
+      supplementaryModelJudge: {
+        id: supplementaryJudge.id,
+        version: supplementaryJudge.version,
+        rubricHash: supplementaryJudge.rubricRef.contentHash,
+        calibrationStatus: supplementaryJudge.calibrationStatus,
+        executable: false,
+        rewardEligible: false
+      },
+      portableCapabilities: input.release.capabilities
     }
   });
   return TasksetSchema.parse({
@@ -50784,7 +51573,7 @@ async function copyVerifierAsset(assets, tasksetRoot, asset) {
   if (contentHash(contents) !== asset.contentHash) {
     throw new Error(`Benchmark verifier asset ${asset.path} failed its content hash.`);
   }
-  await writeFile7(path57.join(tasksetRoot, asset.path), contents, "utf8");
+  await writeFile7(path58.join(tasksetRoot, asset.path), contents, "utf8");
   return contents;
 }
 function builtinAsset(assets, assetPath) {
@@ -50794,19 +51583,6 @@ function builtinAsset(assets, assetPath) {
   }
   return contents;
 }
-function requiredOutputs(taskId, deliverable, validationKinds) {
-  const output = deliverable === "pdf" ? { extension: "pdf", mediaType: "application/pdf" } : deliverable === "spreadsheet" ? {
-    extension: "xlsx",
-    mediaType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-  } : null;
-  if (!output) return [];
-  return [{
-    path: `${taskId}.${output.extension}`,
-    mediaType: output.mediaType,
-    maxBytes: 1e7,
-    metadata: { validationKinds }
-  }];
-}
 function benchmarkFixtures(taskId) {
   return [
     {
@@ -50830,7 +51606,7 @@ function benchmarkFixtures(taskId) {
       },
       infrastructureError: null,
       expectedPassed: false,
-      expectedRewardEligible: false,
+      expectedRewardEligible: true,
       metadata: {}
     },
     {
@@ -50840,7 +51616,7 @@ function benchmarkFixtures(taskId) {
       output: { text: "The launch is moving to August 27 while testing finishes." },
       infrastructureError: null,
       expectedPassed: false,
-      expectedRewardEligible: false,
+      expectedRewardEligible: true,
       metadata: {}
     }
   ];
@@ -50848,16 +51624,29 @@ function benchmarkFixtures(taskId) {
 function uniqueAssets(assets) {
   return [...new Map(assets.map((asset) => [asset.id, asset])).values()];
 }
-function stringValue11(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
+function supplementaryModelJudge(release) {
+  const raw = release.metadata.supplementaryModelJudge;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("Benchmark release has no supplementary model-judge metadata.");
+  }
+  const value = raw;
+  if (typeof value.id !== "string" || typeof value.version !== "string" || value.calibrationStatus !== "pending" || value.executable !== false || value.rewardEligible !== false) {
+    throw new Error("Benchmark supplementary model-judge metadata is invalid.");
+  }
+  return {
+    id: value.id,
+    version: value.version,
+    calibrationStatus: value.calibrationStatus,
+    rubricRef: ImmutableAssetRefSchema.parse(value.rubricRef)
+  };
 }
 
 // ../server/src/training/local-taskset-work-runtime.ts
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import { createHash as createHash16, randomUUID as randomUUID23 } from "node:crypto";
-import { existsSync as existsSync12, promises as fs24 } from "node:fs";
+import { existsSync as existsSync12, promises as fs25 } from "node:fs";
 import os8 from "node:os";
-import path58 from "node:path";
+import path59 from "node:path";
 function createLocalTasksetWorkRuntime(deps) {
   return {
     createSession: async (payload) => {
@@ -50911,7 +51700,7 @@ async function executeLocalWorkspaceTool(input) {
   const request = record10(input.payload);
   const action = string2(request.action);
   const args = record10(request.args);
-  const root = path58.resolve(input.session.cwd);
+  const root = path59.resolve(input.session.cwd);
   await ensureLayout(root);
   try {
     if (action === "sandbox_create" || action === "sandbox_start") {
@@ -50938,8 +51727,8 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_upload_file") {
       const target = localPath(root, string2(args.path));
       const bytes2 = Buffer.from(string2(args.contentsBase64), "base64");
-      await fs24.mkdir(path58.dirname(target), { recursive: true, mode: 448 });
-      await fs24.writeFile(target, bytes2, { mode: 384 });
+      await fs25.mkdir(path59.dirname(target), { recursive: true, mode: 448 });
+      await fs25.writeFile(target, bytes2, { mode: 384 });
       return ok(action, `Uploaded ${relative(root, target)}.`, fileData(target, bytes2));
     }
     if (action === "sandbox_list_files") {
@@ -50950,7 +51739,7 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_read_file") {
       const target = localPath(root, string2(args.path));
       const maxBytes = integer(args.maxBytes, 512e3, 1, 1e6);
-      const bytes2 = await fs24.readFile(target);
+      const bytes2 = await fs25.readFile(target);
       const bounded = bytes2.subarray(0, maxBytes);
       return ok(action, bounded.toString("utf8"), {
         path: relative(root, target),
@@ -50962,24 +51751,24 @@ async function executeLocalWorkspaceTool(input) {
     if (action === "sandbox_write_file") {
       const target = localPath(root, string2(args.path));
       const contents = string2(args.content, true);
-      await fs24.mkdir(path58.dirname(target), { recursive: true, mode: 448 });
-      await fs24.writeFile(target, contents, { encoding: "utf8", mode: 384 });
+      await fs25.mkdir(path59.dirname(target), { recursive: true, mode: 448 });
+      await fs25.writeFile(target, contents, { encoding: "utf8", mode: 384 });
       return ok(action, `Wrote ${relative(root, target)}.`, fileData(target, Buffer.from(contents)));
     }
     if (action === "sandbox_edit_file") {
       const target = localPath(root, string2(args.path));
-      const contents = await fs24.readFile(target, "utf8");
+      const contents = await fs25.readFile(target, "utf8");
       const oldText = string2(args.oldText);
       if (!contents.includes(oldText)) {
         return fail(action, "The exact text to replace was not found.");
       }
       const next = args.replaceAll === true ? contents.replaceAll(oldText, string2(args.newText, true)) : contents.replace(oldText, string2(args.newText, true));
-      await fs24.writeFile(target, next, { encoding: "utf8", mode: 384 });
+      await fs25.writeFile(target, next, { encoding: "utf8", mode: 384 });
       return ok(action, `Edited ${relative(root, target)}.`, fileData(target, Buffer.from(next)));
     }
     if (action === "sandbox_delete_file") {
       const target = localPath(root, string2(args.path));
-      await fs24.rm(target, { recursive: args.recursive === true, force: true });
+      await fs25.rm(target, { recursive: args.recursive === true, force: true });
       return ok(action, `Deleted ${relative(root, target)}.`, { path: relative(root, target) });
     }
     if (action === "sandbox_exec") {
@@ -50992,7 +51781,7 @@ async function executeLocalWorkspaceTool(input) {
         output: [result.stdout, result.stderr].filter(Boolean).join("\n").trim(),
         data: {
           command,
-          cwd: path58.join(root, "work"),
+          cwd: path59.join(root, "work"),
           exitCode: result.code,
           stdout: result.stdout,
           stderr: result.stderr
@@ -51001,24 +51790,24 @@ async function executeLocalWorkspaceTool(input) {
     }
     if (action === "sandbox_save_output") {
       const source = localPath(root, string2(args.path));
-      const bytes2 = await fs24.readFile(source);
+      const bytes2 = await fs25.readFile(source);
       if (bytes2.byteLength > WORK_OUTPUT_MAX_BYTES) {
         return fail(action, `Work output exceeds ${WORK_OUTPUT_MAX_BYTES.toLocaleString()} bytes.`);
       }
       const title = safeName2(
-        typeof args.suggestedName === "string" && args.suggestedName.trim() ? args.suggestedName : path58.basename(source)
+        typeof args.suggestedName === "string" && args.suggestedName.trim() ? args.suggestedName : path59.basename(source)
       );
-      const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path58.extname(title).toLowerCase()];
+      const contentType2 = WORK_OUTPUT_CONTENT_TYPES[path59.extname(title).toLowerCase()];
       if (!contentType2) return fail(action, `${title} is not a supported Work output format.`);
-      const outputDir = path58.join(
+      const outputDir = path59.join(
         input.deps.storeDir,
         "work",
         "outputs",
         safeName2(input.session.id)
       );
-      await fs24.mkdir(outputDir, { recursive: true, mode: 448 });
-      const destination = path58.join(outputDir, `001-${randomUUID23()}-${title}`);
-      await fs24.writeFile(destination, bytes2, { mode: 384 });
+      await fs25.mkdir(outputDir, { recursive: true, mode: 448 });
+      const destination = path59.join(outputDir, `001-${randomUUID23()}-${title}`);
+      await fs25.writeFile(destination, bytes2, { mode: 384 });
       const outputRef = FileOutputRefSchema.parse({
         kind: "file",
         id: `output-${createHash16("sha256").update(destination).digest("hex").slice(0, 24)}`,
@@ -51055,25 +51844,25 @@ async function executeLocalWorkspaceTool(input) {
 }
 async function ensureLayout(root) {
   await Promise.all(["inputs", "work", "outputs"].map(
-    (area) => fs24.mkdir(path58.join(root, area), { recursive: true, mode: 448 })
+    (area) => fs25.mkdir(path59.join(root, area), { recursive: true, mode: 448 })
   ));
 }
 function localPath(root, value) {
   const normalized = value.replaceAll("\\", "/").replace(/^\/+/, "").replace(/^workspace(?:\/|$)/, "");
-  const target = path58.resolve(root, normalized);
-  if (target !== root && !target.startsWith(`${root}${path58.sep}`)) {
+  const target = path59.resolve(root, normalized);
+  if (target !== root && !target.startsWith(`${root}${path59.sep}`)) {
     throw new Error("Local Work path escaped its isolated workspace.");
   }
   return target;
 }
 async function listFiles2(root, target, recursive) {
-  const stat7 = await fs24.stat(target).catch(() => null);
+  const stat7 = await fs25.stat(target).catch(() => null);
   if (!stat7) return [];
   if (!stat7.isDirectory()) return [relative(root, target)];
-  const entries = await fs24.readdir(target, { withFileTypes: true });
+  const entries = await fs25.readdir(target, { withFileTypes: true });
   const files = [];
   for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const item = path58.join(target, entry.name);
+    const item = path59.join(target, entry.name);
     files.push(relative(root, item));
     if (recursive && entry.isDirectory()) files.push(...await listFiles2(root, item, true));
     if (files.length >= 1e3) break;
@@ -51082,8 +51871,8 @@ async function listFiles2(root, target, recursive) {
 }
 function runCommand5(command, cwd, timeoutMs) {
   return new Promise((resolve) => {
-    const nodeRuntimeRoot = path58.dirname(path58.dirname(process.execPath));
-    const localPythonRoot = path58.join(os8.homedir(), ".local", "lib");
+    const nodeRuntimeRoot = path59.dirname(path59.dirname(process.execPath));
+    const localPythonRoot = path59.join(os8.homedir(), ".local", "lib");
     const sandboxArgs = [
       "--tmpfs",
       "/",
@@ -51135,7 +51924,7 @@ function runCommand5(command, cwd, timeoutMs) {
       "-lc",
       command
     ];
-    execFile8(
+    execFile9(
       "/bin/bwrap",
       sandboxArgs,
       { cwd, timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024 },
@@ -51202,7 +51991,7 @@ function integer(value, fallback, minimum, maximum) {
   return typeof value === "number" && Number.isInteger(value) ? Math.min(maximum, Math.max(minimum, value)) : fallback;
 }
 function relative(root, target) {
-  return path58.relative(root, target).replaceAll(path58.sep, "/");
+  return path59.relative(root, target).replaceAll(path59.sep, "/");
 }
 function safeName2(value) {
   return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "output";
@@ -51257,12 +52046,12 @@ function createBenchmarkRuntimeComposition(input) {
 // ../server/src/training/dataset-storage-service.ts
 import { constants as constants3 } from "node:fs";
 import { access as access4, mkdir as mkdir12, readFile as readFile18, rename as rename5, statfs as statfs2, writeFile as writeFile8 } from "node:fs/promises";
-import path60 from "node:path";
+import path61 from "node:path";
 
 // ../server/src/training/dataset-storage-discovery.ts
 import { readdir as readdir4, readFile as readFile17 } from "node:fs/promises";
 import os9 from "node:os";
-import path59 from "node:path";
+import path60 from "node:path";
 var NETWORK_FILE_SYSTEMS = /* @__PURE__ */ new Set([
   "9p",
   "afpfs",
@@ -51348,7 +52137,7 @@ function parseLinuxMountInfo(value, storeDir) {
     candidates.push({
       kind,
       label: driveLabel(mountPath, source, kind),
-      datasetStorePath: mountPath === "/" ? path59.join(storeDir, "datasets") : path59.join(mountPath, "OpenPond", "datasets"),
+      datasetStorePath: mountPath === "/" ? path60.join(storeDir, "datasets") : path60.join(mountPath, "OpenPond", "datasets"),
       path: mountPath
     });
   }
@@ -51367,7 +52156,7 @@ function parseMacMountOutput(value, storeDir) {
     candidates.push({
       kind,
       label: driveLabel(mountPath, source, kind),
-      datasetStorePath: mountPath === "/" ? path59.join(storeDir, "datasets") : path59.join(mountPath, "OpenPond", "datasets"),
+      datasetStorePath: mountPath === "/" ? path60.join(storeDir, "datasets") : path60.join(mountPath, "OpenPond", "datasets"),
       path: mountPath
     });
   }
@@ -51390,11 +52179,11 @@ function parseWindowsLogicalDisks(value, storeDir) {
     const root = `${deviceId}\\`;
     const volumeName = typeof record11.VolumeName === "string" ? record11.VolumeName.trim() : "";
     const kind = driveType === 4 ? "network" : driveType === 2 ? "removable" : "local";
-    const storeRoot = path59.win32.parse(path59.win32.resolve(storeDir)).root.toLowerCase();
+    const storeRoot = path60.win32.parse(path60.win32.resolve(storeDir)).root.toLowerCase();
     return [{
       kind,
       label: volumeName || (root.toLowerCase() === storeRoot ? "System disk" : deviceId.toUpperCase()),
-      datasetStorePath: root.toLowerCase() === storeRoot ? path59.win32.join(storeDir, "datasets") : path59.win32.join(root, "OpenPond", "datasets"),
+      datasetStorePath: root.toLowerCase() === storeRoot ? path60.win32.join(storeDir, "datasets") : path60.win32.join(root, "OpenPond", "datasets"),
       path: root
     }];
   });
@@ -51408,25 +52197,25 @@ function storageKindForPath(value) {
 }
 async function discoverGvfsCandidates() {
   const uid = typeof process.getuid === "function" ? process.getuid() : os9.userInfo().uid;
-  const gvfsRoot = path59.join("/run/user", String(uid), "gvfs");
+  const gvfsRoot = path60.join("/run/user", String(uid), "gvfs");
   const entries = await readdir4(gvfsRoot, { withFileTypes: true }).catch(() => []);
   return entries.flatMap((entry) => {
     if (!entry.isDirectory()) return [];
-    const mountedPath = path59.join(gvfsRoot, entry.name);
+    const mountedPath = path60.join(gvfsRoot, entry.name);
     return [{
       kind: "network",
       label: labelForGvfsMount(entry.name),
-      datasetStorePath: path59.join(mountedPath, "OpenPond", "datasets"),
+      datasetStorePath: path60.join(mountedPath, "OpenPond", "datasets"),
       path: mountedPath
     }];
   });
 }
 function systemStorageCandidate(storeDir, platform) {
-  const root = path59.parse(path59.resolve(storeDir)).root;
+  const root = path60.parse(path60.resolve(storeDir)).root;
   return {
     kind: "local",
     label: "System disk",
-    datasetStorePath: path59.join(storeDir, "datasets"),
+    datasetStorePath: path60.join(storeDir, "datasets"),
     path: platform === "win32" ? root : root || "/"
   };
 }
@@ -51445,12 +52234,12 @@ function storageKind(input) {
 }
 function driveLabel(mountPath, source, kind) {
   if (mountPath === "/") return "System disk";
-  const mountName = path59.basename(mountPath);
+  const mountName = path60.basename(mountPath);
   if (kind === "network") {
     const sourceName = source.replace(/\/+$/, "").split("/").pop();
     return decodeSafely(sourceName || mountName || source);
   }
-  return decodeSafely(mountName || path59.basename(source) || source);
+  return decodeSafely(mountName || path60.basename(source) || source);
 }
 function labelForGvfsMount(name) {
   const separator = name.indexOf(":");
@@ -51484,7 +52273,7 @@ function uniqueCandidates2(candidates) {
   return [...unique2.values()];
 }
 function normalizedPath(value) {
-  const normalized = path59.normalize(value);
+  const normalized = path60.normalize(value);
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
@@ -51545,15 +52334,15 @@ var runCommandProbe = async (executable, args, options = {}) => {
 
 // ../server/src/training/dataset-storage-service.ts
 function createDatasetStorageService(input) {
-  const directory = path60.join(input.storeDir, "datasets");
-  const settingsPath = path60.join(directory, "settings.json");
+  const directory = path61.join(input.storeDir, "datasets");
+  const settingsPath = path61.join(directory, "settings.json");
   async function settings() {
     try {
       return DatasetStorageSettingsSchema.parse(JSON.parse(await readFile18(settingsPath, "utf8")));
     } catch {
       return DatasetStorageSettingsSchema.parse({
         schemaVersion: "openpond.datasetStorageSettings.v1",
-        datasetStorePath: path60.join(input.storeDir, "datasets"),
+        datasetStorePath: path61.join(input.storeDir, "datasets"),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
@@ -51565,7 +52354,7 @@ function createDatasetStorageService(input) {
       platform: process.platform,
       storeDir: input.storeDir
     });
-    if (!candidates.some((candidate2) => path60.resolve(candidate2.datasetStorePath) === path60.resolve(current.datasetStorePath))) {
+    if (!candidates.some((candidate2) => path61.resolve(candidate2.datasetStorePath) === path61.resolve(current.datasetStorePath))) {
       candidates.push({
         datasetStorePath: current.datasetStorePath,
         kind: storageKindForPath(current.datasetStorePath),
@@ -51579,7 +52368,7 @@ function createDatasetStorageService(input) {
       return {
         ...candidate2,
         id: `dataset-storage-${Buffer.from(candidate2.path).toString("base64url").slice(0, 120)}`,
-        configured: path60.resolve(candidate2.datasetStorePath) === path60.resolve(current.datasetStorePath),
+        configured: path61.resolve(candidate2.datasetStorePath) === path61.resolve(current.datasetStorePath),
         mounted: stats !== null,
         freeBytes: stats ? Number(stats.bavail) * Number(stats.bsize) : null,
         totalBytes: stats ? Number(stats.blocks) * Number(stats.bsize) : null,
@@ -51596,7 +52385,7 @@ function createDatasetStorageService(input) {
     const request = UpdateDatasetStorageSettingsRequestSchema.parse(value);
     const updated = DatasetStorageSettingsSchema.parse({
       schemaVersion: "openpond.datasetStorageSettings.v1",
-      datasetStorePath: path60.resolve(request.datasetStorePath),
+      datasetStorePath: path61.resolve(request.datasetStorePath),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (!await ensureWritable(updated.datasetStorePath)) {
@@ -51752,10 +52541,10 @@ function createManagedAdapterRegistryClient(dependencies = {}) {
   const fetchImpl = dependencies.fetchImpl ?? fetch;
   const resolveRegistryAccess = dependencies.resolveRegistryAccess ?? ((teamId) => resolveManagedAdapterUserAccess({ teamId }));
   const resolveInferenceAccess = dependencies.resolveInferenceAccess ?? ((teamId) => resolveManagedAdapterUserAccess({ teamId }));
-  async function requestJson2(resolveAccess, teamId, path62, init = {}) {
+  async function requestJson2(resolveAccess, teamId, path63, init = {}) {
     const access5 = await resolveAccess(teamId);
     assertResolvedTeam(access5.teamId, teamId);
-    const requestUrl = `${access5.apiBaseUrl}${path62}`;
+    const requestUrl = `${access5.apiBaseUrl}${path63}`;
     const headers = withVercelProtectionBypass(
       requestUrl,
       hostedApiAuthHeaders(access5.token),
@@ -52385,10 +53174,10 @@ async function createOpenPondServer(options = {}) {
   const harnessEvaluationReviewStream = createLocalHarnessEvaluationReviewModelStream(streamOpenPondHostedChatTurn2);
   const executeWebSearch = createWebSearchExecutorFromEnv();
   const executeConnectedAppTool = createCloudConnectedAppToolExecutor();
-  const attachmentRootDir = path61.join(storeDir, "attachments");
+  const attachmentRootDir = path62.join(storeDir, "attachments");
   const logger = createLogger({
     channel: "server",
-    logDir: path61.join(storeDir, "logs"),
+    logDir: path62.join(storeDir, "logs"),
     metadata: {
       version,
       runtimeVersion
@@ -52578,14 +53367,27 @@ async function createOpenPondServer(options = {}) {
     store,
     defaultSessionCwd,
     createManagedLocalWorkCwd: async (sessionId) => {
-      const workspacePath = path61.join(storeDir, "work", "tasks", sessionId);
-      await fs25.mkdir(workspacePath, { recursive: true, mode: 448 });
+      const workspacePath = path62.join(storeDir, "work", "tasks", sessionId);
+      await fs26.mkdir(workspacePath, { recursive: true, mode: 448 });
       return workspacePath;
     },
     loadAppPreferences,
     appendRuntimeEvent,
     loadLastUsedProfile: async () => (await loadOpenPondProfileLibrary()).lastUsed
   });
+  const sessionTitleService = createSessionTitleService({
+    appendRuntimeEvent,
+    getSession,
+    logger,
+    stream: streamOpenPondHostedChatTurn2,
+    updateSession
+  });
+  const createSessionWithAutoTitle = async (payload) => {
+    const prompt = autoTitlePromptFromPayload(payload);
+    const session = await createSession(withPendingAutoTitle(payload));
+    if (prompt) sessionTitleService.schedule(session.id, prompt);
+    return session;
+  };
   const {
     activeWorkspace,
     appendWorkspaceDiffEvent,
@@ -52682,7 +53484,7 @@ async function createOpenPondServer(options = {}) {
   const tasksetAuthoringSkillText = tasksetAuthoringSkillArtifact.bundle;
   const taskCreatorService = createTaskCreatorService({
     store,
-    tasksetRootDir: path61.join(storeDir, "training", "tasksets"),
+    tasksetRootDir: path62.join(storeDir, "training", "tasksets"),
     authoringSkillHash: contentHash(tasksetAuthoringSkillText),
     loadCodexHistoryThread: (sessionId) => readCodexHistoryThreadPayload(sessionId, {
       attachmentRootDir,
@@ -52711,7 +53513,7 @@ async function createOpenPondServer(options = {}) {
   });
   const datasetArtifactService = createDatasetArtifactService({
     store,
-    workerProjectDir: path61.resolve(process.cwd(), "python", "openpond-datasets")
+    workerProjectDir: path62.resolve(process.cwd(), "python", "openpond-datasets")
   });
   const {
     benchmarkTasksets,
@@ -52815,7 +53617,7 @@ async function createOpenPondServer(options = {}) {
   const trainingChatSearchService = createTrainingChatSearchService({ store });
   const datasetImportService = createDatasetImportService({
     store,
-    workerProjectDir: path61.resolve(
+    workerProjectDir: path62.resolve(
       process.cwd(),
       "python",
       "openpond-datasets"
@@ -53039,7 +53841,7 @@ async function createOpenPondServer(options = {}) {
           nextStep: response2.items.length === 0 ? "There are no pinned or saved files." : `Listed ${response2.items.length} sidebar file${response2.items.length === 1 ? "" : "s"}.`
         };
       }
-      const path62 = normalizeSidebarFilePath(requestedPath ?? "");
+      const path63 = normalizeSidebarFilePath(requestedPath ?? "");
       const workspaceId = session.workspaceId ?? session.localProjectId ?? session.appId;
       if (!workspaceId) {
         throw new Error(
@@ -53052,18 +53854,18 @@ async function createOpenPondServer(options = {}) {
         workspaceKind,
         workspaceId,
         workspaceName,
-        path: path62,
+        path: path63,
         status: action === "pin" ? "pinned" : action === "save_for_later" ? "saved_for_later" : "none",
         sourceSessionId: session.id
       });
       const changed = response.items.find(
-        (item) => item.workspaceKind === workspaceKind && item.workspaceId === workspaceId && item.path === path62
+        (item) => item.workspaceKind === workspaceKind && item.workspaceId === workspaceId && item.path === path63
       ) ?? null;
       const verb = action === "pin" ? "Pinned" : action === "save_for_later" ? "Saved" : "Removed";
       return {
         ...response,
         changed,
-        nextStep: `${verb} ${path62}${action === "save_for_later" ? " for later" : ""}.`
+        nextStep: `${verb} ${path63}${action === "save_for_later" ? " for later" : ""}.`
       };
     },
     listIntegrationConnections: listSandboxIntegrationConnections,
@@ -53579,13 +54381,14 @@ async function createOpenPondServer(options = {}) {
   });
   const harnessEvaluationReviewScheduler = createLocalHarnessEvaluationReviewScheduler({
     store,
+    storeDir,
     stream: harnessEvaluationReviewStream,
     isClosing: () => closing,
     logger
   });
   const agentRuntime = createAppServer({
     ports: createAgentRuntimePorts({
-      createSession,
+      createSession: createSessionWithAutoTitle,
       getSession,
       turnsForSession: (sessionId) => store.turnsForSession(sessionId, 1e3),
       runtimeEventsForSession: (sessionId) => store.runtimeEventsForSession(sessionId),
@@ -53599,7 +54402,8 @@ async function createOpenPondServer(options = {}) {
       reviewHarness: (request) => reviewSelectedLocalHarnessEvaluation({
         store,
         request,
-        stream: harnessEvaluationReviewStream
+        stream: harnessEvaluationReviewStream,
+        continuation: { storeDir, stream: harnessEvaluationReviewStream }
       }),
       acceptHarnessEvaluationReview: async (request) => {
         const profile = await loadOpenPondProfileState();
@@ -53763,7 +54567,7 @@ async function createOpenPondServer(options = {}) {
       browserControlComplete: browserControlQueue.completeRequest,
       browserControlStatus: browserControlQueue.status,
       agentRuntime,
-      createSession,
+      createSession: createSessionWithAutoTitle,
       patchSession: patchSessionPayload,
       sendTurn,
       runSessionCommand: runSessionCommandPayload,