openpond 0.0.49 → 0.0.51

package/dist/chunks/{chunk-3BR4ACFF.js → chunk-3PYU3XCS.js}

@@ -14,7 +14,7 @@ import {
   ToolDeclarationSchema,
   createHarnessAdvanceReceipt,
   validateConnectedAppToolCallRequest
-} from "./chunk-7G472COA.js";
+} from "./chunk-35OYRVVH.js";
 import {
   external_exports,
   yaml
@@ -243,10 +243,10 @@ function sha256Hex(contents) {
 
 // ../../packages/cloud/dist/profile/local-profile.js
 import { createRequire } from "node:module";
-import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import { cp, mkdir, readFile as readFile5, readdir as readdir2, rename, rm, symlink, writeFile as writeFile2 } from "node:fs/promises";
+import { cp, mkdir, readFile as readFile5, readdir as readdir2, rename, rm as rm2, symlink, writeFile as writeFile2 } from "node:fs/promises";
 import path8 from "node:path";
 
 // ../../packages/cloud/dist/config.js
@@ -1488,8 +1488,9 @@ function text3(value) {
 
 // ../../packages/cloud/dist/profile/profile-git.js
 import { spawn } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile3, writeFile } from "node:fs/promises";
+import { readFile as readFile3, rm, writeFile } from "node:fs/promises";
 import path5 from "node:path";
 var PROFILE_REPO_GITIGNORE = [
   "**/node_modules/",
@@ -1634,6 +1635,80 @@ async function commitProfileChanges(repoPath, message) {
 async function profileGitHead(repoPath) {
   return gitText(repoPath, ["rev-parse", "HEAD"]);
 }
+async function commitProfileBenchmarkRef(input) {
+  const state = await loadProfileGitState(input.repoPath);
+  if (!state.isRepo) {
+    throw new Error(state.error ?? "Active OpenPond profile source is not a Git repo.");
+  }
+  const baseCommit = input.baseCommit ?? state.head;
+  if (!baseCommit)
+    throw new Error("A Profile benchmark requires an admitted Git commit.");
+  const runSegment = safeGitSegment(input.runId);
+  const ref = `refs/openpond/benchmarks/${runSegment}`;
+  const existing = await gitText(input.repoPath, ["rev-parse", "--verify", ref]);
+  if (existing) {
+    return {
+      ref,
+      commit: existing,
+      baseCommit,
+      paths: input.files.map((file) => safeGitPath(file.path)).sort()
+    };
+  }
+  const files = input.files.map((file) => ({ ...file, path: safeGitPath(file.path) })).sort((left, right) => left.path.localeCompare(right.path));
+  if (!files.length)
+    throw new Error("A Profile benchmark commit requires at least one file.");
+  if (new Set(files.map((file) => file.path)).size !== files.length) {
+    throw new Error("A Profile benchmark commit cannot contain duplicate paths.");
+  }
+  const indexPath = path5.join(input.repoPath, ".git", `openpond-benchmark-index-${randomUUID2()}`);
+  const env = {
+    ...process.env,
+    GIT_INDEX_FILE: indexPath,
+    GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME || "OpenPond",
+    GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL || "openpond@example.invalid",
+    GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME || "OpenPond",
+    GIT_COMMITTER_EMAIL: process.env.GIT_COMMITTER_EMAIL || "openpond@example.invalid"
+  };
+  try {
+    await requireGitSuccess(input.repoPath, ["read-tree", baseCommit], "git read-tree", { env });
+    for (const file of files) {
+      const blob = await requireGitSuccess(input.repoPath, ["hash-object", "-w", "--stdin"], `git hash-object ${file.path}`, { env, input: file.contents });
+      await requireGitSuccess(input.repoPath, ["update-index", "--add", "--cacheinfo", `100644,${blob.stdout.trim()},${file.path}`], `git update-index ${file.path}`, { env });
+    }
+    const tree = await requireGitSuccess(input.repoPath, ["write-tree"], "git write-tree", { env });
+    const commit = await requireGitSuccess(input.repoPath, [
+      "commit-tree",
+      tree.stdout.trim(),
+      "-p",
+      baseCommit,
+      "-m",
+      input.message ?? `Preserve OpenPond benchmark ${input.runId}`
+    ], "git commit-tree", { env });
+    await requireGitSuccess(input.repoPath, ["update-ref", ref, commit.stdout.trim()], "git update-ref", { env });
+    return {
+      ref,
+      commit: commit.stdout.trim(),
+      baseCommit,
+      paths: files.map((file) => file.path)
+    };
+  } finally {
+    await rm(indexPath, { force: true }).catch(() => void 0);
+  }
+}
+function safeGitSegment(value) {
+  const segment = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
+  if (!segment || segment === "." || segment === "..") {
+    throw new Error("Benchmark run id cannot form a safe Git ref.");
+  }
+  return segment;
+}
+function safeGitPath(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized.split("/").some((segment) => !segment || segment === "." || segment === "..") || normalized.includes("\0")) {
+    throw new Error(`Unsafe benchmark Git path: ${value}`);
+  }
+  return normalized;
+}
 async function hasGitHead(repoPath) {
   const result = await runGitCommand(repoPath, ["rev-parse", "--verify", "HEAD"]);
   return result.code === 0;
@@ -1724,8 +1799,18 @@ async function runGitCommand(repoPath, args, options = {}) {
     proc.on("close", (code) => {
       resolve({ code, stdout, stderr });
     });
+    if (options.input !== void 0)
+      proc.stdin?.end(options.input);
+    else
+      proc.stdin?.end();
   });
 }
+async function requireGitSuccess(repoPath, args, label, options = {}) {
+  const result = await runGitCommand(repoPath, args, options);
+  if (result.code !== 0)
+    throw new Error(gitFailureMessage(label, result));
+  return result;
+}
 
 // ../../packages/cloud/dist/profile/profile-source-upload.js
 import { stat as stat3 } from "node:fs/promises";
@@ -2239,8 +2324,8 @@ async function installAgentPackageIntoActiveProfile(input) {
   if (targetExists && input.overwrite !== true) {
     throw new Error(`Agent "${agentPackage.agentId}" already exists. Confirm replacement to install this version.`);
   }
-  const temporary = path8.join(agentsRoot, `.${agentPackage.agentId}.${randomUUID2()}.installing`);
-  const backup = path8.join(agentsRoot, `.${agentPackage.agentId}.${randomUUID2()}.backup`);
+  const temporary = path8.join(agentsRoot, `.${agentPackage.agentId}.${randomUUID3()}.installing`);
+  const backup = path8.join(agentsRoot, `.${agentPackage.agentId}.${randomUUID3()}.backup`);
   const manifest = await readProfileManifest(active.config.repoPath);
   const originalManifest = JSON.stringify(manifest);
   let movedExisting = false;
@@ -2269,11 +2354,11 @@ async function installAgentPackageIntoActiveProfile(input) {
     };
     await writeProfileManifest(active.config.repoPath, manifest);
     if (movedExisting)
-      await rm(backup, { recursive: true, force: true });
+      await rm2(backup, { recursive: true, force: true });
   } catch (error) {
-    await rm(temporary, { recursive: true, force: true });
+    await rm2(temporary, { recursive: true, force: true });
     if (installed)
-      await rm(target, { recursive: true, force: true });
+      await rm2(target, { recursive: true, force: true });
     if (movedExisting && existsSync4(backup))
       await rename(backup, target);
     if (JSON.stringify(manifest) !== originalManifest) {
@@ -3708,9 +3793,9 @@ function invalidSource(source) {
 }
 
 // ../../packages/cloud/dist/extensions/extension-manager.js
-import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile6, rename as rename2, rm as rm2, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile6, rename as rename2, rm as rm3, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import path10 from "node:path";
 var REGISTRY_SCHEMA_VERSION = 1;
 var OPERATION_LOCK_STALE_MS = 2 * 60 * 1e3;
@@ -3853,7 +3938,7 @@ function createGithubExtensionManager(options = {}) {
       const registry = await readRegistry(registryPath);
       const existing = requireInstalled(registry, identity.id);
       const target = extensionDirectory(rootPath, identity.owner, identity.repo);
-      const trash = `${target}.${randomUUID3()}.remove`;
+      const trash = `${target}.${randomUUID4()}.remove`;
       if (existsSync5(target))
         await rename2(target, trash);
       try {
@@ -3861,7 +3946,7 @@ function createGithubExtensionManager(options = {}) {
           ...current,
           extensions: current.extensions.filter((extension) => extension.id !== existing.id)
         }));
-        await rm2(trash, { recursive: true, force: true });
+        await rm3(trash, { recursive: true, force: true });
         return existing;
       } catch (error) {
         if (existsSync5(trash) && !existsSync5(target))
@@ -3927,11 +4012,11 @@ function createGithubExtensionManager(options = {}) {
 async function materializeExtension(input) {
   const preview = input.resolution.preview;
   const target = extensionDirectory(input.rootPath, preview.owner, preview.repo);
-  const temporary = `${target}.${randomUUID3()}.install`;
+  const temporary = `${target}.${randomUUID4()}.install`;
   const backup = backupDirectory(input.rootPath, preview.id);
   const current = path10.join(temporary, "current");
-  await rm2(temporary, { recursive: true, force: true });
-  await rm2(backup, { recursive: true, force: true });
+  await rm3(temporary, { recursive: true, force: true });
+  await rm3(backup, { recursive: true, force: true });
   await mkdir2(current, { recursive: true, mode: 448 });
   try {
     await input.github.download(input.resolution, async (relativePath, bytes, executable) => {
@@ -3948,7 +4033,7 @@ async function materializeExtension(input) {
     await rename2(temporary, target);
     return extension;
   } catch (error) {
-    await rm2(temporary, { recursive: true, force: true });
+    await rm3(temporary, { recursive: true, force: true });
     if (existsSync5(backup) && !existsSync5(target))
       await rename2(backup, target);
     throw error;
@@ -3969,13 +4054,13 @@ function installedExtension(preview, target, installedAt, updatedAt) {
   };
 }
 async function finalizeMaterialization(rootPath, id) {
-  await rm2(backupDirectory(rootPath, id), { recursive: true, force: true });
+  await rm3(backupDirectory(rootPath, id), { recursive: true, force: true });
 }
 async function rollbackMaterialization(rootPath, id) {
   const identity = parseGithubExtensionSource(id.replace(/^github:/, ""));
   const target = extensionDirectory(rootPath, identity.owner, identity.repo);
   const backup = backupDirectory(rootPath, id);
-  await rm2(target, { recursive: true, force: true });
+  await rm3(target, { recursive: true, force: true });
   if (existsSync5(backup))
     await rename2(backup, target);
 }
@@ -4139,7 +4224,7 @@ async function withExtensionLock(rootPath, id, operation) {
         throw error;
       const lockStat = await stat4(lockPath).catch(() => null);
       if (lockStat && Date.now() - lockStat.mtimeMs > OPERATION_LOCK_STALE_MS) {
-        await rm2(lockPath, { recursive: true, force: true });
+        await rm3(lockPath, { recursive: true, force: true });
         continue;
       }
       if (Date.now() >= deadline) {
@@ -4154,7 +4239,7 @@ async function withExtensionLock(rootPath, id, operation) {
   try {
     return await operation();
   } finally {
-    await rm2(lockPath, { recursive: true, force: true });
+    await rm3(lockPath, { recursive: true, force: true });
   }
 }
 function extensionSort(left, right) {
@@ -4162,7 +4247,7 @@ function extensionSort(left, right) {
 }
 
 // ../../packages/cloud/dist/profile/hosted-run-idempotency.js
-import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID5 } from "node:crypto";
 function buildHostedRunIdempotencyKey(input) {
   const explicit = input.explicitKey?.trim();
   if (explicit)
@@ -4173,7 +4258,7 @@ function buildHostedRunIdempotencyKey(input) {
   const base = `profile-push-run:${input.localHead}:${sourceHead}:${input.runtimeAgentId}:${targetProjectId}:${inputHash}`;
   if (!input.retry)
     return base;
-  return `${base}:retry:${(input.randomId ?? randomUUID4)()}`;
+  return `${base}:retry:${(input.randomId ?? randomUUID5)()}`;
 }
 function hashStableJson(value) {
   return createHash6("sha256").update(stableJsonStringify(value)).digest("hex");
@@ -4426,7 +4511,6 @@ function sidebarFileBookmarkId(input) {
 var PROVIDER_IDS = [
   "openpond",
   "codex",
-  "local-adapter",
   "anthropic",
   "openai",
   "xai",
@@ -8594,6 +8678,31 @@ var DatasetRowPageSchema = external_exports.object({
   totalRows: external_exports.number().int().nonnegative(),
   returnedRows: external_exports.number().int().nonnegative()
 });
+var DatasetStorageSettingsSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.datasetStorageSettings.v1"),
+  datasetStorePath: external_exports.string().trim().min(1).max(4e3),
+  updatedAt: TimestampSchema2
+});
+var DatasetStorageRootSchema = external_exports.object({
+  id: IdSchema2,
+  label: external_exports.string().trim().min(1).max(500),
+  path: external_exports.string().trim().min(1).max(4e3),
+  datasetStorePath: external_exports.string().trim().min(1).max(4e3),
+  kind: external_exports.enum(["local", "network", "removable", "cache"]),
+  configured: external_exports.boolean(),
+  mounted: external_exports.boolean(),
+  writable: external_exports.boolean(),
+  totalBytes: external_exports.number().int().nonnegative().nullable(),
+  freeBytes: external_exports.number().int().nonnegative().nullable()
+});
+var DatasetStorageStateSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.datasetStorageState.v1"),
+  settings: DatasetStorageSettingsSchema,
+  storageRoots: external_exports.array(DatasetStorageRootSchema)
+});
+var UpdateDatasetStorageSettingsRequestSchema = external_exports.object({
+  datasetStorePath: external_exports.string().trim().min(1).max(4e3)
+});
 
 // ../../packages/contracts/dist/dataset-sources.js
 var IdSchema3 = external_exports.string().trim().min(1).max(240);
@@ -8751,6 +8860,25 @@ var TasksetStatusSchema = external_exports.enum([
   "failed",
   "archived"
 ]);
+var TasksetPurposeSchema = external_exports.enum(["general", "benchmark"]);
+var TasksetBenchmarkBindingSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.tasksetBenchmark.v1"),
+  definitionId: IdSchema4,
+  releaseId: IdSchema4,
+  releaseHash: Sha256Schema,
+  managedReleasePath: external_exports.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
+  adaptationSplit: TasksetSplitSchema,
+  evaluationSplit: TasksetSplitSchema,
+  primaryMetric: external_exports.enum([
+    "foreground_tokens",
+    "success_rate",
+    "latency_ms",
+    "cost_usd"
+  ]),
+  qualityGate: external_exports.enum(["none", "non_regression", "all_pass"]),
+  source: external_exports.enum(["builtin", "imported"]),
+  metadata: MetadataSchema6
+});
 var TaskCreationSurfaceSchema = external_exports.enum([
   "slash_train",
   "session_menu",
@@ -9214,7 +9342,7 @@ var TasksetReadinessReportSchema = external_exports.object({
   recommendedMethod: external_exports.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
   trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
   methodReadiness: external_exports.array(TrainingMethodReadinessSchema).default([]),
-  compatibleDestinationClasses: external_exports.array(external_exports.enum(["export", "local_cpu_fixture", "custom", "hosted_managed"])),
+  compatibleDestinationClasses: external_exports.array(external_exports.enum(["export", "custom", "hosted_managed"])),
   blockers: external_exports.array(external_exports.object({ code: IdSchema4, message: external_exports.string().trim().min(1).max(5e3), path: external_exports.string().trim().max(2e3).nullable() })).default([]),
   warnings: external_exports.array(external_exports.string().trim().min(1).max(5e3)).default([]),
   generatedAt: TimestampSchema4
@@ -9265,6 +9393,8 @@ var TasksetSchema = external_exports.object({
   createImproveRunId: NullableIdSchema.default(null),
   name: external_exports.string().trim().min(1).max(500),
   objective: external_exports.string().trim().min(1).max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
   status: TasksetStatusSchema,
   sourceRefs: external_exports.array(TasksetSourceRefSchema).min(1).max(1e5),
   datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
@@ -9282,6 +9412,20 @@ var TasksetSchema = external_exports.object({
   updatedAt: TimestampSchema4,
   metadata: MetadataSchema6
 }).superRefine((taskset, context) => {
+  if (taskset.purpose === "benchmark" && !taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark Tasksets require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (taskset.purpose !== "benchmark" && taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark Tasksets may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
   if (taskset.datasetArtifact && taskset.tasks.length > 0) {
     context.addIssue({
       code: "custom",
@@ -9693,6 +9837,204 @@ var ModelRunReceiptSchema = external_exports.object({
   telemetry: CorrelatedTelemetryReceiptSchema.nullable().default(null),
   contentHash: ReleaseHashSchema
 }).strict();
+var EvaluationUsageCategorySchema = external_exports.object({
+  inputTokens: external_exports.number().int().nonnegative(),
+  outputTokens: external_exports.number().int().nonnegative(),
+  totalTokens: external_exports.number().int().nonnegative(),
+  costUsd: external_exports.number().nonnegative().nullable()
+}).strict();
+var GitObjectIdSchema = external_exports.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
+var ModelEvaluationAttemptSchema = external_exports.object({
+  phase: external_exports.enum([
+    "baseline",
+    "adaptation",
+    "candidate_adaptation",
+    "candidate"
+  ]),
+  taskId: ReleaseIdSchema,
+  attemptId: ReleaseIdSchema,
+  sessionId: ReleaseIdSchema.nullable(),
+  turnId: ReleaseIdSchema.nullable(),
+  passed: external_exports.boolean(),
+  score: external_exports.number().min(0).max(1).nullable(),
+  failureClass: TaskFailureClassSchema.nullable(),
+  inputTokens: external_exports.number().int().nonnegative(),
+  outputTokens: external_exports.number().int().nonnegative(),
+  totalTokens: external_exports.number().int().nonnegative(),
+  latencyMs: external_exports.number().int().nonnegative(),
+  costUsd: external_exports.number().nonnegative().nullable(),
+  startedAt: ReleaseTimestampSchema
+}).strict();
+var ModelEvaluationTaskEfficiencyCohortSchema = external_exports.object({
+  targetTaskCount: external_exports.number().int().nonnegative(),
+  comparedTaskCount: external_exports.number().int().nonnegative(),
+  passedTaskCount: external_exports.number().int().nonnegative(),
+  failedTaskCount: external_exports.number().int().nonnegative(),
+  lowerTaskCount: external_exports.number().int().nonnegative(),
+  higherTaskCount: external_exports.number().int().nonnegative(),
+  unchangedTaskCount: external_exports.number().int().nonnegative()
+}).strict();
+var ModelEvaluationTaskEfficiencySchema = external_exports.object({
+  target: external_exports.literal("all_tasks_lower"),
+  targetTaskCount: external_exports.number().int().nonnegative(),
+  comparedTaskCount: external_exports.number().int().nonnegative(),
+  passedTaskCount: external_exports.number().int().nonnegative(),
+  failedTaskCount: external_exports.number().int().nonnegative(),
+  lowerTaskCount: external_exports.number().int().nonnegative(),
+  higherTaskCount: external_exports.number().int().nonnegative(),
+  unchangedTaskCount: external_exports.number().int().nonnegative(),
+  baselineTokens: external_exports.number().int().nonnegative(),
+  refinedTokens: external_exports.number().int().nonnegative(),
+  tokenDelta: external_exports.number().int(),
+  tokenDeltaPercent: external_exports.number().finite().nullable(),
+  complete: external_exports.boolean(),
+  passed: external_exports.boolean(),
+  cohorts: external_exports.object({
+    adaptation: ModelEvaluationTaskEfficiencyCohortSchema,
+    heldOut: ModelEvaluationTaskEfficiencyCohortSchema
+  }).strict()
+}).strict();
+var ModelEvaluationUsageSchema = external_exports.object({
+  baseline: EvaluationUsageCategorySchema,
+  adaptation: EvaluationUsageCategorySchema,
+  candidateAdaptation: EvaluationUsageCategorySchema,
+  candidate: EvaluationUsageCategorySchema,
+  refiner: EvaluationUsageCategorySchema,
+  grader: EvaluationUsageCategorySchema
+}).strict();
+var ModelEvaluationAccountingSchema = external_exports.object({
+  usage: ModelEvaluationUsageSchema,
+  observedSpendUsd: external_exports.number().nonnegative(),
+  attempts: external_exports.array(ModelEvaluationAttemptSchema).max(1e4)
+}).strict();
+var ModelEvaluationEvidenceSnapshotSchema = external_exports.object({
+  id: ReleaseIdSchema,
+  contentHash: ReleaseHashSchema,
+  artifactPath: external_exports.string().trim().min(1).max(2e3)
+}).strict();
+var ModelEvaluationReceiptSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelEvaluationReceipt.v1"),
+  benchmarkId: ReleaseIdSchema,
+  resultManifest: external_exports.object({
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema,
+    artifactPath: external_exports.string().trim().min(1).max(2e3)
+  }).strict(),
+  stages: external_exports.object({
+    baseline: ImmutableReleaseRefSchema,
+    adaptation: ImmutableReleaseRefSchema,
+    refiner: ImmutableReleaseRefSchema,
+    candidateAdaptation: ImmutableReleaseRefSchema,
+    candidate: ImmutableReleaseRefSchema,
+    comparison: ImmutableReleaseRefSchema
+  }).strict(),
+  usage: ModelEvaluationUsageSchema,
+  quality: external_exports.object({
+    baselinePassRate: external_exports.number().min(0).max(1),
+    candidatePassRate: external_exports.number().min(0).max(1),
+    adaptationBaselinePassRate: external_exports.number().min(0).max(1),
+    adaptationCandidatePassRate: external_exports.number().min(0).max(1),
+    adaptationCandidatePassed: external_exports.boolean(),
+    heldOutCandidatePassed: external_exports.boolean(),
+    passed: external_exports.boolean()
+  }).strict(),
+  foregroundTokenDelta: external_exports.number().int(),
+  foregroundTokenDeltaPercent: external_exports.number().finite().nullable(),
+  taskEfficiency: ModelEvaluationTaskEfficiencySchema.optional(),
+  efficiency: external_exports.object({
+    grossForegroundTokenSavings: external_exports.number().int(),
+    overheadTokens: external_exports.number().int().nonnegative(),
+    firstPassNetTokenSavings: external_exports.number().int(),
+    breakEvenReuseCount: external_exports.number().int().nonnegative().nullable(),
+    amortizedTokenSavings: external_exports.number().int(),
+    amortizedReuseCount: external_exports.number().int().positive()
+  }).strict(),
+  budget: external_exports.object({
+    maximumSpendUsd: external_exports.number().nonnegative(),
+    observedSpendUsd: external_exports.number().nonnegative(),
+    enforced: external_exports.boolean()
+  }).strict(),
+  evidenceSnapshot: ImmutableReleaseRefSchema,
+  lineage: external_exports.object({
+    adaptationEvidenceHash: ReleaseHashSchema,
+    refinerInputHash: ReleaseHashSchema,
+    refinerOutcomeHash: ReleaseHashSchema,
+    validationHash: ReleaseHashSchema,
+    applyReceiptHash: ReleaseHashSchema,
+    candidateRelease: ImmutableReleaseRefSchema,
+    valid: external_exports.boolean()
+  }).strict(),
+  invalidReasons: external_exports.array(external_exports.string().trim().min(1).max(2e3)).max(100),
+  attempts: external_exports.array(ModelEvaluationAttemptSchema).max(1e4).default([]),
+  terminalClassification: external_exports.enum([
+    "improved",
+    "no_improvement",
+    "regressed",
+    "inconclusive",
+    "cancelled",
+    "infrastructure_failure"
+  ]),
+  profileGit: external_exports.object({
+    ref: external_exports.string().trim().min(1).max(2e3),
+    commit: GitObjectIdSchema,
+    baseCommit: GitObjectIdSchema
+  }).strict().nullable(),
+  contentHash: ReleaseHashSchema
+}).strict();
+var ModelEvaluationStopReceiptSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.modelEvaluationStopReceipt.v1"),
+  benchmarkId: ReleaseIdSchema,
+  terminalClassification: external_exports.literal("inconclusive"),
+  stopReason: external_exports.enum([
+    "candidate_harness_unchanged",
+    "candidate_lineage_invalid"
+  ]),
+  reason: external_exports.string().trim().min(1).max(5e3),
+  stoppedAfter: external_exports.literal("refiner"),
+  baselineHarness: ImmutableReleaseRefSchema,
+  candidateHarness: ImmutableReleaseRefSchema,
+  refiner: external_exports.object({
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema,
+    outcomeCount: external_exports.number().int().nonnegative()
+  }).strict(),
+  usage: ModelEvaluationUsageSchema,
+  budget: external_exports.object({
+    maximumSpendUsd: external_exports.number().nonnegative(),
+    observedSpendUsd: external_exports.number().nonnegative(),
+    enforced: external_exports.boolean()
+  }).strict(),
+  evidenceSnapshot: ImmutableReleaseRefSchema,
+  attempts: external_exports.array(ModelEvaluationAttemptSchema).max(1e4),
+  contentHash: ReleaseHashSchema
+}).strict();
+var ModelEvaluationConfigurationSchema = external_exports.object({
+  benchmarkId: ReleaseIdSchema,
+  model: ChatModelRefSchema,
+  upstreamModel: external_exports.object({
+    providerId: ReleaseIdSchema,
+    modelId: external_exports.string().trim().min(1).max(300),
+    revision: external_exports.string().trim().min(1).max(300),
+    pricing: external_exports.object({
+      version: external_exports.string().trim().min(1).max(300),
+      source: external_exports.string().trim().min(1).max(300),
+      effectiveAt: ReleaseTimestampSchema,
+      inputUsdPerMillionTokens: external_exports.number().nonnegative(),
+      cachedInputUsdPerMillionTokens: external_exports.number().nonnegative(),
+      outputUsdPerMillionTokens: external_exports.number().nonnegative()
+    }).strict().optional()
+  }).strict(),
+  reasoningEffort: external_exports.string().trim().min(1).max(100).nullable(),
+  seeds: external_exports.array(external_exports.number().int()).min(1).max(100),
+  repetitions: external_exports.number().int().positive().max(20),
+  maximumSpendUsd: external_exports.number().nonnegative(),
+  attemptPlan: external_exports.array(external_exports.object({
+    stage: external_exports.enum(["baseline", "adaptation", "candidate_adaptation", "candidate"]),
+    split: external_exports.string().trim().min(1).max(100),
+    taskIds: external_exports.array(ReleaseIdSchema).min(1).max(1e5),
+    attemptCount: external_exports.number().int().positive()
+  }).strict()).length(4)
+}).strict();
 var ModelRunSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.modelRun.v1"),
   id: ReleaseIdSchema,
@@ -9716,19 +10058,38 @@ var ModelRunSchema = external_exports.object({
     "opd",
     "opsd",
     "sdpo"
-  ]),
-  destinationId: ReleaseIdSchema,
+  ]).nullable(),
+  destinationId: ReleaseIdSchema.nullable(),
   taskset: VersionedReleaseRefSchema,
   harnessRelease: ImmutableReleaseRefSchema.nullable().optional(),
   quote: external_exports.object({
     maximumSpendUsd: external_exports.number().nonnegative(),
     hourlyCostUsd: external_exports.number().nonnegative().nullable()
-  }).strict(),
+  }).strict().nullable(),
+  evaluation: ModelEvaluationConfigurationSchema.nullable().default(null),
+  evaluationProgress: external_exports.object({
+    stage: external_exports.enum([
+      "baseline",
+      "adaptation",
+      "refiner",
+      "candidate_adaptation",
+      "candidate",
+      "comparison"
+    ]),
+    completedAttempts: external_exports.number().int().nonnegative(),
+    totalAttempts: external_exports.number().int().positive(),
+    accounting: ModelEvaluationAccountingSchema.nullable().default(null),
+    evidenceSnapshot: ModelEvaluationEvidenceSnapshotSchema.nullable().default(null)
+  }).strict().nullable().default(null),
   reward: external_exports.object({
     raw: external_exports.number(),
     components: external_exports.record(external_exports.string(), external_exports.number())
   }).strict().nullable(),
-  receipt: ModelRunReceiptSchema.nullable(),
+  receipt: external_exports.union([
+    ModelRunReceiptSchema,
+    ModelEvaluationReceiptSchema,
+    ModelEvaluationStopReceiptSchema
+  ]).nullable(),
   adapterArtifactLineageId: ReleaseIdSchema.nullable(),
   failure: external_exports.string().trim().min(1).max(5e3).nullable(),
   startedAt: ReleaseTimestampSchema,
@@ -9741,6 +10102,24 @@ var ModelRunSchema = external_exports.object({
       message: "A successful Model Run requires a canonical receipt."
     });
   }
+  if (run.kind === "evaluation" && (run.method !== null || run.destinationId !== null || !run.evaluation || run.adapterArtifactLineageId !== null)) {
+    context.addIssue({
+      code: "custom",
+      message: "An evaluation Model Run requires evaluation configuration and cannot claim training method, destination, or adapter lineage."
+    });
+  }
+  if (run.kind === "evaluation" && run.receipt && run.receipt.schemaVersion !== "openpond.modelEvaluationReceipt.v1" && run.receipt.schemaVersion !== "openpond.modelEvaluationStopReceipt.v1") {
+    context.addIssue({
+      code: "custom",
+      message: "An evaluation Model Run requires an evaluation receipt."
+    });
+  }
+  if (run.kind !== "evaluation" && (run.method === null || run.destinationId === null || run.quote === null)) {
+    context.addIssue({
+      code: "custom",
+      message: "A training or rollout Model Run requires method, destination, and quote."
+    });
+  }
   if (run.kind === "rollout_smoke" && run.adapterArtifactLineageId !== null) {
     context.addIssue({
       code: "custom",
@@ -9748,6 +10127,71 @@ var ModelRunSchema = external_exports.object({
     });
   }
 });
+function summarizeModelEvaluationTaskEfficiency(input) {
+  const selected = /* @__PURE__ */ new Map();
+  for (const attempt of input.attempts) {
+    const key = `${attempt.phase}\0${attempt.taskId}`;
+    const current = selected.get(key);
+    if (!current || attempt.startedAt > current.startedAt || attempt.startedAt === current.startedAt && attempt.attemptId > current.attemptId) {
+      selected.set(key, attempt);
+    }
+  }
+  const attempts = [...selected.values()];
+  const pairs = [
+    ["adaptation", "adaptation", "candidate_adaptation"],
+    ["held_out", "baseline", "candidate"]
+  ].flatMap(([cohort, baselinePhase, refinedPhase]) => {
+    const refinedByTask = new Map(attempts.filter((attempt) => attempt.phase === refinedPhase).map((attempt) => [attempt.taskId, attempt]));
+    return attempts.filter((attempt) => attempt.phase === baselinePhase).flatMap((baseline) => {
+      const refined = refinedByTask.get(baseline.taskId);
+      return refined ? [{
+        cohort,
+        taskId: baseline.taskId,
+        baseline,
+        refined,
+        tokenDelta: refined.totalTokens - baseline.totalTokens
+      }] : [];
+    });
+  });
+  const defaultTargetTaskCount = new Set(attempts.filter((attempt) => attempt.phase === "baseline" || attempt.phase === "adaptation").map((attempt) => attempt.taskId)).size;
+  const targetTaskCount = input.targetTaskCount ?? defaultTargetTaskCount;
+  if (!Number.isInteger(targetTaskCount) || targetTaskCount < 0) {
+    throw new Error("Benchmark task-efficiency target must be a non-negative integer.");
+  }
+  const cohortTargetTaskCount = {
+    adaptation: new Set(attempts.filter((attempt) => attempt.phase === "adaptation").map((attempt) => attempt.taskId)).size,
+    held_out: new Set(attempts.filter((attempt) => attempt.phase === "baseline").map((attempt) => attempt.taskId)).size
+  };
+  const summarizePairs = (items, cohortTarget) => ({
+    targetTaskCount: cohortTarget,
+    comparedTaskCount: items.length,
+    passedTaskCount: items.filter((pair) => pair.tokenDelta < 0).length,
+    failedTaskCount: items.filter((pair) => pair.tokenDelta >= 0).length,
+    lowerTaskCount: items.filter((pair) => pair.tokenDelta < 0).length,
+    higherTaskCount: items.filter((pair) => pair.tokenDelta > 0).length,
+    unchangedTaskCount: items.filter((pair) => pair.tokenDelta === 0).length
+  });
+  const counts = summarizePairs(pairs, targetTaskCount);
+  const baselineTokens = pairs.reduce((sum, pair) => sum + pair.baseline.totalTokens, 0);
+  const refinedTokens = pairs.reduce((sum, pair) => sum + pair.refined.totalTokens, 0);
+  const tokenDelta = refinedTokens - baselineTokens;
+  const complete = pairs.length === targetTaskCount;
+  const summary = ModelEvaluationTaskEfficiencySchema.parse({
+    target: "all_tasks_lower",
+    ...counts,
+    baselineTokens,
+    refinedTokens,
+    tokenDelta,
+    tokenDeltaPercent: baselineTokens > 0 ? tokenDelta / baselineTokens * 100 : null,
+    complete,
+    passed: complete && counts.passedTaskCount === targetTaskCount,
+    cohorts: {
+      adaptation: summarizePairs(pairs.filter((pair) => pair.cohort === "adaptation"), cohortTargetTaskCount.adaptation),
+      heldOut: summarizePairs(pairs.filter((pair) => pair.cohort === "held_out"), cohortTargetTaskCount.held_out)
+    }
+  });
+  return { summary, pairs };
+}
 
 // ../../packages/contracts/dist/training-policy-optimization.js
 var IdSchema6 = external_exports.string().trim().min(1).max(240);
@@ -9853,7 +10297,7 @@ var DEFAULT_LOCAL_MODEL_CHAT_CONFIGURATION = LocalModelChatConfigurationSchema.p
 var ManagedAdapterServingProjectionSchema = external_exports.object({
   schemaVersion: external_exports.literal("openpond.managedAdapterServingProjection.v1"),
   teamId: TrainingIdSchema.nullable().default(null),
-  source: external_exports.enum(["openpond_training", "sandbox_managed_rl"]),
+  source: external_exports.literal("sandbox_managed_rl"),
   sourceRef: TrainingIdSchema,
   canonicalArtifactId: TrainingIdSchema.nullable(),
   canonicalArtifactState: external_exports.enum(["imported_unvalidated", "evaluating", "promotable", "rejected", "deleted"]).nullable(),
@@ -10432,7 +10876,6 @@ var TrainingMethodSchema = external_exports.enum([
 ]);
 var TrainingParameterizationSchema = external_exports.enum(["lora", "full"]);
 var TrainingDestinationIdSchema = external_exports.enum([
-  "local_cpu_fixture",
   "openpond_managed"
 ]);
 var SftRecipeSchema = external_exports.object({
@@ -11123,6 +11566,8 @@ var TrainingStateResponseSchema = external_exports.object({
   sources: external_exports.array(TrainingSourceRefSchema),
   creations: external_exports.array(TaskCreationSnapshotSchema),
   tasksets: external_exports.array(TasksetSchema),
+  benchmarkRuns: external_exports.array(external_exports.custom()).default([]),
+  benchmarkComparisons: external_exports.array(external_exports.custom()).default([]),
   datasetImports: external_exports.array(DatasetImportJobSchema).default([]),
   datasetArtifacts: external_exports.array(DatasetArtifactSummarySchema).default([]),
   graderAuditReports: external_exports.array(GraderAuditReportSchema),
@@ -11261,166 +11706,6 @@ function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
-// ../../packages/contracts/dist/compute.js
-var IdSchema7 = external_exports.string().trim().min(1).max(240);
-var TimestampSchema6 = external_exports.string().trim().datetime({ offset: true });
-var ByteCountSchema = external_exports.number().int().nonnegative();
-var OptionalByteCountSchema = ByteCountSchema.nullable();
-var ComputePlatformSchema = external_exports.enum(["darwin", "linux", "win32", "other"]);
-var ComputeDeviceKindSchema = external_exports.enum(["cpu", "gpu", "accelerator"]);
-var ComputeVendorSchema = external_exports.enum(["apple", "nvidia", "amd", "intel", "other"]);
-var ComputeProbeStateSchema = external_exports.enum(["available", "unavailable", "error"]);
-var ComputeRuntimeKindSchema = external_exports.enum([
-  "python",
-  "trl_peft",
-  "mlx",
-  "cuda",
-  "rocm",
-  "ollama",
-  "docker",
-  "podman"
-]);
-var ComputeDeviceSchema = external_exports.object({
-  id: IdSchema7,
-  kind: ComputeDeviceKindSchema,
-  vendor: ComputeVendorSchema,
-  index: external_exports.number().int().nonnegative().nullable(),
-  name: external_exports.string().trim().min(1).max(500),
-  totalMemoryBytes: OptionalByteCountSchema,
-  freeMemoryBytes: OptionalByteCountSchema,
-  physicalCoreCount: external_exports.number().int().positive().nullable(),
-  logicalCoreCount: external_exports.number().int().positive().nullable(),
-  driverVersion: external_exports.string().trim().min(1).max(200).nullable(),
-  runtimeVersion: external_exports.string().trim().min(1).max(200).nullable(),
-  computeCapability: external_exports.string().trim().min(1).max(100).nullable(),
-  supportedPrecisions: external_exports.array(external_exports.enum(["fp32", "fp16", "bf16", "tf32", "int8", "int4"])),
-  available: external_exports.boolean(),
-  unavailableReason: external_exports.string().trim().min(1).max(2e3).nullable()
-});
-var ComputeRuntimeSchema = external_exports.object({
-  id: IdSchema7,
-  kind: ComputeRuntimeKindSchema,
-  state: ComputeProbeStateSchema,
-  version: external_exports.string().trim().min(1).max(200).nullable(),
-  executable: external_exports.string().trim().min(1).max(4e3).nullable(),
-  detail: external_exports.string().trim().min(1).max(2e3).nullable()
-});
-var ComputeStorageRootSchema = external_exports.object({
-  id: IdSchema7,
-  label: external_exports.string().trim().min(1).max(500),
-  path: external_exports.string().trim().min(1).max(4e3),
-  modelStorePath: external_exports.string().trim().min(1).max(4e3),
-  datasetStorePath: external_exports.string().trim().min(1).max(4e3),
-  kind: external_exports.enum(["local", "network", "removable", "cache"]),
-  configured: external_exports.boolean(),
-  mounted: external_exports.boolean(),
-  writable: external_exports.boolean(),
-  totalBytes: OptionalByteCountSchema,
-  freeBytes: OptionalByteCountSchema
-});
-var ComputeConnectionRefSchema = external_exports.object({
-  id: IdSchema7,
-  kind: external_exports.enum(["local", "ssh", "managed", "custom"]),
-  label: external_exports.string().trim().min(1).max(500),
-  configured: external_exports.boolean(),
-  available: external_exports.boolean(),
-  lastCheckedAt: TimestampSchema6.nullable(),
-  unavailableReason: external_exports.string().trim().min(1).max(2e3).nullable()
-});
-var ModelAssetSourceSchema = external_exports.enum(["huggingface", "mlx", "ollama", "local"]);
-var ModelAssetSchema = external_exports.object({
-  id: IdSchema7,
-  name: external_exports.string().trim().min(1).max(500),
-  source: ModelAssetSourceSchema,
-  path: external_exports.string().trim().min(1).max(4e3).nullable(),
-  modelId: external_exports.string().trim().min(1).max(500).nullable(),
-  revision: external_exports.string().trim().min(1).max(256).nullable(),
-  tokenizerRevision: external_exports.string().trim().min(1).max(256).nullable(),
-  chatTemplateHash: external_exports.string().trim().regex(/^[a-f0-9]{64}$/).nullable(),
-  digest: external_exports.string().trim().min(8).max(256).nullable(),
-  family: external_exports.string().trim().min(1).max(200).nullable(),
-  parameterCount: external_exports.number().int().positive().nullable(),
-  format: external_exports.enum(["safetensors", "pytorch", "mlx", "gguf", "unknown"]),
-  quantization: external_exports.string().trim().min(1).max(100).nullable(),
-  sizeBytes: OptionalByteCountSchema,
-  inferenceCompatible: external_exports.boolean(),
-  trainingCompatible: external_exports.boolean(),
-  compatibilityReason: external_exports.string().trim().min(1).max(2e3).nullable(),
-  discoveredAt: TimestampSchema6
-});
-var ModelDownloadStatusSchema = external_exports.enum(["queued", "downloading", "verifying", "succeeded", "cancelling", "cancelled", "failed"]);
-var ModelDownloadJobSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.modelDownload.v1"),
-  id: IdSchema7,
-  modelId: IdSchema7,
-  revision: external_exports.string().trim().min(8).max(256),
-  license: external_exports.string().trim().min(1).max(200),
-  destinationPath: external_exports.string().trim().min(1).max(4e3),
-  expectedBytes: ByteCountSchema,
-  downloadedBytes: ByteCountSchema,
-  status: ModelDownloadStatusSchema,
-  error: external_exports.string().trim().min(1).max(2e4).nullable(),
-  startedAt: TimestampSchema6.nullable(),
-  completedAt: TimestampSchema6.nullable(),
-  createdAt: TimestampSchema6,
-  updatedAt: TimestampSchema6
-});
-var ComputeHostProfileSchema = external_exports.object({
-  platform: ComputePlatformSchema,
-  architecture: external_exports.string().trim().min(1).max(100),
-  operatingSystem: external_exports.string().trim().min(1).max(500),
-  hostname: external_exports.string().trim().min(1).max(500),
-  totalMemoryBytes: OptionalByteCountSchema
-});
-var ComputeSettingsSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.computeSettings.v1"),
-  modelStorePath: external_exports.string().trim().min(1).max(4e3).nullable(),
-  datasetStorePath: external_exports.string().trim().min(1).max(4e3).nullable().default(null),
-  defaultDeviceIds: external_exports.array(IdSchema7).max(64),
-  additionalModelPaths: external_exports.array(external_exports.string().trim().min(1).max(4e3)).max(32),
-  updatedAt: TimestampSchema6
-});
-var ComputeInventorySchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.computeInventory.v1"),
-  host: ComputeHostProfileSchema,
-  devices: external_exports.array(ComputeDeviceSchema),
-  runtimes: external_exports.array(ComputeRuntimeSchema),
-  storageRoots: external_exports.array(ComputeStorageRootSchema),
-  connections: external_exports.array(ComputeConnectionRefSchema),
-  models: external_exports.array(ModelAssetSchema),
-  downloads: external_exports.array(ModelDownloadJobSchema),
-  warnings: external_exports.array(external_exports.string().trim().min(1).max(2e3)).max(100),
-  scannedAt: TimestampSchema6
-});
-var ComputeCompatibilityIssueSchema = external_exports.object({
-  code: IdSchema7,
-  severity: external_exports.enum(["warning", "error"]),
-  message: external_exports.string().trim().min(1).max(2e3)
-});
-var ComputeCompatibilityReportSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.computeCompatibility.v1"),
-  compatible: external_exports.boolean(),
-  deviceIds: external_exports.array(IdSchema7),
-  modelAssetId: IdSchema7.nullable(),
-  runtimeIds: external_exports.array(IdSchema7),
-  estimatedMemoryBytes: OptionalByteCountSchema,
-  estimatedStorageBytes: OptionalByteCountSchema,
-  issues: external_exports.array(ComputeCompatibilityIssueSchema),
-  checkedAt: TimestampSchema6
-});
-var ComputeStateResponseSchema = external_exports.object({
-  schemaVersion: external_exports.literal("openpond.computeState.v1"),
-  settings: ComputeSettingsSchema,
-  inventory: ComputeInventorySchema.nullable(),
-  scanning: external_exports.boolean()
-});
-var UpdateComputeSettingsRequestSchema = external_exports.object({
-  modelStorePath: external_exports.string().trim().min(1).max(4e3).nullable().optional(),
-  datasetStorePath: external_exports.string().trim().min(1).max(4e3).nullable().optional(),
-  defaultDeviceIds: external_exports.array(IdSchema7).max(64).optional(),
-  additionalModelPaths: external_exports.array(external_exports.string().trim().min(1).max(4e3)).max(32).optional()
-});
-
 // ../../packages/contracts/dist/learning-signals.js
 var LearningSignalKindSchema = external_exports.enum([
   "trajectory",
@@ -12447,6 +12732,7 @@ export {
   buildHostedRunIdempotencyKey,
   buildOpenPondProfileSetupGate,
   formatOpenPondProfileSetupRequirement,
+  commitProfileBenchmarkRef,
   readSourceUploadCache,
   materializeSourceUploadFile,
   writeSourceUploadCache,
@@ -12549,6 +12835,7 @@ export {
   nextCreateImproveRunRevision,
   OpenPondProfileRefSchema,
   SessionSchema,
+  TurnSchema,
   ApprovalSchema,
   createPlaceholderPanes,
   SHIPPED_OPENPOND_SKILL_NAMES,
@@ -12643,6 +12930,9 @@ export {
   DatasetArtifactRegistryEntrySchema,
   DatasetRowPageRequestSchema,
   DatasetRowPageSchema,
+  DatasetStorageSettingsSchema,
+  DatasetStorageStateSchema,
+  UpdateDatasetStorageSettingsRequestSchema,
   HuggingFaceDatasetSourceRefSchema,
   ExternalDatasetSourceRefSchema,
   ImmutableReleaseRefSchema,
@@ -12674,7 +12964,10 @@ export {
   CreateHuggingFaceDatasetImportRequestSchema,
   ApproveDatasetImportMappingRequestSchema,
   ModelVersionSchema,
+  ModelEvaluationReceiptSchema,
+  ModelEvaluationStopReceiptSchema,
   ModelRunSchema,
+  summarizeModelEvaluationTaskEfficiency,
   LocalModelChatConfigurationSchema,
   managedAdapterProjectionReady,
   resolveModelBindingPromotionGate,
@@ -12685,8 +12978,6 @@ export {
   CrossSystemWorldSpecSchema,
   CROSS_SYSTEM_TOOL_DEFINITIONS,
   CROSS_SYSTEM_TOOL_CONTRACT_HASH,
-  CROSS_SYSTEM_LOCAL_TOOL_MAX_TURNS,
-  crossSystemLocalToolSystemPrompt,
   CROSS_SYSTEM_LOCAL_TOOL_SYSTEM_PROMPT,
   CrossSystemTrajectorySchema,
   CrossSystemVerifierResultSchema,
@@ -12694,7 +12985,6 @@ export {
   CrossSystemBootstrapRecordSchema,
   CrossSystemExpertBootstrapApprovalSchema,
   CrossSystemExpertBootstrapPreviewSchema,
-  PpoTrajectorySchema,
   RolloutTrajectoryReceiptSchema,
   TrainingDestinationIdSchema,
   TrainingRecipeSchema,
@@ -12720,13 +13010,6 @@ export {
   ModelBindingRoleSchema,
   ModelBindingSchema,
   estimateTrainingTaskSizing,
-  ModelAssetSchema,
-  ModelDownloadJobSchema,
-  ComputeSettingsSchema,
-  ComputeInventorySchema,
-  ComputeStateResponseSchema,
-  UpdateComputeSettingsRequestSchema,
-  LearningSignalBatchSchema,
   HarnessRunManifestContentSchema,
   HarnessRunManifestSchema,
   ResolvedTrainingBundleContentSchema,