@workbench-ai/workbench-core 0.0.46

package/dist/index.js

@@ -0,0 +1,2858 @@
+import { createHash } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import YAML from "yaml";
+import { adapterCommandName, assertWorkbenchAdapterOperationResultOk, collectWorkbenchAdapterAuthRequirements, readWorkbenchAdapterOperationResult, workbenchAdapterOperationCommand, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
+import { BENCHMARK_SPEC_FILE, engineCaseEnginePrivateFiles, engineCaseFilesForRuntimeInput, engineCaseSubjectVisibleFiles, resolveEngineCaseExecutionConfig, resolveWorkbenchResolvedSourceYaml as resolveWorkbenchResolvedSourceYamlInternal, validateWorkbenchResolvedSourceYaml as validateWorkbenchResolvedSourceYamlInternal, isWorkbenchSubjectManifestPath, } from "./generic-spec.js";
+import { attachSandboxMetadataToJob, createWorkbenchSandboxFileStore, isSurfaceSnapshotFile, readWorkbenchExecutionSpec, } from "./sandbox-inputs.js";
+import { asRuntimeRecord, importNodeModule, jsonRecord, nodeBuiltin, quoteShellArg, resolveWorkbenchWorkerId, } from "./runtime-utils.js";
+import { executeValidatedSandboxExecution, } from "./sandbox-plane.js";
+import { createSandboxBackendPlaneForProvider, } from "./sandbox-backends/index.js";
+import { applyWorkbenchSubjectPatch } from "./subject-patch.js";
+import { assignUsageRole, completeUsageSummary, mergeUsageSummaries, normalizeUsageSummary, usageStats, } from "./execution-usage.js";
+import { traceFilePaths, workbenchTracePhaseDirectory, } from "./trace-files.js";
+import { engineCaseForCase, } from "./execution-jobs.js";
+import { createWorkbenchExecutionEventPublisher, publishCommandPhaseEvent, } from "./execution-events.js";
+import { readWorkbenchExecutionPurpose } from "./execution-phases.js";
+import { adapterAuthEnv, localWorkbenchAdapterAuthStore, normalizeWorkbenchAdapterAuthTarget, sanitizeWorkbenchAdapterAuthBundle, } from "./adapter-auth.js";
+export { BENCHMARK_SPEC_FILE, DEFAULT_EXECUTION_RESOURCES, engineCaseEnginePrivateFiles, engineCaseFilesForRuntimeInput, engineCaseSubjectVisibleFiles, engineResolveInvocationForSpec, engineResolveBindingForSpec, engineResolveBindingForSourceYaml, isWorkbenchSubjectManifestPath, parseWorkbenchSourceFiles, resolveEngineCaseExecutionConfig, resolveWorkbenchResolvedSourceYaml, resolveWorkbenchSourceFiles, serializeWorkbenchResolvedSourceYaml, validateWorkbenchResolvedSourceYaml, } from "./generic-spec.js";
+export { adapterCommandName, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, parseWorkbenchAdapterManifest, workbenchAdapterManifestRequiresAuth, workbenchAdapterManifestSupportsOperation, workbenchAdapterOperationCommand, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, } from "@workbench-ai/workbench-protocol";
+export { adapterAuthEnv, createWorkbenchAdapterAuthBundle, defaultWorkbenchAdapterAuthStoreRoot, localWorkbenchAdapterAuthStore, normalizeWorkbenchAdapterAuthTarget, parseWorkbenchAdapterAuthTarget, sanitizeWorkbenchAdapterAuthBundle, } from "./adapter-auth.js";
+export { asRuntimeRecord, importNodeModule, nodeBuiltin, normalizeWorkbenchWorkerId, normalizeRuntimeRegistry, quoteShellArg, resolveDockerRuntimeImageRef, resolveWorkbenchWorkerId, } from "./runtime-utils.js";
+export { assignUsageRole, extractExecutionUsageFromTrace, mergeUsageSummaries, } from "./execution-usage.js";
+export { createWorkbenchProgressStdoutParser, publishWorkbenchProgressStdoutEnvelope, } from "./execution-events.js";
+export { resolveSandboxTemplateImage, } from "./sandbox-backends/template-images.js";
+export { readOutputTraceFiles, workbenchTracePhaseDirectory, workbenchTraceRunDirectory, workbenchTraceRunDirectoryName, } from "./trace-files.js";
+export { assertWorkbenchAdapterOperationSupport, assertWorkbenchAdapterOperationResultOk, collectWorkbenchAdapterOperationIssues, collectWorkbenchAdapterOperationRequirements, ensureWorkbenchAdapterOutputDir, WORKBENCH_ADAPTER_RESULT_FILE, normalizeWorkbenchAdapterOperationRequest, normalizeWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, readWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, writeWorkbenchAdapterOperationResult, } from "@workbench-ai/workbench-protocol";
+export { applyWorkbenchSubjectPatch, } from "./subject-patch.js";
+export { createWorkbenchSandboxFileStore, createSandboxAdapterRequest, executionResultFromCompletedSandboxJob, materializeWorkbenchSandboxInput, readWorkbenchExecutionSpec, sanitizeWorkbenchExecutionJobForSandbox, } from "./sandbox-inputs.js";
+export { compileWorkbenchExecutionGraph, } from "./execution-graph.js";
+export { createBaselineSubjectExecution, createBaselineSubjectJob, createWorkbenchExecutionJob, expectedWorkbenchRunJobCount, engineCaseForCase, engineCaseIds, attemptJobCountForRunSpec, workbenchExecutionJobPurpose, MAX_WORKBENCH_RUN_BUDGET, planWorkbenchExecutionJobsForPurpose, validateWorkbenchRunEnvelope, workbenchExecutionJobId, } from "./execution-jobs.js";
+export { addCapacity, capacityFits, runWorkbenchExecutionDag, subtractCapacity, workbenchJobDependencies, workbenchJobHostCost, workbenchJobResources, } from "./execution-scheduler.js";
+export { assertWorkbenchExecutionIsolation, collectWorkbenchExecutionIsolationIssues, validateWorkbenchExecutionOutputPayloads, } from "./execution-outputs.js";
+export { collectSandboxAllocationScopeIssues, collectExecutionCapabilityScopeIssues, collectSandboxHandleScopeIssues, createWorkbenchSandboxAllocation, createWorkbenchSandboxExecutionMetadata, createWorkbenchExecutionCapability, executeValidatedSandboxExecution, } from "./sandbox-plane.js";
+export { buildSubjectCasePhaseRefs, buildWorkbenchTracePhases, isWorkbenchPhaseActive, readWorkbenchExecutionId, readWorkbenchExecutionMetadataNumber, readWorkbenchExecutionMetadataString, readWorkbenchExecutionPurpose, resolveWorkbenchJobGroupStatus, } from "./execution-phases.js";
+export { finalizeWorkbenchExecutionTraceForJob, mergeWorkbenchExecutionTracesByJob, } from "./execution-traces.js";
+export { DOCKER_SANDBOX_BACKEND, assertSandboxHostHealthForProvider, createDockerSandboxBackendDescriptor, createDockerSandboxPlane, resolveWorkbenchSandboxProviderName, sandboxProviderAdmissionForResources, sandboxProviderDefaultMaxConcurrentJobs, sandboxProviderLeaseScope, sandboxHostHealthExpectationForProvider, } from "./sandbox-backends/index.js";
+export const DEFAULT_ENVIRONMENT_VERSIONS = [
+    {
+        id: "envv_python_3_12",
+        environmentId: "env_python",
+        name: "Python 3.12",
+        imageRef: "docker://workbench/workbench-python-3.12:envv_python_3_12",
+        sourceHash: "builtin:python-3.12",
+        sourceType: "builtin",
+        status: "ready",
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+        spec: {
+            base: "workbench/python-3.12",
+            resources: {
+                cpu: 2,
+                memoryGb: 4,
+                diskGb: 10,
+                timeoutMinutes: 20,
+            },
+            network: "off",
+        },
+    },
+    {
+        id: "envv_libreoffice_python",
+        environmentId: "env_libreoffice_python",
+        name: "LibreOffice + Python",
+        imageRef: "docker://workbench/workbench-libreoffice-python:envv_libreoffice_python",
+        sourceHash: "builtin:libreoffice-python",
+        sourceType: "builtin",
+        status: "ready",
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+        spec: {
+            base: "workbench/python-3.12",
+            resources: {
+                cpu: 2,
+                memoryGb: 4,
+                diskGb: 10,
+                timeoutMinutes: 30,
+            },
+            network: "off",
+        },
+    },
+    {
+        id: "envv_libreoffice_agent",
+        environmentId: "env_libreoffice_agent",
+        name: "LibreOffice + Agent",
+        imageRef: "docker://workbench/workbench-libreoffice-agent:envv_libreoffice_agent",
+        sourceHash: "builtin:libreoffice-agent",
+        sourceType: "builtin",
+        status: "ready",
+        createdAt: "2026-04-29T00:00:00.000Z",
+        updatedAt: "2026-04-29T00:00:00.000Z",
+        spec: {
+            base: "workbench/python-3.12",
+            resources: {
+                cpu: 4,
+                memoryGb: 8,
+                diskGb: 20,
+                timeoutMinutes: 60,
+            },
+            network: "on",
+        },
+    },
+    {
+        id: "envv_node_22",
+        environmentId: "env_node",
+        name: "Node 22",
+        imageRef: "docker://workbench/workbench-node-22:envv_node_22",
+        sourceHash: "builtin:node-22",
+        sourceType: "builtin",
+        status: "ready",
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+        spec: {
+            base: "workbench/node-22",
+            resources: {
+                cpu: 2,
+                memoryGb: 4,
+                diskGb: 10,
+                timeoutMinutes: 20,
+            },
+            network: "off",
+        },
+    },
+];
+export const DEFAULT_ENVIRONMENTS = [
+    {
+        id: "env_python",
+        name: "Python",
+        description: "Python runtime for scripts, data processing, and simple evaluators.",
+        currentVersionId: "envv_python_3_12",
+        builtIn: true,
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+    },
+    {
+        id: "env_libreoffice_python",
+        name: "LibreOffice + Python",
+        description: "Python runtime with soffice for document, spreadsheet, and PDF-heavy evaluations.",
+        currentVersionId: "envv_libreoffice_python",
+        builtIn: true,
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+    },
+    {
+        id: "env_libreoffice_agent",
+        name: "LibreOffice + Agent",
+        description: "Agent runtime with soffice and Python libraries for spreadsheet-heavy skill and rubric evaluations.",
+        currentVersionId: "envv_libreoffice_agent",
+        builtIn: true,
+        createdAt: "2026-04-29T00:00:00.000Z",
+        updatedAt: "2026-04-29T00:00:00.000Z",
+    },
+    {
+        id: "env_node",
+        name: "Node",
+        description: "Node runtime for JavaScript and TypeScript subjects.",
+        currentVersionId: "envv_node_22",
+        builtIn: true,
+        createdAt: "2026-04-23T00:00:00.000Z",
+        updatedAt: "2026-04-23T00:00:00.000Z",
+    },
+];
+export function loadAuthoredWorkbenchSourceDocument(args) {
+    const spec = parseAuthoredWorkbenchSourceSpec(args.sourceYaml);
+    return {
+        path: args.path ?? "benchmark.yaml",
+        exists: args.sourceYaml.trim().length > 0,
+        source_yaml: args.sourceYaml,
+        source_files: authoredSourceFilesForDocument(args),
+        spec,
+        cases: summarizeCaseInputs(args.cases ?? []),
+    };
+}
+function authoredSourceFilesForDocument(args) {
+    const explicit = (args.sourceFiles ?? [])
+        .filter((file) => file.encoding === "utf8" &&
+        isAuthoredSourceYamlPath(file.path))
+        .map((file) => ({
+        path: file.path,
+        content: file.content,
+    }));
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    return splitAuthoredSourceYaml(args.sourceYaml);
+}
+function splitAuthoredSourceYaml(sourceYaml) {
+    const parsed = YAML.parse(sourceYaml);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return [];
+    }
+    const entries = [
+        [BENCHMARK_SPEC_FILE, parsed.benchmark],
+        ["subjects/current/subject.yaml", splitSubjectSourceRecord(parsed.subject)],
+        ["optimizers/current.yaml", splitOptimizerSourceRecord(parsed.optimizer)],
+    ];
+    return entries.flatMap(([filePath, value]) => {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return [];
+        }
+        return [{
+                path: filePath,
+                content: `${YAML.stringify(value).trimEnd()}\n`,
+            }];
+    });
+}
+function splitSubjectSourceRecord(value) {
+    const record = cloneYamlRecord(value);
+    if (!record) {
+        return value;
+    }
+    delete record.benchmark;
+    delete record.path;
+    rewriteAdapterSources(record, "subjects");
+    return record;
+}
+function splitOptimizerSourceRecord(value) {
+    const record = cloneYamlRecord(value);
+    if (!record) {
+        return value;
+    }
+    rewriteAdapterSources(record, "optimizers");
+    return record;
+}
+function cloneYamlRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? YAML.parse(YAML.stringify(value))
+        : null;
+}
+function rewriteAdapterSources(record, yamlDir) {
+    if (!Array.isArray(record.adapters)) {
+        return;
+    }
+    record.adapters = record.adapters.map((entry) => typeof entry === "string" && !/^(?:npm|git):/iu.test(entry.trim())
+        ? sourcePathRelativeTo(yamlDir, entry)
+        : entry);
+}
+function sourcePathRelativeTo(yamlDir, sourcePath) {
+    const normalized = sourcePath.replace(/\\/gu, "/").replace(/^\.\//u, "");
+    const relative = path.posix.relative(yamlDir, normalized);
+    return relative || ".";
+}
+function isAuthoredSourceYamlPath(filePath) {
+    return filePath === BENCHMARK_SPEC_FILE ||
+        isWorkbenchSubjectManifestPath(filePath) ||
+        /^optimizers\/[^/]+\.ya?ml$/iu.test(filePath);
+}
+function formatOptimizerSummary(spec) {
+    return spec.improve ? `adapter:${spec.improve.use}` : "optimizer not configured";
+}
+function formatEngineRunSummary(spec) {
+    return `adapter:${spec.engineRun.use}`;
+}
+function environmentNetwork(runtime) {
+    const egress = runtime.network?.egress;
+    return egress === "none" ? "off" : "on";
+}
+function environmentResources(runtime) {
+    const resources = runtime.resources ?? {};
+    const output = {};
+    if (typeof resources.cpu === "number") {
+        output.cpu = resources.cpu;
+    }
+    if (typeof resources.memoryGb === "number") {
+        output.memoryGb = resources.memoryGb;
+    }
+    if (typeof resources.diskGb === "number") {
+        output.diskGb = resources.diskGb;
+    }
+    if (typeof resources.timeoutMinutes === "number") {
+        output.timeoutMinutes = resources.timeoutMinutes;
+    }
+    return Object.keys(output).length > 0 ? output : undefined;
+}
+function adapterProtocolCommandSpec(adapter, operation, manifests = []) {
+    if (!/^[a-z][a-z0-9-]*$/u.test(adapter.use)) {
+        throw new Error(`Adapter id ${adapter.use} cannot be mapped to an executable command.`);
+    }
+    const manifest = manifests.find((entry) => entry.id === adapter.use);
+    return {
+        use: "command",
+        command: manifest ? workbenchAdapterOperationCommand(manifest, operation) : adapterCommandName(adapter.use),
+    };
+}
+function protocolPhaseForExecution(execution, manifests) {
+    const role = executionPurposeRole(execution.purpose);
+    const operation = execution.purpose === "improve" ? "optimizer.improve" : "subject.run";
+    const command = adapterProtocolCommandSpec(execution.adapter, operation, manifests);
+    return {
+        kind: role,
+        label: execution.purpose,
+        operation,
+        adapter: execution.adapter,
+        command: command.command,
+    };
+}
+function attemptPhasesForExecution(execution, spec, manifests) {
+    void spec;
+    const enginePhase = {
+        kind: "engine",
+        label: "engine",
+        operation: "engine.run",
+        adapter: execution.adapter,
+        command: adapterProtocolCommandSpec(execution.adapter, "engine.run", manifests).command,
+    };
+    return [enginePhase];
+}
+function adapterConfigRecord(adapter, manifests = []) {
+    const config = cloneJsonRecord(jsonRecord(adapter.with));
+    const manifest = manifests.find((entry) => entry.id === adapter.use);
+    if (!manifest?.slots) {
+        return config;
+    }
+    for (const slot of Object.values(manifest.slots)) {
+        const value = jsonPointerValue(config, slot.path);
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const nested = jsonRecord(value[index]);
+                if (nested) {
+                    value[index] = invocationWithCommand(nested, slot.operation, manifests);
+                }
+            }
+            continue;
+        }
+        const nested = jsonRecord(value);
+        if (nested) {
+            setJsonPointerValue(config, slot.path, invocationWithCommand(nested, slot.operation, manifests));
+        }
+    }
+    return config;
+}
+function invocationWithCommand(invocation, operation, manifests) {
+    const use = typeof invocation.use === "string" ? invocation.use : "";
+    if (!use) {
+        return invocation;
+    }
+    const manifest = manifests.find((entry) => entry.id === use);
+    return {
+        ...invocation,
+        command: manifest ? workbenchAdapterOperationCommand(manifest, operation) : adapterCommandName(use),
+    };
+}
+function cloneJsonRecord(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function jsonPointerValue(root, pointer) {
+    let current = root;
+    for (const segment of jsonPointerSegments(pointer)) {
+        if (!current || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function setJsonPointerValue(root, pointer, value) {
+    const segments = jsonPointerSegments(pointer);
+    let current = root;
+    for (const segment of segments.slice(0, -1)) {
+        const next = current[segment];
+        if (!next || typeof next !== "object" || Array.isArray(next)) {
+            return;
+        }
+        current = next;
+    }
+    const key = segments.at(-1);
+    if (key) {
+        current[key] = value;
+    }
+}
+function jsonPointerSegments(pointer) {
+    if (pointer === "") {
+        return [];
+    }
+    return pointer
+        .replace(/^\//u, "")
+        .split("/")
+        .map((segment) => segment.replace(/~1/gu, "/").replace(/~0/gu, "~"));
+}
+export function materializeWorkbenchRunResult(args) {
+    const completed = args.jobs.filter((job) => job.status === "succeeded");
+    const failedJobCount = args.jobs.filter((job) => job.status === "failed").length;
+    const completedJobCount = args.jobs.filter((job) => job.status === "succeeded").length;
+    const subjectRevisions = completed
+        .filter((job) => workbenchExecutionPurpose(job) === "improve")
+        .map((job) => normalizeSubjectRevisionJobOutput(job.output))
+        .filter((output) => output !== null)
+        .sort((left, right) => left.attemptIndex - right.attemptIndex);
+    const evaluationJobs = args.jobs.filter((job) => workbenchExecutionPurpose(job) === "attempt");
+    const evaluationsBySubject = new Map();
+    for (const job of evaluationJobs) {
+        const subjectId = readJobString(job.output, "subjectId") ??
+            readJobString(job.input, "subjectId") ??
+            job.subjectId;
+        if (subjectId) {
+            evaluationsBySubject.set(subjectId, [
+                ...(evaluationsBySubject.get(subjectId) ?? []),
+                job,
+            ]);
+        }
+    }
+    const subjects = [];
+    const subjectFiles = {};
+    const evaluations = [];
+    for (const subjectRevision of subjectRevisions) {
+        const subjectId = subjectRevision.subjectId;
+        const subjectJobs = evaluationsBySubject.get(subjectId) ?? [];
+        const succeededEvaluationJobs = subjectJobs.filter((job) => job.status === "succeeded");
+        const outputs = normalizeEvaluationSampleOutputs({
+            jobs: succeededEvaluationJobs,
+            allJobs: completed,
+        })
+            .sort((left, right) => compareSampleOutputs(left.output, right.output));
+        const outputJobIds = new Set(outputs.flatMap(({ jobs }) => jobs.map((job) => job.id)));
+        const completedSampleKeys = new Set(outputs
+            .map(({ output }) => evaluationSampleGroupKeyFromOutput(output))
+            .filter((key) => key !== null));
+        const errorSampleJobs = [
+            ...subjectJobs.filter((job) => job.status === "failed"),
+            ...succeededEvaluationJobs.filter((job) => !outputJobIds.has(job.id)),
+        ];
+        const errorSamples = errorEvaluationSamplesFromJobs(errorSampleJobs, subjectId, subjectRevision.attemptIndex, completedSampleKeys);
+        const samples = [
+            ...outputs.map(({ jobs, output }) => withJobUsage(output.sample, completed, jobs[0])),
+            ...errorSamples,
+        ].sort((left, right) => left.index - right.index || left.id.localeCompare(right.id));
+        const evalRecord = createEvaluationRecord(subjectId, samples);
+        const usage = mergeUsageSummaries([
+            subjectRevision.usage,
+            ...samples.map((sample) => sample.usage),
+        ]);
+        const metrics = evaluationMeanMetrics(createEvaluationRecord(subjectId, samples));
+        const attemptIndex = subjectRevision.attemptIndex;
+        const evaluationTraces = [
+            ...outputs.flatMap(({ output }) => output.traces),
+            ...errorSampleJobs.flatMap(jobTracePaths),
+        ].sort();
+        const baseId = subjectRevision.baseId && subjectRevision.baseId !== subjectId
+            ? subjectRevision.baseId
+            : null;
+        const sourceMeta = subjectSourceMetadata(args.subjectSourceFiles);
+        const benchmarkMeta = benchmarkSourceMetadata(args.benchmarkSourceFiles);
+        const meta = {
+            attemptIndex,
+            sampleCount: evalRecord.sampleCount,
+            optimizer: formatOptimizerSummary(args.spec),
+            engineRun: formatEngineRunSummary(args.spec),
+            strategy: "greedy",
+            traces: {
+                improve: subjectRevision.traces,
+                evaluations: evaluationTraces,
+            },
+        };
+        if (sourceMeta) {
+            meta.source = sourceMeta;
+        }
+        if (benchmarkMeta) {
+            meta.benchmark = benchmarkMeta;
+        }
+        const record = {
+            id: subjectId,
+            ordinal: args.existingSubjectCount + subjects.length,
+            benchmarkFingerprint: args.benchmarkFingerprint,
+            subjectFingerprint: args.subjectFingerprint ?? materializedSubjectFingerprint(args.spec, subjectRevision.files),
+            createdAt: args.startedAt,
+            ...(baseId ? { baseId } : {}),
+            referenceIds: [],
+            status: evalRecord.completedSampleCount > 0 ? "evaluated" : "eval_error",
+            fileChanges: subjectRevision.fileChanges,
+            ...(metrics ? { metrics } : {}),
+            ...(usage ? { usage } : {}),
+            eval: evalRecord,
+            ...(subjectRevision.prompt ? { prompt: subjectRevision.prompt } : {}),
+            meta,
+        };
+        subjects.push(record);
+        evaluations.push(createEvaluationResultRecord({
+            runId: args.runId,
+            benchmarkFingerprint: args.benchmarkFingerprint,
+            createdAt: args.startedAt,
+            subject: record,
+            evaluation: evalRecord,
+        }));
+        subjectFiles[subjectId] = materializedSubjectFiles({
+            subjectRevisionFiles: subjectRevision.files,
+        });
+    }
+    const selectedSubject = selectSubject({
+        subjects,
+        previousSubject: args.previousSubject ?? null,
+    });
+    return {
+        subjects,
+        subjectFiles,
+        evaluations,
+        activeSubjectId: selectedSubject?.id ?? args.previousSubject?.id ?? null,
+        selectedSubject,
+        completedJobCount,
+        failedJobCount,
+    };
+}
+function subjectSourceMetadata(files) {
+    const sourceFiles = (files ?? [])
+        .filter((file) => /^subjects\/[^/]+\/subject\.ya?ml$/iu.test(file.path))
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((file) => ({
+        path: file.path,
+        kind: file.kind,
+        encoding: file.encoding ?? "utf8",
+        content: file.content,
+        executable: file.executable ?? false,
+    }));
+    return sourceFiles.length > 0 ? { files: sourceFiles } : null;
+}
+function benchmarkSourceMetadata(files) {
+    const sourceFiles = (files ?? [])
+        .filter((file) => file.path === BENCHMARK_SPEC_FILE)
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((file) => ({
+        path: file.path,
+        kind: file.kind,
+        encoding: file.encoding ?? "utf8",
+        content: file.content,
+        executable: file.executable ?? false,
+    }));
+    return sourceFiles.length > 0 ? { files: sourceFiles } : null;
+}
+function materializedSubjectFingerprint(spec, files) {
+    const hash = createHash("sha256");
+    hash.update("workbench-subject-v1\0");
+    hash.update("materialized\0runner\0");
+    hash.update(JSON.stringify(spec.run));
+    for (const file of filterSubjectSourceFiles(files).slice().sort((left, right) => left.path.localeCompare(right.path))) {
+        hash.update("\0file\0");
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.encoding ?? "utf8");
+        hash.update("\0");
+        hash.update(file.content);
+        hash.update("\0");
+        hash.update(file.executable ? "1" : "0");
+    }
+    return hash.digest("hex");
+}
+function materializedSubjectFiles(args) {
+    const byPath = new Map();
+    for (const file of filterSubjectSourceFiles(args.subjectRevisionFiles)) {
+        byPath.set(file.path, { ...file });
+    }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+function createEvaluationResultRecord(args) {
+    const evaluation = args.evaluation;
+    return {
+        id: evaluationResultId(args.runId, args.subject.id),
+        runId: args.runId,
+        benchmarkFingerprint: args.benchmarkFingerprint,
+        subjectFingerprint: args.subject.subjectFingerprint,
+        subjectId: args.subject.id,
+        createdAt: args.createdAt,
+        updatedAt: evaluation.finishedAt ?? args.createdAt,
+        status: evaluation.status,
+        sampleCount: evaluation.sampleCount,
+        completedSampleCount: evaluation.completedSampleCount,
+        errorSampleCount: evaluation.errorSampleCount,
+        ...(evaluation.metrics ? { metrics: evaluation.metrics } : {}),
+        ...(evaluation.durationMs ? { durationMs: evaluation.durationMs } : {}),
+        ...(evaluation.usage ? { usage: evaluation.usage } : {}),
+        ...(evaluation.error ? { error: evaluation.error } : {}),
+        evaluation,
+    };
+}
+function evaluationResultId(runId, subjectId) {
+    const runPart = runId.replace(/[^a-z0-9]+/giu, "_").replace(/^_+|_+$/gu, "").slice(-24);
+    const subjectPart = subjectId.replace(/[^a-z0-9]+/giu, "_").replace(/^_+|_+$/gu, "").slice(-24);
+    return `eval_${runPart}_${subjectPart}`;
+}
+export function selectExecutionOutputFilesForInspection(args) {
+    return args.files.filter((file) => !isWorkbenchInternalOutputPath(file.path));
+}
+export function isWorkbenchInternalOutputPath(filePath) {
+    const normalized = normalizeRelativePath(filePath);
+    return (normalized === ".workbench" ||
+        normalized.startsWith(".workbench/") ||
+        normalized === "workbench-result.json" ||
+        normalized === "sandbox-environment.json" ||
+        normalized === "sandbox_error.log" ||
+        normalized === "exit_code" ||
+        /^[a-z-]+_(stdout\.log|stderr\.log|exit_code)$/u.test(normalized));
+}
+export function createSubjectRevisionTraceInputFiles(args) {
+    const files = [];
+    const manifestJobs = [];
+    const jobs = args.jobs
+        .filter((job) => job.runId === args.runId && isTerminalExecutionJob(job))
+        .sort(compareTraceInputJobs);
+    for (const job of jobs) {
+        const jobFiles = completedJobOutputFiles(job);
+        const rawTraceFiles = jobFiles.filter((file) => normalizeRelativePath(file.path).startsWith(".workbench/traces/"));
+        files.push(...rawTraceFiles.map((file) => ({ ...file })));
+        const events = args.events
+            .filter((event) => event.runId === args.runId && event.jobId === job.id)
+            .sort((left, right) => left.at.localeCompare(right.at));
+        const eventPath = `events/${job.id}.ndjson`;
+        if (events.length > 0) {
+            files.push(textSurfaceFile(eventPath, `${events.map((event) => JSON.stringify(event)).join("\n")}\n`));
+        }
+        const summaryPath = `jobs/${job.id}.json`;
+        const summary = subjectRevisionTraceJobSummary(job, {
+            eventPath: events.length > 0 ? eventPath : null,
+            rawTracePaths: rawTraceFiles.map((file) => file.path).sort(),
+        });
+        files.push(textSurfaceFile(summaryPath, `${JSON.stringify(summary, null, 2)}\n`));
+        manifestJobs.push({
+            ...summary,
+            summary_path: summaryPath,
+        });
+    }
+    files.push(textSurfaceFile("manifest.json", `${JSON.stringify({
+        run_id: args.runId,
+        jobs: manifestJobs,
+    }, null, 2)}\n`));
+    return dedupeSurfaceFiles(files);
+}
+function isTerminalExecutionJob(job) {
+    return job.kind === "execute" && (job.status === "succeeded" ||
+        job.status === "failed" ||
+        job.status === "cancelled");
+}
+function compareTraceInputJobs(left, right) {
+    const leftAttempt = readOptionalJobNumber(left.input, "attemptIndex") ?? -1;
+    const rightAttempt = readOptionalJobNumber(right.input, "attemptIndex") ?? -1;
+    return leftAttempt - rightAttempt ||
+        purposeSortKey(workbenchExecutionPurpose(left)) - purposeSortKey(workbenchExecutionPurpose(right)) ||
+        (readOptionalJobNumber(left.input, "sampleIndex") ?? -1) - (readOptionalJobNumber(right.input, "sampleIndex") ?? -1) ||
+        (readJobString(left.input, "caseId") ?? "").localeCompare(readJobString(right.input, "caseId") ?? "") ||
+        left.id.localeCompare(right.id);
+}
+function purposeSortKey(purpose) {
+    if (purpose === "improve") {
+        return 0;
+    }
+    if (purpose === "attempt") {
+        return 1;
+    }
+    return 3;
+}
+function completedJobOutputFiles(job) {
+    const output = jsonRecord(job.output);
+    if (!Array.isArray(output.files)) {
+        return [];
+    }
+    const files = [];
+    for (const file of output.files) {
+        if (isSurfaceSnapshotFile(file)) {
+            files.push({ ...file });
+        }
+    }
+    return files;
+}
+function subjectRevisionTraceJobSummary(job, paths) {
+    const output = jsonRecord(job.output);
+    return {
+        job_id: job.id,
+        purpose: workbenchExecutionPurpose(job) ?? "unknown",
+        status: job.status,
+        subject_id: job.subjectId ?? readJobString(job.input, "subjectId"),
+        attempt_index: readOptionalJobNumber(job.input, "attemptIndex"),
+        sample_index: readOptionalJobNumber(job.input, "sampleIndex"),
+        case_id: readJobString(job.input, "caseId"),
+        created_at: job.createdAt,
+        ...(job.startedAt ? { started_at: job.startedAt } : {}),
+        ...(job.finishedAt ? { finished_at: job.finishedAt } : {}),
+        ...(job.error ? { error: job.error } : {}),
+        traces: jobTracePaths(job),
+        event_path: paths.eventPath,
+        raw_trace_paths: [...paths.rawTracePaths],
+        output: summarizeJobOutputForTrace(output),
+    };
+}
+function summarizeJobOutputForTrace(output) {
+    const { files: _files, fileSet: _fileSet, subjectPatch, ...rest } = output;
+    const patch = jsonRecord(subjectPatch);
+    const { files: _patchFiles, ...patchSummary } = patch;
+    return {
+        ...rest,
+        ...(Object.keys(patch).length > 0
+            ? { subjectPatch: patchSummary }
+            : {}),
+    };
+}
+function textSurfaceFile(path, content) {
+    return {
+        path,
+        kind: "text",
+        encoding: "utf8",
+        content,
+        executable: false,
+    };
+}
+function dedupeSurfaceFiles(files) {
+    const byPath = new Map();
+    for (const file of files) {
+        byPath.set(normalizeRelativePath(file.path), {
+            ...file,
+            path: normalizeRelativePath(file.path),
+        });
+    }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+export function buildWorkbenchProjectSourceFiles(input) {
+    const files = [
+        ...(input.specFiles
+            ? input.specFiles.map((file) => ({ ...file }))
+            : [textSurfaceFile("benchmark.yaml", input.specSource ?? "")]),
+        ...prefixProjectSourceFiles(input.subjectFiles, input.subjectFilesPath),
+        ...prefixProjectSourceFiles(input.engineResolveFiles, input.engineResolveFilesPath),
+        ...(input.adapterFiles ?? []).map((file) => ({ ...file })),
+        ...(input.dockerfiles ?? []).map((file) => ({ ...file })),
+    ];
+    if (input.dockerfilePath && input.dockerfile !== null && input.dockerfile !== undefined) {
+        files.push(textSurfaceFile(input.dockerfilePath, input.dockerfile));
+    }
+    return dedupeSurfaceFiles(files);
+}
+export function readWorkbenchSpecDockerfilePath(spec) {
+    return typeof spec.environment.dockerfile === "string" &&
+        spec.environment.dockerfile.length > 0
+        ? spec.environment.dockerfile
+        : "environment/Dockerfile";
+}
+function prefixProjectSourceFiles(files, rootPath) {
+    const root = normalizeRelativePath(rootPath);
+    return files.map((file) => {
+        const filePath = normalizeRelativePath(file.path);
+        return {
+            ...file,
+            path: filePath === root || filePath.startsWith(`${root}/`)
+                ? filePath
+                : `${root}/${filePath}`,
+        };
+    });
+}
+export function isSubjectSourceFilePath(filePath) {
+    const normalized = normalizeRelativePath(filePath);
+    return (normalized !== ".workbench" &&
+        !normalized.startsWith(".workbench/") &&
+        normalized !== "workbench-result.json");
+}
+export function filterSubjectSourceFiles(files) {
+    return files
+        .filter((file) => isSubjectSourceFilePath(file.path))
+        .map((file) => ({ ...file }));
+}
+export function buildSubjectLineage(args) {
+    const orderedSummaries = args.summaries.slice().sort((left, right) => {
+        const createdAt = left.createdAt.localeCompare(right.createdAt);
+        return createdAt !== 0 ? createdAt : left.id.localeCompare(right.id);
+    });
+    const summaryIds = new Set(orderedSummaries.map((summary) => summary.id));
+    return {
+        activeId: args.activeId,
+        nodes: orderedSummaries.map((summary) => ({
+            id: summary.id,
+            active: args.activeId === summary.id,
+            summary,
+        })),
+        edges: orderedSummaries.flatMap((summary) => buildLineageEdges(summary, summaryIds)),
+    };
+}
+export function normalizeSurfaceFiles(files) {
+    const byPath = new Map();
+    for (const file of files) {
+        const normalizedPath = normalizeRelativePath(file.path);
+        const content = String(file.content ?? "");
+        byPath.set(normalizedPath, {
+            path: normalizedPath,
+            kind: file.encoding === "base64" ? "binary" : "text",
+            encoding: file.encoding ?? "utf8",
+            content,
+            executable: file.executable === true,
+        });
+    }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
+export function filterSurfaceFilesByInclude(files, include) {
+    if (!include || include.length === 0) {
+        return files.map((file) => ({ ...file }));
+    }
+    const matchers = include.map((pattern) => globPatternToRegExp(normalizeRelativePath(pattern)));
+    return files
+        .filter((file) => matchers.some((matcher) => matcher.test(normalizeRelativePath(file.path))))
+        .map((file) => ({ ...file }));
+}
+function globPatternToRegExp(pattern) {
+    let source = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "*") {
+            const next = pattern[index + 1];
+            const afterNext = pattern[index + 2];
+            if (next === "*") {
+                if (afterNext === "/") {
+                    source += "(?:.*/)?";
+                    index += 2;
+                }
+                else {
+                    source += ".*";
+                    index += 1;
+                }
+            }
+            else {
+                source += "[^/]*";
+            }
+            continue;
+        }
+        if (char === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegExp(char);
+    }
+    return new RegExp(`${source}$`, "u");
+}
+function escapeRegExp(value) {
+    return value.replace(/[\\^$.*+?()[\]{}|]/gu, "\\$&");
+}
+export function summarizeSubjectFiles(files, changedPaths = files.map((file) => file.path)) {
+    const changed = new Set(changedPaths);
+    return [...files]
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((file) => {
+        const previewKind = resolvePreviewKind(file.path);
+        const text = file.encoding === "utf8" ? file.content : "";
+        const lines = text.length === 0 ? [] : text.split(/\r?\n/u);
+        return {
+            path: file.path,
+            old_path: null,
+            status: changed.has(file.path) ? "added" : "unchanged",
+            mime_type: detectMimeType(file.path),
+            preview_kind: previewKind,
+            additions: changed.has(file.path) ? Math.max(lines.length, 1) : 0,
+            deletions: 0,
+        };
+    });
+}
+export function createSubjectFilePreview(args) {
+    if (args.view === "diff") {
+        throw new Error("Diff previews require explicit before and after file content.");
+    }
+    const normalizedPath = normalizeRelativePath(args.path);
+    const file = args.files.find((entry) => entry.path === normalizedPath);
+    if (!file) {
+        throw new Error(`File ${args.path} was not found.`);
+    }
+    const source = {
+        content: file.content,
+        encoding: file.encoding,
+    };
+    return {
+        path: file.path,
+        view: args.view,
+        mime_type: detectMimeType(file.path),
+        preview_kind: resolvePreviewKind(file.path),
+        diff: null,
+        source,
+        rendered_html: null,
+    };
+}
+export function createCaseReview(args) {
+    const preferredSampleIndex = uniquePhaseSampleIndex(args.phases ?? []);
+    const sampleMatchesCase = (sample) => sample.id === args.caseId ||
+        sample.id.startsWith(`${args.caseId}__`) ||
+        (sample.cases ?? []).some((entry) => entry.id === args.caseId || entry.id.startsWith(`${args.caseId}__`));
+    const samples = args.subject.eval?.samples ?? [];
+    const sampleResult = samples.find((sample) => typeof preferredSampleIndex === "number" &&
+        sample.index === preferredSampleIndex &&
+        sampleMatchesCase(sample)) ?? samples.find(sampleMatchesCase);
+    const caseResult = sampleResult?.cases?.find((entry) => entry.id === args.caseId || entry.id.startsWith(`${args.caseId}__`));
+    if (!sampleResult && (args.phases?.length ?? 0) > 0) {
+        return {
+            subjectId: args.subject.id,
+            caseId: args.caseId,
+            caseLabel: args.caseId,
+            ...(typeof preferredSampleIndex === "number"
+                ? { sampleIndex: preferredSampleIndex }
+                : {}),
+            metrics: {},
+            phases: args.phases ?? [],
+            criteria_results: [],
+        };
+    }
+    if (!sampleResult) {
+        throw new Error(`Case ${args.caseId} was not found on subject ${args.subject.id}.`);
+    }
+    const durationMs = typeof caseResult?.durationMs === "number"
+        ? caseResult.durationMs
+        : sampleResult?.cases?.length === 1 &&
+            typeof sampleResult.durationMs === "number"
+            ? sampleResult.durationMs
+            : !caseResult && typeof sampleResult.durationMs === "number"
+                ? sampleResult.durationMs
+                : undefined;
+    const sampleStatus = sampleResult.status === "planned" ? undefined : sampleResult.status;
+    const status = caseResult?.status ?? sampleStatus;
+    return {
+        subjectId: args.subject.id,
+        caseId: caseResult?.id ?? sampleResult.id,
+        caseLabel: caseResult?.label ?? args.caseId,
+        sampleId: sampleResult.id,
+        sampleIndex: sampleResult.index,
+        ...(status ? { status } : {}),
+        metrics: caseResult?.metrics ?? sampleResult.metrics ?? {},
+        ...(typeof durationMs === "number" ? { durationMs } : {}),
+        ...(caseResult?.source ? { source: caseResult.source } : {}),
+        ...((caseResult?.feedback ?? sampleResult.feedback) !== undefined
+            ? { feedback: caseResult?.feedback ?? sampleResult.feedback }
+            : {}),
+        phases: args.phases ?? [],
+        criteria_results: (caseResult?.criteria ?? []).map((criterion) => ({
+            criterion_id: criterion.criterion_id,
+            pass: criterion.pass,
+            score: criterion.score,
+            errors: criterion.errors ?? [],
+            ...(criterion.rationale ? { rationale: criterion.rationale } : {}),
+        })),
+    };
+}
+function uniquePhaseSampleIndex(phases) {
+    const sampleIndices = new Set(phases
+        .map((phase) => phase.sampleIndex)
+        .filter((index) => typeof index === "number"));
+    if (sampleIndices.size !== 1) {
+        return null;
+    }
+    const [sampleIndex] = sampleIndices;
+    return typeof sampleIndex === "number" ? sampleIndex : null;
+}
+function parseAuthoredWorkbenchSourceSpec(source) {
+    const validation = validateWorkbenchResolvedSourceYamlInternal(source);
+    if (!validation.ok) {
+        return null;
+    }
+    const resolved = resolveWorkbenchResolvedSourceYamlInternal(source);
+    return {
+        version: 3,
+        benchmark: {
+            name: resolved.benchmark.name,
+            description: resolved.benchmark.description,
+            engine: authoredAdapterSpecFromInvocation(resolved.engine),
+        },
+        subject: {
+            name: resolved.subject.name,
+            description: resolved.subject.description,
+            files: { path: resolved.subject.files.path },
+            run: runSpecFromInvocation(resolved.run),
+        },
+        ...(resolved.optimizer
+            ? {
+                optimizer: {
+                    name: resolved.optimizer.name,
+                    ...(resolved.optimizer.description ? { description: resolved.optimizer.description } : {}),
+                    edits: [...resolved.optimizer.edits],
+                    improve: improveSpecFromInvocation(resolved.improve),
+                },
+            }
+            : {}),
+    };
+}
+function improveSpecFromInvocation(invocation) {
+    return authoredAdapterSpecFromInvocation(invocation);
+}
+function runSpecFromInvocation(invocation) {
+    return authoredAdapterSpecFromInvocation(invocation);
+}
+function authoredAdapterSpecFromInvocation(invocation) {
+    const config = jsonRecord(invocation.with);
+    return {
+        use: invocation.use,
+        ...(invocation.auth !== undefined ? { auth: invocation.auth } : {}),
+        ...(Object.keys(config).length > 0 ? { with: config } : {}),
+    };
+}
+function summarizeCaseInputs(files) {
+    if (files.length === 0) {
+        return [];
+    }
+    const caseIds = [...new Set(files.flatMap((file) => {
+            const normalized = normalizeRelativePath(file.path);
+            const slash = normalized.indexOf("/");
+            if (slash <= 0) {
+                return [];
+            }
+            return [normalized.slice(0, slash)];
+        }))].sort();
+    if (caseIds.length === 0) {
+        return [];
+    }
+    return caseIds.map((taskId, index) => {
+        const prefix = `${taskId}/`;
+        const fileCount = files.filter((file) => normalizeRelativePath(file.path).startsWith(prefix)).length;
+        return {
+            id: `case-${String(index + 1).padStart(3, "0")}`,
+            slug: taskId.replace(/\W+/gu, "-"),
+            path: taskId,
+            name: taskId,
+            fileCount,
+        };
+    });
+}
+function buildLineageEdges(summary, summaryIds) {
+    const edges = [];
+    if (summary.baseId && summary.baseId !== summary.id && summaryIds.has(summary.baseId)) {
+        edges.push({
+            id: `anchor:${summary.baseId}:${summary.id}`,
+            kind: "anchor",
+            sourceId: summary.baseId,
+            targetId: summary.id,
+        });
+    }
+    return edges;
+}
+export function createWorkbenchRunWorkload(args) {
+    const purpose = workbenchExecutionPurpose(args.job);
+    if (!purpose) {
+        throw new Error(`Unsupported runtime job kind: ${args.job.kind}`);
+    }
+    const subjectId = readJobString(args.job.input, "subjectId") ?? args.job.subjectId;
+    if (!subjectId) {
+        throw new Error(`${purpose} execution job is missing subjectId.`);
+    }
+    const attemptIndex = readRequiredJobNumber(args.job.input, "attemptIndex", `${purpose} execution job`);
+    const sampleIndex = purpose === "improve"
+        ? 0
+        : readRequiredJobNumber(args.job.input, "sampleIndex", `${purpose} execution job`);
+    const caseId = purpose === "improve"
+        ? "current"
+        : readRequiredJobString(args.job.input, "caseId", `${purpose} execution job`);
+    const engineCase = purpose === "improve"
+        ? undefined
+        : engineCaseForCase(args.engineCases, caseId);
+    const selectedEngineResolveFiles = engineCase
+        ? engineCaseFilesForRuntimeInput({ spec: args.spec, engineCase })
+        : [];
+    const engineCaseSpec = engineCase?.case;
+    const initial = createInitialSubjectFiles({
+        baseFiles: args.baseFiles,
+        spec: args.spec,
+        attemptIndex,
+    });
+    return {
+        job: args.job,
+        spec: args.spec,
+        subjectId,
+        attemptIndex,
+        sampleIndex,
+        subjectFiles: initial.files,
+        caseId,
+        engineResolveFiles: selectedEngineResolveFiles,
+        traceFiles: (args.traceFiles ?? []).map((file) => ({ ...file })),
+        ...(engineCase ? { engineCase } : {}),
+        ...(engineCaseSpec ? { engineCaseSpec } : {}),
+        prompt: initial.prompt,
+        changedPaths: initial.changedPaths,
+        baseId: readJobString(args.job.input, "baseId"),
+    };
+}
+function createInitialSubjectFiles(args) {
+    const editablePaths = optimizerEdits(args.spec).map(normalizeRelativePath);
+    const editPath = editablePaths[0];
+    const subjectPaths = editPath ? [editPath] : [];
+    const files = args.baseFiles.length > 0
+        ? args.baseFiles.map((file) => ({ ...file }))
+        : editPath
+            ? normalizeSurfaceFiles([{ path: editPath, content: "" }])
+            : [];
+    const prompt = [
+        `Run the subject workload for benchmark: ${args.spec.benchmark.description}`,
+        `Attempt ${args.attemptIndex + 1} uses ${formatOptimizerSummary(args.spec)}; the improve adapter may edit the subject before Workbench scores it.`,
+    ].join("\n");
+    const byPath = new Map(files.map((file) => [file.path, file]));
+    if (editPath &&
+        ![...byPath.keys()].some((filePath) => subjectPaths.includes(filePath))) {
+        byPath.set(editPath, {
+            path: editPath,
+            kind: "text",
+            encoding: "utf8",
+            executable: false,
+            content: "",
+        });
+    }
+    return {
+        files: [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path)),
+        changedPaths: [],
+        prompt,
+    };
+}
+export async function executeWorkbenchExecutionJob(args, options) {
+    const startedAt = args.job.startedAt ?? args.now ?? new Date().toISOString();
+    const execution = readWorkbenchExecutionSpec(args.job);
+    try {
+        const adapterAuthProfiles = await explicitAdapterAuthProfilesForExecution(execution, args, Boolean(options.loadLocalAdapterAuthProfiles));
+        const runtimeArgs = adapterAuthProfiles.length > 0
+            ? { ...args, adapterAuthProfiles }
+            : args;
+        const executionForSandbox = readWorkbenchExecutionSpec(runtimeArgs.job);
+        const fileStore = createWorkbenchSandboxFileStore(runtimeArgs);
+        const planeFactory = options.createSandboxPlaneForProvider ?? createSandboxBackendPlaneForProvider;
+        const plane = planeFactory(options.sandboxProvider, runtimeArgs, startedAt, fileStore);
+        const validated = await executeValidatedSandboxExecution(plane, executionForSandbox, {
+            now: startedAt,
+            runnerId: resolveWorkbenchWorkerId([
+                process.env.WORKBENCH_WORKER_ID,
+                process.env.EC2_INSTANCE_ID,
+                os.hostname(),
+                process.env.HOSTNAME,
+            ], "local-runner"),
+            fileStore,
+        });
+        return completedJobFromSandboxResult(runtimeArgs.job, startedAt, validated.result);
+    }
+    catch (error) {
+        return failWorkbenchRunJob(args.job, startedAt, error);
+    }
+}
+async function explicitAdapterAuthProfilesForExecution(execution, args, loadLocalAdapterProfiles) {
+    const required = requiredAdapterAuthTargetsForExecution(execution, args);
+    if (required.length === 0) {
+        return [];
+    }
+    const provided = (args.adapterAuthProfiles ?? [])
+        .map((bundle) => sanitizeWorkbenchAdapterAuthBundle(bundle));
+    const providedByTarget = new Map(provided.map((bundle) => [
+        adapterAuthTargetKey(bundle),
+        bundle,
+    ]));
+    const missing = required.filter((target) => !providedByTarget.has(adapterAuthTargetKey(target)));
+    if (missing.length > 0 && loadLocalAdapterProfiles) {
+        const store = localWorkbenchAdapterAuthStore();
+        const loaded = await Promise.all(required.map(async (target) => await store.get(target)));
+        const missingLoaded = loaded.findIndex((bundle) => !bundle);
+        if (missingLoaded >= 0) {
+            const target = required[missingLoaded];
+            throw new Error(`ADAPTER_AUTH_REQUIRED: ${target.adapterId}${target.slot ? `/${target.slot}` : ""} disconnected. Run workbench auth connect ${target.adapterId}${target.slot ? `/${target.slot}` : ""}.`);
+        }
+        return loaded.map((bundle) => bundle);
+    }
+    if (missing.length > 0) {
+        const target = missing[0];
+        throw new Error(`ADAPTER_AUTH_REQUIRED: ${target.adapterId}${target.slot ? `/${target.slot}` : ""} disconnected. Run workbench auth connect ${target.adapterId}${target.slot ? `/${target.slot}` : ""}.`);
+    }
+    return required.map((target) => providedByTarget.get(adapterAuthTargetKey(target)));
+}
+function adapterAuthTargetKey(target) {
+    return `${target.adapterId}/${target.slot ?? "_"}/${target.profile}`;
+}
+export function workbenchExecutionPurpose(job) {
+    return readWorkbenchExecutionPurpose(job);
+}
+export async function executeAdapterInCurrentSandboxRuntime(args, execution, startedAt, capability) {
+    const eventPublisher = createWorkbenchExecutionEventPublisher({
+        projectId: args.job.projectId,
+        runId: args.job.runId,
+        jobId: args.job.id,
+        executionId: execution.id,
+        attempt: Math.max(1, args.job.attempt),
+        target: args.progress,
+    });
+    const adapterAuth = await materializeSandboxAdapterAuth(args, execution);
+    const runtimeInput = {
+        ...args,
+        ...(adapterAuth.root ? { adapterAuthRoot: adapterAuth.root } : {}),
+        ...(Object.keys(adapterAuth.env).length > 0
+            ? { adapterAuthEnv: adapterAuth.env }
+            : {}),
+    };
+    try {
+        if (execution.purpose === "improve") {
+            return await executeSubjectRevisionExecutionInSandbox(runtimeInput, execution, startedAt, capability, eventPublisher);
+        }
+        if (execution.purpose === "attempt") {
+            return await executeAttemptExecutionInSandbox(runtimeInput, execution, startedAt, capability, eventPublisher);
+        }
+        throw new Error(`Unsupported execution purpose ${execution.purpose}.`);
+    }
+    catch (error) {
+        return failWorkbenchRunJob(args.job, startedAt, error);
+    }
+    finally {
+        if (adapterAuth.cleanup) {
+            await adapterAuth.cleanup().catch(() => undefined);
+        }
+        await eventPublisher.flush().catch(() => undefined);
+    }
+}
+async function materializeSandboxAdapterAuth(args, execution) {
+    const adapterProfiles = adapterAuthProfilesForExecution(execution, args);
+    if (adapterProfiles.length === 0) {
+        return { env: {} };
+    }
+    const env = {};
+    for (const bundle of adapterProfiles) {
+        Object.assign(env, adapterAuthEnv(bundle));
+    }
+    const adapterFileBundles = adapterProfiles.filter((bundle) => bundle.files.length > 0);
+    if (adapterFileBundles.length === 0) {
+        return { env };
+    }
+    const [fs, os, path] = await Promise.all([
+        importNodeModule(nodeBuiltin("fs/promises")),
+        importNodeModule(nodeBuiltin("os")),
+        importNodeModule(nodeBuiltin("path")),
+    ]);
+    const base = args.workdir ?? os.tmpdir();
+    await fs.mkdir(base, { recursive: true });
+    const root = await fs.mkdtemp(path.join(base, "workbench-adapter-auth-"));
+    await materializeAdapterAuthProfiles(adapterFileBundles, root, fs, path);
+    return {
+        ...(root ? { root } : {}),
+        env,
+        cleanup: async () => {
+            if (root) {
+                await fs.rm(root, { recursive: true, force: true });
+            }
+        },
+    };
+}
+async function materializeAdapterAuthProfiles(bundles, root, fs, path) {
+    for (const bundle of bundles) {
+        const targetRoot = path.join(root, bundle.adapterId, bundle.slot ?? "_", bundle.profile);
+        for (const file of bundle.files) {
+            const targetPath = path.join(targetRoot, file.path);
+            await fs.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs.writeFile(targetPath, file.encoding === "base64"
+                ? Buffer.from(file.content, "base64")
+                : file.content, { mode: file.mode ?? 0o600 });
+        }
+    }
+}
+function adapterAuthRequest(bundles, root, currentAdapterId) {
+    const self = {};
+    const adapters = {};
+    for (const bundle of bundles) {
+        const key = bundle.slot ?? "default";
+        const fileAuth = bundle.files.length > 0
+            ? {
+                ...(root ? { filesRoot: `${root}/${bundle.adapterId}/${bundle.slot ?? "_"}/${bundle.profile}` } : {}),
+                files: bundle.files.map((file) => ({
+                    path: file.path,
+                    encoding: file.encoding,
+                })),
+            }
+            : undefined;
+        const entry = {
+            method: bundle.method,
+            profile: bundle.profile,
+            ...(bundle.env && bundle.env.length > 0
+                ? { env: Object.fromEntries(bundle.env.map((entry) => [entry.name, "materialized"])) }
+                : {}),
+            ...(fileAuth ? fileAuth : {}),
+        };
+        adapters[bundle.adapterId] = {
+            ...(adapters[bundle.adapterId] ?? {}),
+            [key]: entry,
+        };
+        if (!currentAdapterId || bundle.adapterId === currentAdapterId) {
+            self[key] = entry;
+        }
+    }
+    const entries = {};
+    if (Object.keys(self).length > 0) {
+        entries.self = self;
+    }
+    if (Object.keys(adapters).length > 0) {
+        entries.adapters = adapters;
+    }
+    return entries;
+}
+function adapterAuthRequestForPhase(args, adapterId) {
+    const profiles = (args.adapterAuthProfiles ?? [])
+        .map((bundle) => sanitizeWorkbenchAdapterAuthBundle(bundle));
+    if (profiles.length === 0) {
+        return args.adapterAuthRequest;
+    }
+    return adapterAuthRequest(profiles, args.adapterAuthRoot, adapterId);
+}
+function adapterAuthProfilesForExecution(execution, args) {
+    const profiles = (args.adapterAuthProfiles ?? [])
+        .map((bundle) => sanitizeWorkbenchAdapterAuthBundle(bundle));
+    if (profiles.length === 0) {
+        return [];
+    }
+    const targets = requiredAdapterAuthTargetsForExecution(execution, args);
+    return profiles.filter((bundle) => targets.some((target) => bundle.adapterId === target.adapterId &&
+        bundle.profile === target.profile &&
+        (target.slot === undefined || bundle.slot === target.slot)));
+}
+function requiredAdapterAuthTargetsForExecution(execution, args) {
+    const manifests = args.adapterManifests ?? [];
+    return collectWorkbenchAdapterAuthRequirements(adapterInvocationsForExecution(execution, args.spec), manifests)
+        .map((target) => normalizeWorkbenchAdapterAuthTarget(target));
+}
+function adapterInvocationsForExecution(execution, spec) {
+    if (execution.purpose === "attempt") {
+        return uniqueAdapterInvocations([execution.adapter, spec.run]);
+    }
+    return [execution.adapter];
+}
+function uniqueAdapterInvocations(invocations) {
+    const seen = new Set();
+    const result = [];
+    for (const invocation of invocations) {
+        const key = JSON.stringify(invocation);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(invocation);
+    }
+    return result;
+}
+function completedJobFromSandboxResult(fallbackJob, startedAt, result) {
+    const completedJob = asRuntimeRecord(result.metadata).completedJob;
+    if (completedJob &&
+        typeof completedJob === "object" &&
+        !Array.isArray(completedJob)) {
+        return completedJob;
+    }
+    if (result.status === "succeeded") {
+        const finishedAt = result.finishedAt || new Date().toISOString();
+        return {
+            ...fallbackJob,
+            status: "succeeded",
+            attempt: Math.max(1, fallbackJob.attempt),
+            startedAt: result.startedAt || startedAt,
+            finishedAt,
+            updatedAt: finishedAt,
+            output: {
+                ok: true,
+                executionId: result.executionId,
+            },
+        };
+    }
+    return attachSandboxMetadataToJob(failWorkbenchRunJob(fallbackJob, result.startedAt || startedAt, result.error ?? `Sandbox execution ${result.status}.`, result.finishedAt), asRuntimeRecord(result.metadata).sandbox);
+}
+async function executeSubjectRevisionExecutionInSandbox(args, execution, startedAt, capability, eventPublisher) {
+    const { workload, result } = await runHostedProtocolExecutionResult(args, execution, startedAt, capability, eventPublisher);
+    if (result.error || (result.exitCode ?? 0) !== 0) {
+        return failWorkbenchRunJob(args.job, startedAt, result.error ?? `Adapter ${execution.adapter.use} exited with status ${result.exitCode}.`, result.finishedAt, result);
+    }
+    const finishedAt = result.finishedAt ?? new Date().toISOString();
+    const subjectPatch = createSubjectPatchFromResult(result, args.spec);
+    if (subjectPatch.fileChanges.length === 0) {
+        return failWorkbenchRunJob(args.job, startedAt, `${execution.adapter.use === "command" ? "Command improve adapter" : `Adapter ${execution.adapter.use}`} completed without changing subject files covered by optimizer edits.`, finishedAt, result);
+    }
+    const subjectRevisionFiles = applyWorkbenchSubjectPatch({
+        baseFiles: workload.subjectFiles,
+        patch: subjectPatch,
+        edits: requireOptimizerEdits(args.spec),
+    });
+    const usage = assignUsageRole("optimizer", result.usage);
+    return {
+        ...args.job,
+        status: "succeeded",
+        attempt: Math.max(1, args.job.attempt),
+        startedAt,
+        finishedAt,
+        updatedAt: finishedAt,
+        output: {
+            ok: true,
+            executionId: execution.id,
+            purpose: execution.purpose,
+            subjectId: workload.subjectId,
+            attemptIndex: workload.attemptIndex,
+            baseId: workload.baseId,
+            prompt: workload.prompt,
+            subjectPatch,
+            fileChanges: subjectPatch.fileChanges,
+            files: subjectRevisionFiles,
+            traces: traceFilePaths(result.files),
+            ...(usage ? { usage } : {}),
+            ...(result.summary !== undefined ? { summary: result.summary } : {}),
+            ...(result.feedback !== undefined ? { feedback: result.feedback } : {}),
+        },
+    };
+}
+async function executeAttemptExecutionInSandbox(args, execution, startedAt, capability, eventPublisher) {
+    const workload = createWorkbenchRunWorkload({
+        job: args.job,
+        spec: args.spec,
+        baseFiles: args.baseFiles,
+        engineResolveFiles: args.engineResolveFiles,
+        engineCases: args.engineCases,
+        traceFiles: args.traceFiles,
+    });
+    const workloadResult = await runHostedCommandExecutionPhases(args, workload, attemptPhasesForExecution(execution, args.spec, args.adapterManifests), startedAt, {
+        capability,
+        eventPublisher,
+    });
+    if (workloadResult.error || (workloadResult.exitCode ?? 0) !== 0) {
+        return failWorkbenchRunJob(args.job, startedAt, workloadResult.error ?? `Attempt adapter execution exited with status ${workloadResult.exitCode}.`, workloadResult.finishedAt, workloadResult);
+    }
+    const engineResult = workloadResult.result;
+    if (!engineResult ||
+        typeof engineResult.score !== "number" ||
+        !Number.isFinite(engineResult.score)) {
+        return failWorkbenchRunJob(args.job, startedAt, "Attempt engine must return a workbench-result result with a finite numeric score.", workloadResult.finishedAt, workloadResult);
+    }
+    const finishedAt = workloadResult.finishedAt ?? new Date().toISOString();
+    const usage = mergeUsageSummaries([
+        workloadResult.usage,
+        engineResult.usage,
+    ]);
+    const sample = evaluateSample({
+        subjectId: workload.subjectId,
+        files: workloadResult.files,
+        engineResolveFiles: workload.engineResolveFiles,
+        spec: workload.spec,
+        attemptIndex: workload.attemptIndex,
+        sampleIndex: workload.sampleIndex,
+        caseId: workload.caseId,
+        startedAt,
+        finishedAt,
+        durationMs: workloadResult.durationMs,
+        workload: {
+            ...workloadResult,
+            ...(usage ? { usage } : {}),
+            result: engineResult,
+        },
+    });
+    return {
+        ...args.job,
+        status: "succeeded",
+        attempt: Math.max(1, args.job.attempt),
+        startedAt,
+        finishedAt: sample.finishedAt,
+        updatedAt: sample.finishedAt ?? startedAt,
+        output: {
+            ok: true,
+            executionId: execution.id,
+            purpose: execution.purpose,
+            subjectId: workload.subjectId,
+            attemptIndex: workload.attemptIndex,
+            sampleIndex: workload.sampleIndex,
+            caseId: workload.caseId,
+            prompt: workload.prompt,
+            result: engineResult,
+            fileChanges: workloadResult.fileChanges.length > 0
+                ? workloadResult.fileChanges
+                : workload.changedPaths,
+            files: workloadResult.files,
+            sample,
+            ...(usage ? { usage } : {}),
+            traces: traceFilePaths(workloadResult.files),
+        },
+    };
+}
+async function runHostedProtocolExecutionResult(args, execution, startedAt, capability, eventPublisher) {
+    const workload = createWorkbenchRunWorkload({
+        job: args.job,
+        spec: args.spec,
+        baseFiles: args.baseFiles,
+        engineResolveFiles: args.engineResolveFiles,
+        engineCases: args.engineCases,
+        traceFiles: args.traceFiles,
+    });
+    const result = await runHostedCommandExecutionPhases(args, workload, [protocolPhaseForExecution(execution, args.adapterManifests)], startedAt, {
+        capability,
+        eventPublisher,
+    });
+    return { workload, result };
+}
+async function runHostedCommandExecutionPhases(args, workload, phases, startedAt, options = {}) {
+    const [{ execFile }, fs, os, path, { promisify }] = await Promise.all([
+        importNodeModule(nodeBuiltin("child_process")),
+        importNodeModule(nodeBuiltin("fs/promises")),
+        importNodeModule(nodeBuiltin("os")),
+        importNodeModule(nodeBuiltin("path")),
+        importNodeModule(nodeBuiltin("util")),
+    ]);
+    const execFileAsync = promisify(execFile);
+    const resolvedRuntime = workload.engineCaseSpec
+        ? resolveEngineCaseExecutionConfig({
+            spec: workload.spec,
+            engineCase: workload.engineCaseSpec,
+        }).environment
+        : workload.spec.environment;
+    const environmentVersion = args.environmentVersion
+        ? environmentVersionForRuntime(resolvedRuntime, args.environmentVersion)
+        : environmentVersionForRuntime(resolvedRuntime);
+    const workspace = await createRuntimeWorkspaceRoot(args, fs, os, path, "workbench-execution-sandbox-");
+    try {
+        await stageWorkbenchRunWorkload(workspace.root, workload);
+        let exitCode = 0;
+        let runtimeError;
+        const phaseResults = [];
+        try {
+            if (!environmentVersion) {
+                throw new Error("environment is required for adapter command executions.");
+            }
+            if (environmentVersion) {
+                await fs.writeFile(path.join(outputDir(workspace.root), "sandbox-environment.json"), `${JSON.stringify({
+                    imageRef: environmentVersion.imageRef,
+                    resources: environmentVersion.spec.resources,
+                    network: environmentVersion.spec.network,
+                }, null, 2)}\n`);
+            }
+            const phaseTimeoutMs = environmentVersion
+                ? environmentVersionTimeoutMs(environmentVersion)
+                : 5 * 60 * 1000;
+            const execution = readWorkbenchExecutionSpec(workload.job);
+            for (const phase of phases) {
+                await resetHostedWorkloadPhaseOutput(workspace.root, phase);
+                if (phase.kind === "engine" && execution.purpose === "attempt") {
+                    await stageAttemptScoringInputs(workspace.root, workload);
+                }
+                const adapterRequestPath = await writeWorkbenchAdapterRequest(workspace.root, workload, execution, phase, adapterAuthRequestForPhase(args, phase.adapter?.use ?? execution.adapter.use), args.adapterManifests);
+                const phaseRole = phaseEventRole(phase);
+                await publishCommandPhaseEvent(options.eventPublisher, {
+                    phase: phase.label,
+                    status: "started",
+                    ...(phaseRole ? { role: phaseRole } : {}),
+                });
+                try {
+                    if (!phase.command) {
+                        throw new Error(`Adapter phase ${phase.label} is missing a command.`);
+                    }
+                    const command = createHostedWorkloadShellCommand(workspace.root, phase.command, phase.label, phase.okExitCodes);
+                    await execFileAsync("sh", ["-c", command], {
+                        cwd: workspace.root,
+                        env: createHostedWorkloadPhaseEnv(workspace.root, adapterRequestPath, args.adapterAuthEnv),
+                        maxBuffer: 10 * 1024 * 1024,
+                        timeout: phaseTimeoutMs,
+                    });
+                    const operationResult = await readWorkbenchAdapterOperationResult(outputDir(workspace.root), phase.operation);
+                    assertWorkbenchAdapterOperationResultOk(operationResult, `Adapter ${phase.adapter?.use ?? execution.adapter.use} ${phase.operation}`);
+                    phaseResults.push(operationResult);
+                    await publishCommandPhaseEvent(options.eventPublisher, {
+                        phase: phase.label,
+                        status: "succeeded",
+                        ...(phaseRole ? { role: phaseRole } : {}),
+                    });
+                }
+                catch (error) {
+                    await publishCommandPhaseEvent(options.eventPublisher, {
+                        phase: phase.label,
+                        status: "failed",
+                        exitCode: readExitCode(error),
+                        error: error instanceof Error ? error.message : String(error),
+                        ...(phaseRole ? { role: phaseRole } : {}),
+                    });
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            exitCode = readExitCode(error);
+            if (exitCode === 0) {
+                exitCode = 1;
+            }
+            runtimeError =
+                error instanceof Error ? (error.stack ?? error.message) : String(error);
+            await fs
+                .writeFile(path.join(outputDir(workspace.root), "sandbox_error.log"), `${runtimeError}\n`)
+                .catch(() => undefined);
+        }
+        if (exitCode !== 0) {
+            return await readHostedRunFailureResult(workspace.root, workload, {
+                exitCode,
+                error: runtimeError ?? `Runtime command exited with status ${exitCode}.`,
+                startedAt,
+            });
+        }
+        return await readWorkbenchRunWorkloadResult(workspace.root, workload, {
+            exitCode,
+            startedAt,
+            phaseResults,
+        });
+    }
+    finally {
+        await workspace.cleanup();
+    }
+}
+async function createRuntimeWorkspaceRoot(args, fs, os, path, prefix) {
+    if (args.workspaceRoot) {
+        await fs.mkdir(args.workspaceRoot, { recursive: true });
+        return { root: args.workspaceRoot, cleanup: async () => undefined };
+    }
+    if (args.workdir) {
+        await fs.mkdir(args.workdir, { recursive: true });
+        const root = await fs.mkdtemp(path.join(args.workdir, prefix));
+        return {
+            root,
+            cleanup: async () => {
+                await fs
+                    .rm(root, { force: true, recursive: true })
+                    .catch(() => undefined);
+            },
+        };
+    }
+    const sandboxRoot = "/workspace";
+    const sandboxRootStat = await fs.stat(sandboxRoot).catch(() => null);
+    if (sandboxRootStat?.isDirectory()) {
+        return {
+            root: sandboxRoot,
+            cleanup: async () => undefined,
+        };
+    }
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+    return {
+        root,
+        cleanup: async () => {
+            await fs
+                .rm(root, { force: true, recursive: true })
+                .catch(() => undefined);
+        },
+    };
+}
+function phaseEventRole(phase) {
+    if (phase.kind === "optimizer") {
+        return "optimizer";
+    }
+    if (phase.kind === "runner") {
+        return "runner";
+    }
+    if (phase.kind === "engine") {
+        return "engine";
+    }
+    return undefined;
+}
+function adapterOperationUsageSummary(result) {
+    if (result.operation === "optimizer.improve") {
+        return assignUsageRole("optimizer", result.usage);
+    }
+    if (result.operation === "subject.run") {
+        return assignUsageRole("runner", result.usage);
+    }
+    if (result.operation === "engine.run") {
+        return assignUsageRole("engine", result.usage);
+    }
+    return result.usage;
+}
+function executionPurposeRole(purpose) {
+    if (purpose === "improve") {
+        return "optimizer";
+    }
+    return "runner";
+}
+function createSubjectPatchFromResult(result, spec) {
+    if (result.subjectPatch) {
+        return result.subjectPatch;
+    }
+    const changedEditPaths = result.fileChanges
+        .map(normalizeRelativePath)
+        .filter((filePath) => !filePath.startsWith(".workbench/") &&
+        isSubjectEditPath(filePath, optimizerEdits(spec)));
+    const changedSet = new Set(changedEditPaths);
+    const files = result.files
+        .filter((file) => changedSet.has(normalizeRelativePath(file.path)))
+        .map((file) => ({ ...file, path: normalizeRelativePath(file.path) }));
+    return {
+        files,
+        fileChanges: changedEditPaths,
+        ...(result.summary ? { summary: result.summary } : {}),
+        ...(result.feedback !== undefined ? { feedback: result.feedback } : {}),
+    };
+}
+function isSubjectEditPath(filePath, edits) {
+    const normalized = normalizeRelativePath(filePath);
+    return edits.some((entry) => {
+        const editPath = normalizeRelativePath(entry).replace(/\/+$/u, "");
+        return (normalized === editPath || normalized.startsWith(`${editPath}/`));
+    });
+}
+function environmentVersionForSpec(spec) {
+    return environmentVersionForRuntime(spec.environment);
+}
+function environmentVersionForRuntime(runtime, base) {
+    const image = runtime.dockerfile;
+    const resolved = findEnvironmentVersionForImage(image, DEFAULT_ENVIRONMENT_VERSIONS) ?? base;
+    if (resolved) {
+        return {
+            id: resolved.id,
+            imageRef: resolved.imageRef,
+            spec: {
+                ...resolved.spec,
+                network: environmentNetwork(runtime),
+                resources: definedEnvironmentResources(environmentResources(runtime)),
+            },
+        };
+    }
+    return {
+        id: "spec_environment",
+        imageRef: image.startsWith("dockerfile://")
+            ? image
+            : `dockerfile://${image}`,
+        spec: {
+            base: "custom",
+            network: environmentNetwork(runtime),
+            resources: definedEnvironmentResources(environmentResources(runtime)),
+        },
+    };
+}
+function definedEnvironmentResources(resources) {
+    return {
+        cpu: resources?.cpu ?? 2,
+        memoryGb: resources?.memoryGb ?? 4,
+        diskGb: resources?.diskGb ?? 10,
+        timeoutMinutes: resources?.timeoutMinutes ?? 30,
+    };
+}
+export async function stageWorkbenchRunWorkload(root, workload) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const purpose = readWorkloadExecutionPurpose(workload);
+    await Promise.all([
+        fs
+            .rm(inputDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+        fs
+            .rm(outputDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+        fs
+            .rm(runtimePrivateDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+        fs
+            .rm(runtimeLogsDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+    ]);
+    await fs.mkdir(inputDir(root), { recursive: true });
+    await fs.mkdir(outputDir(root), { recursive: true });
+    if (purpose === "attempt") {
+        assertMutableWorkspaceFiles(workload.subjectFiles, "Subject files");
+        await fs.mkdir(subjectDir(root), { recursive: true });
+        await fs.mkdir(caseDir(root), { recursive: true });
+        await fs.mkdir(runtimeLogsAgentDir(root), { recursive: true });
+        await fs.mkdir(runtimeLogsVerifierDir(root), { recursive: true });
+        const engineCase = requireWorkloadEngineCase(workload, "Attempt staging");
+        await writeSurfaceFiles(subjectDir(root), workload.subjectFiles);
+        await writeSurfaceFiles(caseDir(root), engineCaseSubjectVisibleFiles(engineCase));
+        await writeSurfaceFiles(root, workload.subjectFiles);
+        return;
+    }
+    if (purpose === "improve") {
+        assertMutableWorkspaceFiles(workload.subjectFiles, "Subject files");
+        await fs.mkdir(subjectDir(root), { recursive: true });
+        await writeSurfaceFiles(subjectDir(root), workload.subjectFiles);
+        await writeSurfaceFiles(root, workload.subjectFiles);
+        await fs.mkdir(tracesDir(root), { recursive: true });
+        await writeSurfaceFiles(tracesDir(root), workload.traceFiles);
+    }
+}
+async function stageAttemptScoringInputs(root, workload) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const engineCase = requireWorkloadEngineCase(workload, "Attempt scoring");
+    await Promise.all([
+        fs
+            .rm(runtimeEnginePrivateDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+        fs
+            .rm(runtimeLogsVerifierDir(root), { recursive: true, force: true })
+            .catch(() => undefined),
+    ]);
+    await fs.mkdir(runtimeEnginePrivateDir(root), { recursive: true });
+    await fs.mkdir(runtimeLogsVerifierDir(root), { recursive: true });
+    await writeSurfaceFiles(runtimeEnginePrivateDir(root), engineCaseEnginePrivateFiles(engineCase));
+}
+async function readHostedRunFailureResult(root, workload, options) {
+    const traceFiles = await readRuntimeTraceFiles(root, workload);
+    const outputFiles = filterRuntimeOutputFiles(await readSurfaceFiles(outputDir(root)));
+    const startedAt = options.startedAt ?? new Date().toISOString();
+    const finishedAt = new Date().toISOString();
+    const files = [...outputFiles, ...traceFiles].sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        files,
+        fileChanges: files.map((file) => file.path),
+        exitCode: options.exitCode,
+        error: options.error,
+        startedAt,
+        finishedAt,
+    };
+}
+async function readWorkbenchRunWorkloadResult(root, workload, options = {}) {
+    const path = await importNodeModule(nodeBuiltin("path"));
+    const traceFiles = await readRuntimeTraceFiles(root, workload);
+    const outputFiles = filterRuntimeOutputFiles(await readSurfaceFiles(outputDir(root)));
+    const outputExitCode = await readOptionalNumber(path.join(outputDir(root), "exit_code"));
+    const startedAt = options.startedAt ?? new Date().toISOString();
+    const finishedAt = new Date().toISOString();
+    const purpose = readWorkloadExecutionPurpose(workload);
+    const primaryOperation = purpose === "improve"
+        ? "optimizer.improve"
+        : "engine.run";
+    const primaryResult = [...(options.phaseResults ?? [])]
+        .reverse()
+        .find((result) => result.operation === primaryOperation);
+    const resultPayload = jsonRecord(primaryResult?.value);
+    const usage = mergeUsageSummaries([
+        options.usage,
+        ...(options.phaseResults ?? []).map(adapterOperationUsageSummary),
+    ]);
+    const metrics = normalizeRewardMetrics(resultPayload.metrics);
+    const cases = normalizeRewardCases(resultPayload.cases);
+    const includeResultScoring = purpose === "attempt";
+    const files = [...outputFiles, ...traceFiles].sort((left, right) => left.path.localeCompare(right.path));
+    const subjectPatch = purpose === "improve" ? primaryResult?.value : undefined;
+    const engineResult = purpose === "attempt" ? primaryResult?.value : undefined;
+    const declaredChanges = subjectPatch?.fileChanges ??
+        (Array.isArray(resultPayload.fileChanges)
+            ? resultPayload.fileChanges.filter((entry) => typeof entry === "string")
+            : files.map((file) => file.path));
+    return {
+        files,
+        fileChanges: declaredChanges,
+        ...(subjectPatch ? { subjectPatch } : {}),
+        ...(engineResult ? { result: engineResult } : {}),
+        ...(includeResultScoring && metrics ? { metrics } : {}),
+        ...(includeResultScoring && cases ? { cases } : {}),
+        ...(typeof resultPayload.summary === "string"
+            ? { summary: resultPayload.summary }
+            : primaryResult?.summary !== undefined
+                ? { summary: primaryResult.summary }
+                : {}),
+        ...(resultPayload.feedback !== undefined
+            ? { feedback: resultPayload.feedback }
+            : primaryResult?.feedback !== undefined
+                ? { feedback: primaryResult.feedback }
+                : {}),
+        ...(usage ? { usage } : {}),
+        exitCode: options.exitCode ?? outputExitCode ?? 0,
+        ...(options.error ? { error: options.error } : {}),
+        startedAt,
+        finishedAt,
+        durationMs: Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt)),
+    };
+}
+async function readRuntimeTraceFiles(root, workload) {
+    const path = await importNodeModule(nodeBuiltin("path"));
+    const traceRoot = path.join(outputDir(root), ".workbench", "traces", workload.job.id);
+    const purpose = readWorkloadExecutionPurpose(workload);
+    const outputTraceRoot = workbenchTracePhaseDirectory({
+        sequence: 1,
+        runId: workload.job.runId,
+        phase: purpose,
+    });
+    return (await readSurfaceFiles(traceRoot)).map((file) => ({
+        ...file,
+        path: normalizeRelativePath(`${outputTraceRoot}/${workload.job.id}/${file.path}`),
+    }));
+}
+function filterRuntimeOutputFiles(files) {
+    return files.filter((file) => !isWorkbenchInternalOutputPath(file.path));
+}
+function createHostedWorkloadShellCommand(root, command, prefix = "", okExitCodes = [0]) {
+    const outputPrefix = prefix ? `${prefix}_` : "";
+    const okExpression = [...new Set(okExitCodes)]
+        .sort((left, right) => left - right)
+        .map((code) => `[ "$status" -eq ${code} ]`)
+        .join(" || ");
+    const output = quoteShellArg(outputDir(root));
+    const stdout = quoteShellArg(`${outputDir(root)}/${outputPrefix}stdout.log`);
+    const stderr = quoteShellArg(`${outputDir(root)}/${outputPrefix}stderr.log`);
+    return [
+        `mkdir -p ${output}`,
+        `(${command}) > ${stdout} 2> ${stderr}`,
+        "status=$?",
+        `printf '%s\\n' "$status" > ${quoteShellArg(`${outputDir(root)}/${outputPrefix}exit_code`)}`,
+        okExpression ? `{ ${okExpression}; } && exit 0` : "",
+        `if [ -s ${stderr} ]; then sed -n '1,120p' ${stderr} >&2; fi`,
+        `if [ -s ${stdout} ]; then sed -n '1,40p' ${stdout} >&2; fi`,
+        'exit "$status"',
+    ].join("; ");
+}
+async function resetHostedWorkloadPhaseOutput(root, _phase) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    await fs
+        .rm(workbenchAdapterOperationResultPath(outputDir(root)), { force: true })
+        .catch(() => undefined);
+}
+async function writeWorkbenchAdapterRequest(root, workload, execution, phase, auth, manifests) {
+    const [fs, path] = await Promise.all([
+        importNodeModule(nodeBuiltin("fs/promises")),
+        importNodeModule(nodeBuiltin("path")),
+    ]);
+    const requestPath = path.join(root, ".workbench", "request.json");
+    await fs.mkdir(path.dirname(requestPath), { recursive: true });
+    const casePrompt = workload.engineCaseSpec?.prompt;
+    const adapter = phase.adapter ?? execution.adapter;
+    const subjectCommand = adapterProtocolCommandSpec(workload.spec.run, "subject.run", manifests).command;
+    await fs.writeFile(requestPath, `${JSON.stringify({
+        protocol: "workbench.adapter.v3",
+        id: execution.id,
+        jobId: workload.job.id,
+        operation: phase.operation,
+        invocation: {
+            use: adapter.use,
+            with: adapterConfigRecord(adapter, manifests),
+            ...(adapter.auth !== undefined ? { auth: adapter.auth } : {}),
+        },
+        ...(auth !== undefined ? { auth } : {}),
+        context: {
+            benchmark: {
+                name: workload.spec.benchmark.name,
+                description: workload.spec.benchmark.description,
+            },
+            subject: {
+                id: workload.subjectId,
+                path: workload.spec.subject.files.path,
+                run: {
+                    ...workload.spec.run,
+                    command: subjectCommand,
+                },
+            },
+            ...(workload.spec.optimizer
+                ? { optimizer: { edits: [...workload.spec.optimizer.edits] } }
+                : {}),
+            attempt: {
+                attemptIndex: workload.attemptIndex,
+                sampleIndex: workload.sampleIndex,
+                caseId: workload.caseId,
+            },
+            case: {
+                id: workload.caseId,
+                ...(casePrompt ? { prompt: casePrompt } : {}),
+            },
+        },
+        paths: {
+            workspace: root,
+            cwd: root,
+            output: outputDir(root),
+            result: workbenchAdapterOperationResultPath(outputDir(root)),
+            subject: subjectDir(root),
+            ...(workload.engineCaseSpec ? { case: caseDir(root) } : {}),
+            traces: tracesDir(root),
+            ...(phase.kind === "engine" ? { enginePrivate: runtimeEnginePrivateDir(root) } : {}),
+            logs: runtimeLogsDir(root),
+        },
+    }, null, 2)}\n`);
+    return requestPath;
+}
+function optimizerEdits(spec) {
+    return spec.optimizer?.edits ?? [];
+}
+function requireOptimizerEdits(spec) {
+    const edits = optimizerEdits(spec);
+    if (edits.length === 0) {
+        throw new Error("Optimizer YAML must declare at least one entry in edits.");
+    }
+    return edits;
+}
+function createHostedWorkloadPhaseEnv(root, adapterRequestPath, adapterEnv = {}) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === "string") {
+            env[key] = value;
+        }
+    }
+    for (const key of Object.keys(env)) {
+        if (key.startsWith("WORKBENCH_")) {
+            delete env[key];
+        }
+    }
+    const runtimeBins = [
+        "/workbench-runtime/node_modules/.bin",
+        "/workbench-runtime/products/workbench/node_modules/.bin",
+    ].join(":");
+    const systemBins = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+    env.PATH = process.env.PATH
+        ? `${systemBins}:${runtimeBins}:${process.env.PATH}`
+        : `${systemBins}:${runtimeBins}`;
+    env.WORKBENCH_ADAPTER_REQUEST = adapterRequestPath;
+    env.WORKBENCH_OUTPUT = outputDir(root);
+    env.WORKBENCH_RESULT = workbenchAdapterOperationResultPath(outputDir(root));
+    Object.assign(env, adapterEnv);
+    return env;
+}
+function readWorkloadExecutionPurpose(workload) {
+    const purpose = workbenchExecutionPurpose(workload.job);
+    if (purpose === "improve" || purpose === "attempt") {
+        return purpose;
+    }
+    throw new Error(`Execution job ${workload.job.id} is missing a supported execution purpose.`);
+}
+function requireWorkloadEngineCase(workload, label) {
+    if (!workload.engineCase) {
+        throw new Error(`${label} workload is missing an engine case.`);
+    }
+    return workload.engineCase;
+}
+function subjectDir(root) {
+    return `${inputDir(root)}/subject`;
+}
+function caseDir(root) {
+    return `${inputDir(root)}/case`;
+}
+function tracesDir(root) {
+    return `${inputDir(root)}/traces`;
+}
+function inputDir(root) {
+    return `${root}/input`;
+}
+function outputDir(root) {
+    return `${root}/output`;
+}
+function runtimePrivateDir(root) {
+    return `${root}/private`;
+}
+function runtimeEnginePrivateDir(root) {
+    return `${runtimePrivateDir(root)}/engine`;
+}
+function runtimeLogsDir(root) {
+    return `${root}/logs`;
+}
+function runtimeLogsAgentDir(root) {
+    return `${runtimeLogsDir(root)}/agent`;
+}
+function runtimeLogsVerifierDir(root) {
+    return `${runtimeLogsDir(root)}/verifier`;
+}
+function assertMutableWorkspaceFiles(files, label) {
+    const reserved = files
+        .map((file) => normalizeRelativePath(file.path))
+        .filter(isRuntimeReservedWorkspacePath);
+    if (reserved.length > 0) {
+        throw new Error(`${label} cannot target runtime-reserved workspace paths: ${reserved.join(", ")}.`);
+    }
+}
+function isRuntimeReservedWorkspacePath(normalizedPath) {
+    return normalizedPath === ".workbench" ||
+        normalizedPath.startsWith(".workbench/") ||
+        normalizedPath === "input" ||
+        normalizedPath.startsWith("input/") ||
+        normalizedPath === "output" ||
+        normalizedPath.startsWith("output/") ||
+        normalizedPath === "logs" ||
+        normalizedPath.startsWith("logs/") ||
+        normalizedPath === "private" ||
+        normalizedPath.startsWith("private/");
+}
+async function writeSurfaceFiles(root, files) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const path = await importNodeModule(nodeBuiltin("path"));
+    for (const file of files) {
+        const target = path.join(root, normalizeRelativePath(file.path));
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        const body = file.encoding === "base64"
+            ? Buffer.from(file.content, "base64")
+            : Buffer.from(file.content, "utf8");
+        await fs.writeFile(target, body);
+        if (file.executable) {
+            await fs.chmod(target, 0o755).catch(() => undefined);
+        }
+    }
+}
+async function readSurfaceFiles(root) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const path = await importNodeModule(nodeBuiltin("path"));
+    const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+    const files = [];
+    async function walk(directory) {
+        const entries = await fs
+            .readdir(directory, { withFileTypes: true })
+            .catch(() => []);
+        for (const entry of entries) {
+            const absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            const relativePath = normalizeRelativePath(path.relative(root, absolutePath).replace(/\\/gu, "/"));
+            const body = await fs.readFile(absolutePath);
+            const stats = await fs.stat(absolutePath);
+            const content = encodeSurfaceSnapshotContent(body, utf8Decoder);
+            files.push({
+                path: relativePath,
+                kind: content.encoding === "base64" ? "binary" : "text",
+                encoding: content.encoding,
+                content: content.content,
+                executable: (stats.mode & 0o111) !== 0,
+            });
+        }
+    }
+    await walk(root);
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+function encodeSurfaceSnapshotContent(body, utf8Decoder) {
+    try {
+        return {
+            encoding: "utf8",
+            content: utf8Decoder.decode(body),
+        };
+    }
+    catch {
+        return {
+            encoding: "base64",
+            content: body.toString("base64"),
+        };
+    }
+}
+function normalizeRewardMetrics(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const metrics = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === "number" && Number.isFinite(entry)) {
+            metrics[key] = entry;
+        }
+    }
+    return Object.keys(metrics).length > 0 ? metrics : undefined;
+}
+function normalizeRewardCases(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const cases = value.flatMap((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return [];
+        }
+        const record = entry;
+        const id = typeof record.id === "string" && record.id.length > 0 ? record.id : "";
+        if (!id) {
+            return [];
+        }
+        const metrics = normalizeRewardMetrics(record.metrics) ?? {};
+        const status = record.status === "completed" || record.status === "error"
+            ? record.status
+            : undefined;
+        const criteria = Array.isArray(record.criteria)
+            ? record.criteria.flatMap((criterion) => {
+                if (!criterion ||
+                    typeof criterion !== "object" ||
+                    Array.isArray(criterion)) {
+                    return [];
+                }
+                const criterionRecord = criterion;
+                const criterionId = typeof criterionRecord.criterion_id === "string"
+                    ? criterionRecord.criterion_id
+                    : "";
+                const label = typeof criterionRecord.label === "string"
+                    ? criterionRecord.label
+                    : criterionId;
+                const score = typeof criterionRecord.score === "number" &&
+                    Number.isFinite(criterionRecord.score)
+                    ? criterionRecord.score
+                    : undefined;
+                const pass = typeof criterionRecord.pass === "boolean"
+                    ? criterionRecord.pass
+                    : score !== undefined
+                        ? score >= 0.5
+                        : undefined;
+                if (!criterionId || score === undefined || pass === undefined) {
+                    return [];
+                }
+                const errors = Array.isArray(criterionRecord.errors)
+                    ? criterionRecord.errors.filter((error) => typeof error === "string")
+                    : [];
+                const rationale = typeof criterionRecord.rationale === "string" &&
+                    criterionRecord.rationale.trim().length > 0
+                    ? criterionRecord.rationale.trim()
+                    : undefined;
+                return [
+                    {
+                        criterion_id: criterionId,
+                        label,
+                        score,
+                        pass,
+                        ...(errors.length > 0 ? { errors } : {}),
+                        ...(rationale ? { rationale } : {}),
+                    },
+                ];
+            })
+            : undefined;
+        return [
+            {
+                id,
+                ...(typeof record.label === "string" ? { label: record.label } : {}),
+                ...(typeof record.split === "string" ? { split: record.split } : {}),
+                ...(status ? { status } : {}),
+                ...(typeof record.durationMs === "number" &&
+                    Number.isFinite(record.durationMs)
+                    ? { durationMs: record.durationMs }
+                    : {}),
+                metrics,
+                ...(record.source &&
+                    typeof record.source === "object" &&
+                    !Array.isArray(record.source)
+                    ? { source: record.source }
+                    : {}),
+                ...(record.feedback !== undefined
+                    ? { feedback: record.feedback }
+                    : {}),
+                ...(criteria && criteria.length > 0 ? { criteria } : {}),
+            },
+        ];
+    });
+    return cases.length > 0 ? cases : undefined;
+}
+async function readOptionalNumber(pathname) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    try {
+        const parsed = Number.parseInt(String(await fs.readFile(pathname, "utf8")).trim(), 10);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function workloadTimeoutMs(spec) {
+    return environmentVersionTimeoutMs(environmentVersionForSpec(spec));
+}
+export function findEnvironmentVersionForImage(image, versions) {
+    const normalizedImage = normalizeDockerImageRef(image);
+    return (versions.find((entry) => normalizeDockerImageRef(entry.imageRef) === normalizedImage) ?? null);
+}
+export function normalizeDockerImageRef(image) {
+    return image.startsWith("docker://") ? image : `docker://${image}`;
+}
+export function environmentVersionTimeoutMs(version) {
+    const timeoutMinutes = version?.spec.resources.timeoutMinutes ?? 30;
+    return Math.max(1, timeoutMinutes) * 60 * 1000;
+}
+function readExitCode(error) {
+    if (error &&
+        typeof error === "object" &&
+        "code" in error &&
+        typeof error.code === "number") {
+        return error.code;
+    }
+    if (error && typeof error === "object" && "signal" in error) {
+        return 124;
+    }
+    return 1;
+}
+function failWorkbenchRunJob(job, startedAt, error, finishedAt = new Date().toISOString(), result) {
+    const message = error instanceof Error ? error.message : String(error);
+    const output = {
+        ok: false,
+        error: message,
+        ...(result?.files ? { files: result.files } : {}),
+        ...(result?.fileChanges ? { fileChanges: result.fileChanges } : {}),
+    };
+    return {
+        ...job,
+        status: "failed",
+        attempt: Math.max(1, job.attempt),
+        startedAt,
+        finishedAt,
+        updatedAt: finishedAt,
+        error: message,
+        output,
+    };
+}
+function evaluateSample(args) {
+    const durationMs = args.durationMs ??
+        Math.max(0, Date.parse(args.finishedAt) - Date.parse(args.startedAt));
+    const sampleScore = args.workload.result?.score;
+    if (typeof sampleScore !== "number" || !Number.isFinite(sampleScore)) {
+        throw new Error("Evaluation sample requires an engine result with a finite numeric score.");
+    }
+    const cases = args.workload.cases?.length ? args.workload.cases : undefined;
+    const metrics = args.workload.metrics ?? {
+        score: sampleScore,
+    };
+    if (metrics.score === undefined) {
+        metrics.score = sampleScore;
+    }
+    const feedback = {
+        ...(args.workload.summary !== undefined
+            ? { summary: args.workload.summary }
+            : {}),
+        ...(args.workload.feedback !== undefined
+            ? { detail: args.workload.feedback }
+            : {}),
+    };
+    const usage = completeUsageSummary(args.workload.usage);
+    return {
+        id: `${args.caseId}__sample_${String(args.sampleIndex + 1).padStart(3, "0")}`,
+        index: args.sampleIndex,
+        subject: {
+            id: args.subjectId,
+            kind: "subject",
+            label: args.subjectId,
+        },
+        status: "completed",
+        startedAt: args.startedAt,
+        finishedAt: args.finishedAt,
+        durationMs,
+        metrics,
+        ...(usage ? { usage } : {}),
+        ...(cases ? { cases } : {}),
+        feedback,
+    };
+}
+function normalizeSampleJobOutput(value, fallbackFiles = []) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (record.ok !== true || typeof record.subjectId !== "string") {
+        return null;
+    }
+    const files = Array.isArray(record.files)
+        ? record.files.filter(isSurfaceSnapshotFile)
+        : [];
+    const sample = isEvaluationSampleRecord(record.sample) ? record.sample : null;
+    if (!sample) {
+        return null;
+    }
+    if (typeof record.attemptIndex !== "number" ||
+        !Number.isFinite(record.attemptIndex)) {
+        return null;
+    }
+    const sampleFiles = files.length > 0
+        ? files
+        : fallbackFiles.map((file) => ({ ...file }));
+    return {
+        subjectId: record.subjectId,
+        attemptIndex: record.attemptIndex,
+        sample,
+        fileChanges: Array.isArray(record.fileChanges)
+            ? record.fileChanges.filter((entry) => typeof entry === "string")
+            : [],
+        files: sampleFiles,
+        traces: Array.isArray(record.traces)
+            ? record.traces.filter((entry) => typeof entry === "string")
+            : traceFilePaths(sampleFiles),
+    };
+}
+function normalizeEvaluationSampleOutputs(args) {
+    return args.jobs.flatMap((job) => {
+        const output = normalizeSampleJobOutput(job.output);
+        return output ? [{ jobs: [job], output }] : [];
+    });
+}
+function meanFinite(values) {
+    const finite = values.filter((value) => typeof value === "number" && Number.isFinite(value));
+    if (finite.length === 0) {
+        return undefined;
+    }
+    return Number((finite.reduce((sum, value) => sum + value, 0) / finite.length).toFixed(6));
+}
+function minIsoTimestamp(values) {
+    const sorted = values
+        .filter((value) => Number.isFinite(Date.parse(value)))
+        .sort((left, right) => Date.parse(left) - Date.parse(right));
+    return sorted[0] ?? null;
+}
+function maxIsoTimestamp(values) {
+    const sorted = values
+        .filter((value) => Number.isFinite(Date.parse(value)))
+        .sort((left, right) => Date.parse(right) - Date.parse(left));
+    return sorted[0] ?? null;
+}
+function withJobUsage(sample, _jobs, attemptJob) {
+    const usage = normalizeUsageSummary(jsonRecord(attemptJob.output).usage)
+        ?? completeUsageSummary(sample.usage);
+    if (!usage) {
+        return sample;
+    }
+    return {
+        ...sample,
+        usage,
+    };
+}
+function normalizeSubjectRevisionJobOutput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (record.ok !== true || typeof record.subjectId !== "string") {
+        return null;
+    }
+    const files = Array.isArray(record.files)
+        ? record.files.filter(isSurfaceSnapshotFile)
+        : [];
+    if (typeof record.attemptIndex !== "number" ||
+        !Number.isFinite(record.attemptIndex)) {
+        return null;
+    }
+    const usage = normalizeUsageSummary(record.usage);
+    return {
+        subjectId: record.subjectId,
+        attemptIndex: record.attemptIndex,
+        baseId: typeof record.baseId === "string" && record.baseId.length > 0
+            ? record.baseId
+            : null,
+        ...(typeof record.prompt === "string" ? { prompt: record.prompt } : {}),
+        fileChanges: Array.isArray(record.fileChanges)
+            ? record.fileChanges.filter((entry) => typeof entry === "string")
+            : [],
+        files,
+        traces: Array.isArray(record.traces)
+            ? record.traces.filter((entry) => typeof entry === "string")
+            : traceFilePaths(files),
+        ...(usage ? { usage } : {}),
+    };
+}
+function errorEvaluationSamplesFromJobs(jobs, subjectId, attemptIndex, completedSampleKeys) {
+    const groups = new Map();
+    for (const job of jobs) {
+        const key = evaluationSampleGroupKeyFromJob(job);
+        if (!key || completedSampleKeys.has(key)) {
+            continue;
+        }
+        groups.set(key, [...(groups.get(key) ?? []), job]);
+    }
+    return [...groups.values()]
+        .map((group) => errorEvaluationSampleFromJobGroup(group, subjectId, attemptIndex))
+        .filter((sample) => sample !== null);
+}
+function errorEvaluationSampleFromJobGroup(jobs, subjectId, attemptIndex) {
+    const job = jobs[0];
+    if (!job) {
+        return null;
+    }
+    const sampleIndex = readOptionalJobNumber(job.input, "sampleIndex");
+    const caseId = readJobString(job.input, "caseId");
+    if (sampleIndex === null || !caseId) {
+        return null;
+    }
+    const startedAt = minIsoTimestamp(jobs.map((entry) => entry.startedAt ?? entry.createdAt));
+    const finishedAt = maxIsoTimestamp(jobs.map((entry) => entry.finishedAt ?? entry.updatedAt ?? entry.startedAt));
+    const error = summarizeEvaluationJobErrors(jobs) ?? "Evaluation job did not produce a valid sample.";
+    return {
+        id: `${caseId}__sample_${String(sampleIndex + 1).padStart(3, "0")}`,
+        index: sampleIndex,
+        subject: {
+            id: subjectId,
+            kind: "subject",
+            label: subjectId,
+        },
+        status: "error",
+        ...(startedAt ? { startedAt } : {}),
+        ...(finishedAt ? { finishedAt } : {}),
+        ...(startedAt && finishedAt
+            ? { durationMs: Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt)) }
+            : {}),
+        ...(error ? { error } : {}),
+        cases: [{
+                id: caseId,
+                status: "error",
+                metrics: {},
+                ...(error ? { feedback: { summary: error } } : {}),
+            }],
+        feedback: {
+            traces: [...new Set(jobs.flatMap(jobTracePaths))].sort(),
+        },
+    };
+}
+function evaluationSampleGroupKeyFromOutput(output) {
+    const caseId = output.sample.cases?.[0]?.id;
+    if (!caseId) {
+        return null;
+    }
+    return evaluationSampleGroupKey(caseId, output.sample.index);
+}
+function evaluationSampleGroupKeyFromJob(job) {
+    const sampleIndex = readOptionalJobNumber(job.input, "sampleIndex");
+    const caseId = readJobString(job.input, "caseId");
+    if (sampleIndex === null || !caseId) {
+        return null;
+    }
+    return evaluationSampleGroupKey(caseId, sampleIndex);
+}
+function evaluationSampleGroupKey(caseId, sampleIndex) {
+    return `${caseId}\0${sampleIndex}`;
+}
+function summarizeEvaluationJobErrors(jobs) {
+    const failures = jobs
+        .map((job) => job.error ? `${job.id}: ${job.error}` : null)
+        .filter((entry) => entry !== null);
+    if (failures.length === 0) {
+        return null;
+    }
+    return failures.length === 1
+        ? failures[0]
+        : `${failures.length} evaluation job errors: ${failures.join("; ")}`;
+}
+function jobTracePaths(job) {
+    const output = job.output && typeof job.output === "object" && !Array.isArray(job.output)
+        ? job.output
+        : {};
+    const files = Array.isArray(output.files)
+        ? output.files.filter(isSurfaceSnapshotFile)
+        : [];
+    return Array.isArray(output.traces)
+        ? output.traces.filter((entry) => typeof entry === "string")
+        : traceFilePaths(files);
+}
+function compareSampleOutputs(left, right) {
+    const sampleOrder = left.sample.index - right.sample.index;
+    if (sampleOrder !== 0) {
+        return sampleOrder;
+    }
+    return left.sample.id.localeCompare(right.sample.id);
+}
+function createEvaluationRecord(subjectId, rawSamples) {
+    const samples = mergeEvaluationSampleRecords(rawSamples);
+    const startedAt = minTimestamp(samples.flatMap((sample) => (sample.startedAt ? [sample.startedAt] : [])));
+    const finishedAt = maxTimestamp(samples.flatMap((sample) => (sample.finishedAt ? [sample.finishedAt] : [])));
+    const durationValues = samples.flatMap((sample) => typeof sample.durationMs === "number" ? [sample.durationMs] : []);
+    const metrics = aggregateSampleMetrics(samples);
+    const usage = usageStats(samples.flatMap((sample) => sample.usage ? [sample.usage] : []));
+    const cases = createEvaluationCaseStats(samples);
+    const completedSampleCount = samples.filter((sample) => sample.status === "completed").length;
+    const errorSampleCount = samples.filter((sample) => sample.status === "error")
+        .length;
+    return {
+        subject: {
+            id: subjectId,
+            kind: "subject",
+        },
+        status: samples.length > 0 && completedSampleCount === samples.length
+            ? "completed"
+            : samples.length > 0 && errorSampleCount === samples.length
+                ? "error"
+                : "partial",
+        sampleCount: samples.length,
+        completedSampleCount,
+        errorSampleCount,
+        ...(startedAt ? { startedAt } : {}),
+        ...(finishedAt ? { finishedAt } : {}),
+        ...(metrics ? { metrics } : {}),
+        ...(durationValues.length > 0
+            ? { durationMs: metricStats(durationValues) }
+            : {}),
+        ...(usage ? { usage } : {}),
+        ...(cases ? { cases } : {}),
+        samples,
+    };
+}
+function aggregateSampleMetrics(samples) {
+    const metricNames = new Set(samples.flatMap((sample) => Object.keys(sample.metrics ?? {})));
+    if (metricNames.size === 0) {
+        return undefined;
+    }
+    const metrics = Object.fromEntries([...metricNames].sort().map((metric) => [
+        metric,
+        metricStats(samples.flatMap((sample) => {
+            const value = sample.metrics?.[metric];
+            return typeof value === "number" && Number.isFinite(value)
+                ? [value]
+                : [];
+        })),
+    ]));
+    return Object.keys(metrics).length > 0 ? metrics : undefined;
+}
+function mergeEvaluationSampleRecords(samples) {
+    const groups = new Map();
+    for (const sample of samples) {
+        const key = String(sample.index);
+        groups.set(key, [...(groups.get(key) ?? []), sample]);
+    }
+    return [...groups.values()]
+        .map(mergeEvaluationSampleGroup)
+        .sort((left, right) => left.index - right.index ||
+        left.id.localeCompare(right.id));
+}
+function mergeEvaluationSampleGroup(group) {
+    const first = group[0];
+    if (group.length === 1) {
+        return normalizeSingleCaseDurations(first);
+    }
+    const startedAt = minTimestamp(group.flatMap((sample) => (sample.startedAt ? [sample.startedAt] : [])));
+    const finishedAt = maxTimestamp(group.flatMap((sample) => (sample.finishedAt ? [sample.finishedAt] : [])));
+    const durationMs = startedAt && finishedAt
+        ? Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt))
+        : undefined;
+    const cases = group.flatMap((sample) => normalizeCaseDurations(sample));
+    const metrics = aggregateSampleGroupMetrics(group);
+    const usage = mergeUsageSummaries(group.map((sample) => sample.usage));
+    const errors = group.flatMap((sample) => sample.error ? [sample.error] : []);
+    return {
+        id: `sample_${String(first.index + 1).padStart(3, "0")}`,
+        index: first.index,
+        subject: first.subject,
+        status: mergeEvaluationSampleStatus(group),
+        ...(startedAt ? { startedAt } : {}),
+        ...(finishedAt ? { finishedAt } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(metrics ? { metrics } : {}),
+        ...(usage ? { usage } : {}),
+        ...(errors.length > 0 ? { error: errors.join("; ") } : {}),
+        ...(cases.length > 0 ? { cases } : {}),
+    };
+}
+function normalizeSingleCaseDurations(sample) {
+    if (!sample.cases) {
+        return sample;
+    }
+    const cases = normalizeCaseDurations(sample);
+    return cases.length === sample.cases.length
+        ? { ...sample, cases }
+        : sample;
+}
+function normalizeCaseDurations(sample) {
+    return (sample.cases ?? []).map((caseResult) => (typeof caseResult.durationMs === "number" ||
+        sample.cases?.length !== 1 ||
+        typeof sample.durationMs !== "number"
+        ? caseResult
+        : { ...caseResult, durationMs: sample.durationMs }));
+}
+function aggregateSampleGroupMetrics(group) {
+    const metricNames = new Set(group.flatMap((sample) => Object.keys(sample.metrics ?? {})));
+    if (metricNames.size === 0) {
+        return undefined;
+    }
+    const metrics = Object.fromEntries([...metricNames].sort().flatMap((metric) => {
+        const value = meanFinite(group.map((sample) => sample.metrics?.[metric]));
+        return value === undefined ? [] : [[metric, value]];
+    }));
+    return Object.keys(metrics).length > 0 ? metrics : undefined;
+}
+function mergeEvaluationSampleStatus(group) {
+    if (group.some((sample) => sample.status === "error")) {
+        return "error";
+    }
+    if (group.some((sample) => sample.status === "running")) {
+        return "running";
+    }
+    if (group.length > 0 && group.every((sample) => sample.status === "completed")) {
+        return "completed";
+    }
+    return "planned";
+}
+function minTimestamp(values) {
+    return values.length > 0
+        ? values.reduce((min, value) => (value < min ? value : min))
+        : null;
+}
+function maxTimestamp(values) {
+    return values.length > 0
+        ? values.reduce((max, value) => (value > max ? value : max))
+        : null;
+}
+function createEvaluationCaseStats(samples) {
+    const byCase = new Map();
+    for (const caseResult of samples.flatMap((sample) => sample.cases ?? [])) {
+        byCase.set(caseResult.id, [
+            ...(byCase.get(caseResult.id) ?? []),
+            caseResult,
+        ]);
+    }
+    if (byCase.size === 0) {
+        return undefined;
+    }
+    return [...byCase.entries()]
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .map(([id, results]) => {
+        const first = results[0];
+        const metricNames = new Set(results.flatMap((result) => Object.keys(result.metrics)));
+        const durationValues = results.flatMap((result) => typeof result.durationMs === "number" ? [result.durationMs] : []);
+        const status = aggregateCaseStatus(results);
+        return {
+            id,
+            ...(first.label ? { label: first.label } : {}),
+            ...(first.split ? { split: first.split } : {}),
+            ...(status ? { status } : {}),
+            sampleCount: results.length,
+            metrics: Object.fromEntries([...metricNames].sort().map((metric) => [
+                metric,
+                metricStats(results.flatMap((result) => {
+                    const value = result.metrics[metric];
+                    return typeof value === "number" && Number.isFinite(value)
+                        ? [value]
+                        : [];
+                })),
+            ])),
+            ...(durationValues.length > 0
+                ? { durationMs: metricStats(durationValues) }
+                : {}),
+        };
+    });
+}
+function aggregateCaseStatus(results) {
+    if (results.some((result) => result.status === "error")) {
+        return "error";
+    }
+    if (results.length > 0) {
+        return "completed";
+    }
+    return undefined;
+}
+function evaluationMeanMetrics(evaluation) {
+    const entries = Object.entries(evaluation.metrics ?? {}).filter((entry) => Number.isFinite(entry[1].mean));
+    return entries.length > 0
+        ? Object.fromEntries(entries.map(([key, stats]) => [key, Number(stats.mean.toFixed(3))]))
+        : undefined;
+}
+function selectSubject(args) {
+    let selected = args.previousSubject;
+    for (const subject of args.subjects) {
+        if (!selected || hasHigherScore(subject, selected)) {
+            selected = subject;
+        }
+    }
+    return selected;
+}
+function hasHigherScore(subject, incumbent) {
+    const subjectValue = readMetric(subject, "score");
+    const incumbentValue = readMetric(incumbent, "score");
+    if (subjectValue == null) {
+        return false;
+    }
+    if (incumbentValue == null) {
+        return true;
+    }
+    return subjectValue > incumbentValue;
+}
+function readMetric(subject, metric) {
+    const direct = subject.metrics?.[metric];
+    return typeof direct === "number" && Number.isFinite(direct) ? direct : null;
+}
+function metricStats(values) {
+    const count = values.length;
+    if (count === 0) {
+        return {
+            count: 0,
+            mean: 0,
+            variance: 0,
+            stddev: 0,
+            min: 0,
+            max: 0,
+        };
+    }
+    const mean = values.reduce((sum, value) => sum + value, 0) / count;
+    const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / count;
+    return {
+        count,
+        mean,
+        variance,
+        stddev: Math.sqrt(variance),
+        min: Math.min(...values),
+        max: Math.max(...values),
+    };
+}
+function normalizeRelativePath(filePath) {
+    const normalized = filePath.replace(/\\/gu, "/").replace(/^\/+/u, "");
+    if (!normalized || normalized.includes("\0")) {
+        throw new Error("File paths must be non-empty relative paths.");
+    }
+    const parts = normalized.split("/");
+    if (parts.some((part) => part === ".." || part === "." || part === "")) {
+        throw new Error(`Unsafe relative file path: ${filePath}`);
+    }
+    return normalized;
+}
+function detectMimeType(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
+        return "text/markdown";
+    }
+    if (lower.endsWith(".json")) {
+        return "application/json";
+    }
+    if (lower.endsWith(".csv")) {
+        return "text/csv";
+    }
+    if (lower.endsWith(".pdf")) {
+        return "application/pdf";
+    }
+    if (lower.endsWith(".png")) {
+        return "image/png";
+    }
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
+        return "image/jpeg";
+    }
+    if (lower.endsWith(".xlsx")) {
+        return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    }
+    return "text/plain";
+}
+function resolvePreviewKind(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith(".md") || lower.endsWith(".markdown")) {
+        return "markdown";
+    }
+    if (lower.endsWith(".csv")) {
+        return "table";
+    }
+    if (lower.endsWith(".xlsx") || lower.endsWith(".xls")) {
+        return "spreadsheet";
+    }
+    if (lower.endsWith(".png") ||
+        lower.endsWith(".jpg") ||
+        lower.endsWith(".jpeg") ||
+        lower.endsWith(".gif")) {
+        return "image";
+    }
+    if (lower.endsWith(".pdf")) {
+        return "pdf";
+    }
+    return "text";
+}
+function readJobString(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const raw = value[key];
+    return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+function readRequiredJobString(value, key, label) {
+    const result = readJobString(value, key);
+    if (!result) {
+        throw new Error(`${label} is missing ${key}.`);
+    }
+    return result;
+}
+function readOptionalJobNumber(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const raw = value[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+}
+function readRequiredJobNumber(value, key, label) {
+    const result = readOptionalJobNumber(value, key);
+    if (result === null) {
+        throw new Error(`${label} is missing ${key}.`);
+    }
+    return result;
+}
+function isEvaluationSampleRecord(value) {
+    const record = value;
+    return Boolean(value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        typeof record.id === "string" &&
+        typeof record.index === "number" &&
+        typeof record.subject === "object" &&
+        isEvaluationSampleStatus(record.status) &&
+        hasOperationalCaseStatuses(record.cases));
+}
+function isEvaluationSampleStatus(value) {
+    return value === "planned" ||
+        value === "running" ||
+        value === "completed" ||
+        value === "error";
+}
+function hasOperationalCaseStatuses(value) {
+    if (value === undefined) {
+        return true;
+    }
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return false;
+        }
+        const status = entry.status;
+        return status === undefined || status === "completed" || status === "error";
+    });
+}