@workbench-ai/workbench 0.0.64 → 0.0.66

package/dist/index.js

@@ -5,17 +5,18 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { Writable } from "node:stream";
-import { createCandidateFilePreview, createBaselineCandidateJob as createRuntimeBaselineCandidateJob, evaluationScorecardId, evaluationMeanMetrics, executeWorkbenchExecutionJob, engineResolveBindingForSpec, filterOptimizerTraceJobsForCaseIds, filterCandidateSourceFiles, formatWorkbenchCaseSelector, formatWorkbenchSelectionPolicy, workbenchCaseSelectorUsesAllCases, workbenchExecutionPurpose, workbenchRunExecutionFingerprint, createWorkbenchAdapterAuthBundle, createOptimizerTraceInputFiles, DOCKER_SANDBOX_BACKEND, localWorkbenchAdapterAuthStore, materializeWorkbenchRunResult, normalizeSurfaceFiles, planWorkbenchExecutionJobsForPurpose, runWorkbenchExecutionDag, resolveEngineCaseExecutionConfig, resolveWorkbenchResolvedSourceYaml, runtimeResources, summarizeCandidateFiles, validateWorkbenchRunEnvelope, parseWorkbenchAdapterAuthTarget, workbenchEngineCaseIdsForImproveEvaluation, workbenchEngineCaseIdsForSelector, workbenchImproveOptimizeSelector, workbenchImproveSelectionPolicy, workbenchProjectSourceFingerprint, workbenchRuntimeBundleFingerprint, workbenchRuntimeExplicitActiveId, } from "@workbench-ai/workbench-core";
+import { createBaselineCandidateJob as createRuntimeBaselineCandidateJob, evaluationScorecardId, evaluationMeanMetrics, executeWorkbenchExecutionJob, engineResolveBindingForSpec, filterOptimizerTraceJobsForCaseIds, filterCandidateSourceFiles, formatWorkbenchCaseSelector, formatWorkbenchSelectionPolicy, workbenchCaseSelectorUsesAllCases, workbenchExecutionPurpose, workbenchRunExecutionFingerprint, createWorkbenchAdapterAuthBundle, createOptimizerTraceInputFiles, DOCKER_SANDBOX_BACKEND, localWorkbenchAdapterAuthStore, materializeWorkbenchRunResult, normalizeSurfaceFiles, isSurfaceSnapshotFile, jsonRecord, planWorkbenchExecutionJobsForPurpose, runWorkbenchExecutionDag, resolveEngineCaseExecutionConfig, resolveWorkbenchResolvedSourceYaml, runtimeResources, validateWorkbenchRunEnvelope, parseWorkbenchAdapterAuthTarget, workbenchEngineCaseIdsForImproveEvaluation, workbenchEngineCaseIdsForSelector, workbenchImproveOptimizeSelector, workbenchImproveSelectionPolicy, workbenchProjectSourceFingerprint, workbenchRuntimeBundleFingerprint, workbenchRuntimeExplicitActiveId, } from "@workbench-ai/workbench-core";
 import { assertWorkbenchAdapterOperationResultOk, collectWorkbenchAdapterAuthRequirements, normalizeWorkbenchAdapterOperationRequest, readWorkbenchAdapterOperationResult, workbenchAdapterOperationCommand, workbenchAdapterOperationResultPath, withDefaultWorkbenchAdapterAuthProfiles as applyDefaultWorkbenchAdapterAuthProfiles, } from "@workbench-ai/workbench-protocol";
 import { builtinLocalTraceAdapter, builtinLocalTraceAdapters, sortLocalTraceRefs, } from "@workbench-ai/workbench-built-in-adapters/local-traces";
-import { commandUsage, HOSTED_WATCH_LIFECYCLE_NOTE, LOCAL_DEV_OPEN_LIFECYCLE_NOTE, rootUsage, } from "./command-model.js";
+import { commandUsage, REMOTE_WATCH_LIFECYCLE_NOTE, LOCAL_DEV_OPEN_LIFECYCLE_NOTE, rootUsage, } from "./command-model.js";
 import { startLocalWorkbenchDevServer } from "./dev-open-server.js";
+import { createLocalWorkbenchInspection } from "./local-inspection.js";
 import { createWorkbenchInitScaffold, } from "./init-scaffold.js";
 import { defaultAdapterManifests, composeRuntimeDockerfileWithAdapters, resolveDefaultWorkbenchAdapter, resolveProjectAdapterSource, resolveWorkbenchAdaptersForProject, WORKBENCH_ADAPTER_MANIFEST_FILE, } from "./adapter-project.js";
 import { createAdapterCommandEnv } from "./adapter-command-env.js";
 import { loadLocalArchive, loadLocalArchiveIndex, exportLocalRuntimeBundle, importLocalRuntimeBundle, runtimeBundleStats, materializeCandidateRoot, readLocalCandidate, readLocalCandidateFiles, readLocalJobs, saveLocalArchive, saveLocalJobs, setLocalActive, upsertLocalRun, upsertLocalCandidate, upsertLocalEvaluation, } from "./local-archive.js";
 import { WorkspaceSnapshotError, } from "./workspace-snapshot.js";
-import { hostedEngineResolveFiles, readLocalProjectSource, WORKBENCH_BENCHMARK_FILE, } from "./project-source.js";
+import { remoteEngineResolveFiles, readLocalProjectSource, WORKBENCH_BENCHMARK_FILE, } from "./project-source.js";
 import { localBenchmarkFingerprint, localCandidateFingerprint, projectStateBenchmarkFingerprint, } from "./benchmark-fingerprint.js";
 const require = createRequire(import.meta.url);
 function getCliVersion() {
@@ -34,6 +35,30 @@ class WorkbenchApiRequestError extends Error {
 }
 const API_REQUEST_MAX_ATTEMPTS = 3;
 const DEFAULT_BASE_URL = "https://v2.workbench.ai";
+const AUTH_COMMAND_HANDLERS = {
+    connect: authConnect,
+    disconnect: authDisconnect,
+};
+const ADAPTERS_COMMAND_HANDLERS = {
+    create: adaptersCreate,
+    inspect: adaptersInspect,
+    list: adaptersList,
+    test: adaptersTest,
+};
+const TRACES_COMMAND_HANDLERS = {
+    collect: localTraceCollect,
+    list: localTraceList,
+    show: localTraceShow,
+};
+const TWO_SEGMENT_HELP_COMMANDS = {
+    adapters: ["create", "list", "inspect", "test"],
+    auth: [],
+    candidates: ["list", "show", "files", "preview"],
+    evaluations: ["list", "show"],
+    executions: ["trace"],
+    runs: ["list", "show"],
+    traces: ["collect", "list", "show"],
+};
 export async function runCli(argv, io = {
     stdin: process.stdin,
     stdout: process.stdout,
@@ -82,31 +107,31 @@ export async function runCli(argv, io = {
             return await pushBenchmark(argv.slice(1), io);
         }
         if (argv[0] === "eval") {
-            const hosted = extractHostedFlag(argv.slice(1));
-            return hosted.enabled
-                ? await startHostedWorkflow("eval", hosted.argv, io)
-                : await localEvaluateCandidate(hosted.argv, io, runtimeOptions);
+            const remote = extractRemoteFlag(argv.slice(1));
+            return remote.enabled
+                ? await startRemoteWorkflow("eval", remote.argv, io)
+                : await localEvaluateCandidate(remote.argv, io, runtimeOptions);
         }
         if (argv[0] === "retry") {
-            const hosted = extractHostedFlag(argv.slice(1));
-            return hosted.enabled
-                ? await retryHostedWorkflow(hosted.argv, io)
-                : await localRetry(hosted.argv, io, runtimeOptions);
+            const remote = extractRemoteFlag(argv.slice(1));
+            return remote.enabled
+                ? await retryRemoteWorkflow(remote.argv, io)
+                : await localRetry(remote.argv, io, runtimeOptions);
         }
         if (argv[0] === "improve") {
-            const hosted = extractHostedFlag(argv.slice(1));
-            return hosted.enabled
-                ? await startHostedWorkflow("improve", hosted.argv, io)
-                : await localRun(hosted.argv, io, runtimeOptions);
+            const remote = extractRemoteFlag(argv.slice(1));
+            return remote.enabled
+                ? await startRemoteWorkflow("improve", remote.argv, io)
+                : await localRun(remote.argv, io, runtimeOptions);
         }
         if (argv[0] === "restore") {
             return await localRestore(argv.slice(1), io);
         }
         if (argv[0] === "open") {
-            const hosted = extractHostedFlag(argv.slice(1));
-            return hosted.enabled
-                ? await openWorkbench(hosted.argv, io)
-                : await localDevOpen(hosted.argv, io);
+            const remote = extractRemoteFlag(argv.slice(1));
+            return remote.enabled
+                ? await openWorkbench(remote.argv, io)
+                : await localDevOpen(remote.argv, io);
         }
         if (argv[0] === "auth") {
             return await runAuthCommand(argv.slice(1), io);
@@ -117,6 +142,9 @@ export async function runCli(argv, io = {
         if (argv[0] === "traces") {
             return await runTracesCommand(argv.slice(1), io);
         }
+        if (argv[0] === "diagnose") {
+            return await localDiagnose(argv.slice(1), io);
+        }
         const commandPath = argv.slice(0, 2).join(" ");
         const rest = argv.slice(2);
         switch (commandPath) {
@@ -124,6 +152,12 @@ export async function runCli(argv, io = {
                 return await localRunList(rest, io);
             case "runs show":
                 return await localRunShow(rest, io);
+            case "evaluations list":
+                return await localEvaluationList(rest, io);
+            case "evaluations show":
+                return await localEvaluationShow(rest, io);
+            case "executions trace":
+                return await localExecutionTrace(rest, io);
             case "candidates list":
                 return await localCandidateList(rest, io);
             case "candidates show":
@@ -152,32 +186,18 @@ export async function runCli(argv, io = {
 }
 function commandPathForHelp(argv) {
     const positionals = argv.filter((arg) => arg !== "--help" && arg !== "-h" && !arg.startsWith("--"));
-    if (positionals[0] === "adapters" &&
-        ["create", "list", "inspect", "test"].includes(positionals[1] ?? "")) {
-        return positionals.slice(0, 2).join(" ");
-    }
-    if (positionals[0] === "traces" &&
-        ["collect", "list", "show"].includes(positionals[1] ?? "")) {
-        return positionals.slice(0, 2).join(" ");
-    }
-    if (positionals[0] === "auth") {
-        return positionals.slice(0, 2).join(" ");
-    }
-    if (positionals[0] === "runs" &&
-        ["list", "show"].includes(positionals[1] ?? "")) {
-        return positionals.slice(0, 2).join(" ");
-    }
-    if (positionals[0] === "candidates" &&
-        ["list", "show", "files", "preview"].includes(positionals[1] ?? "")) {
+    const command = positionals[0] ?? "";
+    const subcommands = TWO_SEGMENT_HELP_COMMANDS[command];
+    if (subcommands && (subcommands.length === 0 || subcommands.includes(positionals[1] ?? ""))) {
         return positionals.slice(0, 2).join(" ");
     }
-    return positionals[0] ?? "";
+    return command;
 }
-function extractHostedFlag(argv) {
+function extractRemoteFlag(argv) {
     let enabled = false;
     const next = [];
     for (const arg of argv) {
-        if (arg === "--hosted") {
+        if (arg === "--remote") {
             enabled = true;
         }
         else {
@@ -1498,6 +1518,9 @@ function latestCompletedAttemptJobsByPair(jobs, desiredKeys) {
     return byPair;
 }
 function caseSamplePairFromJob(job) {
+    if (job.caseId && Number.isSafeInteger(job.sampleIndex) && job.sampleIndex >= 0) {
+        return { caseId: job.caseId, sampleIndex: job.sampleIndex };
+    }
     const input = readRecord(job.input);
     const execution = readRecord(input?.execution);
     const metadata = readRecord(execution?.metadata);
@@ -1593,7 +1616,7 @@ function resolveProjectPath(root, filePath) {
 }
 async function executeLocalDevelopmentJob(args) {
     return await executeWorkbenchExecutionJob(args, {
-        sandboxProvider: DOCKER_SANDBOX_BACKEND,
+        sandboxBackend: DOCKER_SANDBOX_BACKEND,
         loadLocalAdapterAuthProfiles: true,
     });
 }
@@ -1604,7 +1627,7 @@ async function executeLocalDevelopmentDag(args) {
     const result = await runWorkbenchExecutionDag({
         jobs: args.jobs,
         capacity: args.capacity,
-        sandboxProvider: DOCKER_SANDBOX_BACKEND,
+        sandboxBackend: DOCKER_SANDBOX_BACKEND,
         executeJob: async (job) => {
             return await executeLocalDevelopmentJob({
                 job,
@@ -1802,11 +1825,16 @@ async function localRestore(argv, io) {
     writeOutput({ ok: true, activeCandidateId: candidateId, changedPaths }, parsed, io, () => `Restored ${candidateId} to ${candidateRoot}.`);
     return 0;
 }
+function localInspectionFromParsed(parsed) {
+    return createLocalWorkbenchInspection({ workspace: resolveDir(parsed) });
+}
 async function localCandidateList(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "json"]));
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
-    writeOutput(snapshot.candidates, parsed, io, (candidates) => candidates
+    const inspection = localInspectionFromParsed(parsed);
+    const snapshot = await inspection.snapshot();
+    const candidates = await Promise.all(snapshot.summaries.map((candidate) => inspection.candidate({ id: candidate.id })));
+    writeOutput(candidates, parsed, io, (candidates) => candidates
         .map((candidate) => `${candidate.id}\t${candidate.status}\tevaluation ${formatCandidateEvaluationScore(candidate)}${snapshot.activeId === candidate.id ? "\tactive" : ""}`)
         .join("\n") || "No candidates.");
     return 0;
@@ -1814,13 +1842,14 @@ async function localCandidateList(argv, io) {
 async function localCandidateShow(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "candidate", "json"]));
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
+    const inspection = localInspectionFromParsed(parsed);
+    const snapshot = await inspection.snapshot();
     const candidateId = readCandidateIdFlag(parsed, snapshot);
-    const candidate = readLocalCandidate(snapshot, candidateId);
+    const candidate = await inspection.candidate({ id: candidateId });
     writeOutput(candidate, parsed, io, (record) => [
         `${record.id}\t${record.status}`,
         `benchmark\t${record.benchmarkFingerprint}`,
-        `candidate\t${record.candidateFingerprint ?? record.candidateFingerprint}`,
+        `candidate\t${record.candidateFingerprint}`,
         `evaluation\t${formatCandidateEvaluationSummary(record)}`,
         ...(record.baseId ? [`base\t${record.baseId}`] : []),
     ].join("\n"));
@@ -1829,10 +1858,10 @@ async function localCandidateShow(argv, io) {
 async function localCandidateFiles(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "candidate", "json"]));
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
+    const inspection = localInspectionFromParsed(parsed);
+    const snapshot = await inspection.snapshot();
     const candidateId = readCandidateIdFlag(parsed, snapshot);
-    const candidate = readLocalCandidate(snapshot, candidateId);
-    const files = summarizeCandidateFiles(readLocalCandidateFiles(snapshot, candidateId), candidate.fileChanges);
+    const files = await inspection.candidateFiles({ id: candidateId });
     writeOutput(files, parsed, io, (records) => records
         .map((file) => `${file.path}\t${file.status}\t${file.preview_kind}`)
         .join("\n") || "No files.");
@@ -1841,10 +1870,11 @@ async function localCandidateFiles(argv, io) {
 async function localCandidatePreview(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "candidate", "path", "output", "view", "json"]));
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
+    const inspection = localInspectionFromParsed(parsed);
+    const snapshot = await inspection.snapshot();
     const candidateId = readCandidateIdFlag(parsed, snapshot);
-    const preview = createCandidateFilePreview({
-        files: readLocalCandidateFiles(snapshot, candidateId),
+    const preview = await inspection.candidatePreview({
+        id: candidateId,
         path: requireFlag(parsed, "path"),
         view: readPreviewMode(parsed),
     });
@@ -1865,7 +1895,7 @@ async function localCandidatePreview(argv, io) {
 async function localRunList(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "json"]));
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
+    const snapshot = await localInspectionFromParsed(parsed).snapshot();
     writeOutput(snapshot.runs, parsed, io, (runs) => runs
         .map((run) => `${run.id}\t${run.workflow}\t${run.status}\t${run.outcome ?? "pending"}\t${run.attemptsExecuted ?? 0}/${run.attemptsRequested ?? 0}`)
         .join("\n") || "No runs.");
@@ -1873,67 +1903,130 @@ async function localRunList(argv, io) {
 }
 async function localRunShow(argv, io) {
     const parsed = parseArgs(argv);
-    rejectUnknownFlags(parsed, new Set(["dir", "json"]));
+    rejectUnknownFlags(parsed, new Set(["dir", "jobs", "failures", "json"]));
     const runId = parsed.positionals[0];
     if (!runId) {
         throw new UsageError("workbench runs show requires RUN_ID.");
     }
-    const snapshot = await loadLocalArchive(resolveDir(parsed));
-    const run = snapshot.runs.find((entry) => entry.id === runId);
-    if (!run) {
-        throw new UsageError(`Run not found: ${runId}`);
-    }
-    writeOutput(run, parsed, io, (record) => [
-        `${record.id}\t${record.workflow}\t${record.status}`,
-        `outcome\t${record.outcome ?? "pending"}`,
-        `started\t${record.startedAt}`,
-        ...(record.finishedAt ? [`finished\t${record.finishedAt}`] : []),
-        `attempts\t${record.attemptsExecuted ?? 0}/${record.attemptsRequested ?? 0}`,
-        `samples\t${record.samples ?? 0}`,
+    const inspection = localInspectionFromParsed(parsed);
+    const detail = await inspection.run({
+        id: runId,
+        includeJobs: parsed.flags.jobs === true || parsed.flags.failures === true,
+    });
+    const diagnosis = parsed.flags.failures === true
+        ? await inspection.diagnose({ targetId: runId })
+        : null;
+    writeOutput(parsed.flags.failures === true
+        ? { ...detail, diagnosis }
+        : detail, parsed, io, (record) => {
+        const run = record.run;
+        const jobs = "jobs" in record && Array.isArray(record.jobs)
+            ? record.jobs
+            : [];
+        const failures = "diagnosis" in record && record.diagnosis
+            ? record.diagnosis.failures
+            : [];
+        return [
+            `${run.id}\t${run.workflow}\t${run.status}`,
+            `outcome\t${run.outcome ?? "pending"}`,
+            `started\t${run.startedAt}`,
+            ...(run.finishedAt ? [`finished\t${run.finishedAt}`] : []),
+            `attempts\t${run.attemptsExecuted ?? 0}/${run.attemptsRequested ?? 0}`,
+            `samples\t${run.samples ?? 0}`,
+            ...(jobs.length > 0
+                ? [
+                    "jobs",
+                    ...jobs.map((job) => `${job.id}\t${job.kind}\t${job.status}${job.error ? `\t${job.error}` : ""}`),
+                ]
+                : []),
+            ...(failures.length > 0
+                ? [
+                    "failures",
+                    ...failures.map(formatFailureLine),
+                ]
+                : []),
+        ].join("\n");
+    });
+    return 0;
+}
+async function localEvaluationList(argv, io) {
+    const parsed = parseArgs(argv);
+    rejectUnknownFlags(parsed, new Set(["dir", "json"]));
+    const comparison = await localInspectionFromParsed(parsed).evaluations();
+    writeOutput(comparison, parsed, io, (record) => record.rows
+        .map((row) => `${row.evaluationId}\t${row.status}\t${formatNullableMetric(row.score)}\t${row.candidateLabel}\t${row.configurationLabel}\t${row.runId}`)
+        .join("\n") || "No evaluations.");
+    return 0;
+}
+async function localEvaluationShow(argv, io) {
+    const parsed = parseArgs(argv);
+    rejectUnknownFlags(parsed, new Set(["dir", "json"]));
+    const evaluationId = parsed.positionals[0];
+    if (!evaluationId) {
+        throw new UsageError("workbench evaluations show requires EVALUATION_ID.");
+    }
+    const evaluation = await localInspectionFromParsed(parsed).evaluation({ id: evaluationId });
+    writeOutput(evaluation, parsed, io, (record) => [
+        `${record.id}\t${record.status}`,
+        `candidate\t${record.candidateName ?? record.candidateId}`,
+        `run\t${record.runId}`,
+        `samples\t${record.completedSampleCount}/${record.sampleCount}`,
+        `errors\t${record.errorSampleCount}`,
+        `score\t${formatNullableMetric(record.metrics?.score?.mean ?? null)}`,
+        ...(record.error ? [`error\t${record.error}`] : []),
+        ...(record.evaluation.cases?.length
+            ? [
+                "cases",
+                ...record.evaluation.cases.map((entry) => `${entry.id}\t${entry.status ?? "unknown"}\t${formatNullableMetric(entry.metrics?.score?.mean ?? null)}`),
+            ]
+            : []),
     ].join("\n"));
     return 0;
 }
+async function localExecutionTrace(argv, io) {
+    const parsed = parseArgs(argv);
+    rejectUnknownFlags(parsed, new Set(["dir", "run", "job", "json"]));
+    const runId = requireFlag(parsed, "run");
+    const jobId = requireFlag(parsed, "job");
+    const detail = await localInspectionFromParsed(parsed).executionTrace({ runId, jobId });
+    writeOutput(detail, parsed, io, (record) => record.executions
+        .map((execution) => [
+        `${execution.id}\t${execution.kind}\t${execution.status}`,
+        `jobs\t${execution.jobIds.join(",")}`,
+        `sessions\t${execution.sessions.length}`,
+        `spans\t${execution.trace.spans.length}`,
+        `events\t${execution.trace.events.length}`,
+        `summaries\t${execution.trace.summaries.length}`,
+    ].join("\n"))
+        .join("\n\n") || "No execution trace.");
+    return 0;
+}
+async function localDiagnose(argv, io) {
+    const parsed = parseArgs(argv);
+    rejectUnknownFlags(parsed, new Set(["dir", "json"]));
+    rejectUnexpectedPositionals(parsed, "workbench diagnose", 1);
+    const diagnosis = await localInspectionFromParsed(parsed).diagnose({ targetId: parsed.positionals[0] ?? null });
+    writeOutput(diagnosis, parsed, io, (record) => record.failures.length > 0
+        ? record.failures.map(formatFailureLine).join("\n")
+        : "No failures.");
+    return 0;
+}
 async function runAuthCommand(argv, io) {
-    const command = argv[0];
-    const rest = argv.slice(1);
-    switch (command) {
-        case "connect":
-            return await authConnect(rest, io);
-        case "disconnect":
-            return await authDisconnect(rest, io);
-        default:
-            throw new UsageError(`Unknown command: auth ${argv.join(" ")}`);
-    }
+    return await runSubCommand("auth", AUTH_COMMAND_HANDLERS, argv, io);
 }
 async function runAdaptersCommand(argv, io) {
-    const command = argv[0];
-    const rest = argv.slice(1);
-    switch (command) {
-        case "create":
-            return await adaptersCreate(rest, io);
-        case "list":
-            return await adaptersList(rest, io);
-        case "inspect":
-            return await adaptersInspect(rest, io);
-        case "test":
-            return await adaptersTest(rest, io);
-        default:
-            throw new UsageError(`Unknown command: adapters ${argv.join(" ")}`);
-    }
+    return await runSubCommand("adapters", ADAPTERS_COMMAND_HANDLERS, argv, io);
 }
 async function runTracesCommand(argv, io) {
-    const command = argv[0];
-    const rest = argv.slice(1);
-    switch (command) {
-        case "collect":
-            return await localTraceCollect(rest, io);
-        case "list":
-            return await localTraceList(rest, io);
-        case "show":
-            return await localTraceShow(rest, io);
-        default:
-            throw new UsageError(`Unknown command: traces ${argv.join(" ")}`);
+    return await runSubCommand("traces", TRACES_COMMAND_HANDLERS, argv, io);
+}
+async function runSubCommand(group, handlers, argv, io) {
+    const command = argv[0] ?? "";
+    const handler = handlers[command];
+    if (!handler) {
+        throw new UsageError(`Unknown command: ${group} ${argv.join(" ")}`);
     }
+    return await handler(argv.slice(1), io);
 }
 const DEFAULT_LOCAL_TRACE_LIMIT = 3;
 const LOCAL_TRACE_WINDOW_FLAGS = new Set(["providers", "since", "workspace", "limit", "json"]);
@@ -2446,7 +2539,11 @@ fs.writeFileSync(resultPath, JSON.stringify({
 async function login(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["base-url", "no-open", "json"]));
-    const baseUrl = asOptionalString(parsed.flags["base-url"]) ?? DEFAULT_BASE_URL;
+    const config = await loadConfig();
+    const baseUrl = selectWorkbenchBaseUrl({
+        explicitBaseUrl: asOptionalString(parsed.flags["base-url"]),
+        configBaseUrl: config.baseUrl,
+    });
     const authorization = await requestDeviceAuthorization(baseUrl);
     if (parsed.flags.json === true) {
         writeJson({ ok: true, status: "authorization_pending", ...authorization }, io);
@@ -2472,7 +2569,7 @@ async function logout(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["json"]));
     const config = await loadConfig();
-    const baseUrl = normalizeBaseUrl(process.env.WORKBENCH_API_URL ?? config.baseUrl ?? DEFAULT_BASE_URL);
+    const baseUrl = selectWorkbenchBaseUrl({ configBaseUrl: config.baseUrl });
     if (config.accessToken) {
         await fetch(`${baseUrl}/api/oauth/revoke`, {
             method: "POST",
@@ -2493,8 +2590,8 @@ async function authStatus(argv, io) {
     const baseUrl = await effectiveBaseUrl();
     const profileStatus = await readWorkbenchProfileStatus(config);
     const adapterStatuses = await localWorkbenchAdapterAuthStore().listStatus();
-    const hostedAuth = profileStatus.authenticated
-        ? await readHostedAdapterAuthStatuses().catch((error) => ({
+    const remoteAuth = profileStatus.authenticated
+        ? await readRemoteAdapterAuthStatuses().catch((error) => ({
             adapters: [],
             error: error instanceof Error ? error.message : String(error),
         }))
@@ -2503,7 +2600,7 @@ async function authStatus(argv, io) {
             error: "not_authenticated",
         };
     const dir = resolveDir(parsed);
-    const adapterAuth = await projectAdapterAuthStatus(dir, adapterStatuses, hostedAuth.adapters).catch(() => []);
+    const adapterAuth = await projectAdapterAuthStatus(dir, adapterStatuses, remoteAuth.adapters).catch(() => []);
     const result = {
         ok: true,
         workbench: {
@@ -2512,7 +2609,7 @@ async function authStatus(argv, io) {
             username: profileStatus.profile?.username ?? null,
         },
         adapterStatuses,
-        hostedAuth,
+        remoteAuth,
         adapterAuth,
     };
     writeOutput(result, parsed, io, (record) => {
@@ -2525,28 +2622,28 @@ async function authStatus(argv, io) {
                 ? [
                     "",
                     "Required adapter auth:",
-                    ...value.adapterAuth.map((adapter) => `${adapter.adapter}${adapter.profile !== "default" ? ` profile ${adapter.profile}` : ""}: local ${adapter.local.status}${adapter.local.method ? ` (${adapter.local.method})` : ""}${adapter.local.reason ? ` (${adapter.local.reason})` : ""}, hosted ${adapter.hosted.status}${adapter.hosted.method ? ` (${adapter.hosted.method})` : ""}${adapter.hosted.reason ? ` (${adapter.hosted.reason})` : ""}`),
+                    ...value.adapterAuth.map((adapter) => `${adapter.adapter}${adapter.profile !== "default" ? ` profile ${adapter.profile}` : ""}: local ${adapter.local.status}${adapter.local.method ? ` (${adapter.local.method})` : ""}${adapter.local.reason ? ` (${adapter.local.reason})` : ""}, remote ${adapter.remote.status}${adapter.remote.method ? ` (${adapter.remote.method})` : ""}${adapter.remote.reason ? ` (${adapter.remote.reason})` : ""}`),
                 ]
                 : []),
         ].join("\n");
     });
     return 0;
 }
-async function projectAdapterAuthStatus(dir, adapterStatuses, hostedAdapters) {
+async function projectAdapterAuthStatus(dir, adapterStatuses, remoteAdapters) {
     const spec = (await readLocalProjectSource(dir)).spec;
     const adapters = await resolveWorkbenchAdaptersForProject(dir, spec);
     const adapterStatusMap = new Map(adapterStatuses.map((status) => [
         adapterAuthStatusKey(status.adapterId, status.slot, status.profile),
         status,
     ]));
-    const hostedAdapterStatusMap = new Map(hostedAdapters.map((status) => [
+    const remoteAdapterStatusMap = new Map(remoteAdapters.map((status) => [
         adapterAuthStatusKey(status.adapterId, status.slot, status.profile),
         status,
     ]));
     const adapterById = new Map(adapters.map((adapter) => [adapter.manifest.id, adapter]));
     return requiredAuthTargetsForSpec(spec, adapterById).map((target) => {
         const adapterStatus = adapterStatusMap.get(adapterAuthStatusKey(target.adapter, target.slot, target.profile));
-        const hostedAdapterStatus = hostedAdapterStatusMap.get(adapterAuthStatusKey(target.adapter, target.slot, target.profile));
+        const remoteAdapterStatus = remoteAdapterStatusMap.get(adapterAuthStatusKey(target.adapter, target.slot, target.profile));
         return {
             ...target,
             local: adapterStatus
@@ -2556,17 +2653,17 @@ async function projectAdapterAuthStatus(dir, adapterStatuses, hostedAdapters) {
                     ...(adapterStatus.reason ? { reason: adapterStatus.reason } : {}),
                 }
                 : { status: "disconnected" },
-            hosted: hostedAdapterStatus
+            remote: remoteAdapterStatus
                 ? {
-                    status: hostedAdapterStatus.status,
-                    ...(hostedAdapterStatus.method ? { method: hostedAdapterStatus.method } : {}),
-                    ...(hostedAdapterStatus.reason ? { reason: hostedAdapterStatus.reason } : {}),
+                    status: remoteAdapterStatus.status,
+                    ...(remoteAdapterStatus.method ? { method: remoteAdapterStatus.method } : {}),
+                    ...(remoteAdapterStatus.reason ? { reason: remoteAdapterStatus.reason } : {}),
                 }
                 : { status: "disconnected" },
         };
     });
 }
-async function readHostedAdapterAuthStatuses() {
+async function readRemoteAdapterAuthStatuses() {
     const adapterResponse = await apiRequest("/api/workbench/auth/adapters");
     return {
         adapters: adapterResponse.adapters ?? [],
@@ -2941,7 +3038,7 @@ async function pushBenchmark(argv, io) {
     const dir = resolveSourceDir(parsed);
     const source = await readLocalProjectSource(dir);
     const origin = await readWorkbenchOrigin(dir);
-    const baseUrl = await effectiveBaseUrl(origin?.baseUrl);
+    const baseUrl = await effectiveOriginBaseUrl(origin?.baseUrl);
     const visibility = readOptionalBenchmarkVisibility(parsed.flags.visibility);
     const createVisibility = visibility ?? "public";
     const dryRun = parsed.flags["dry-run"] === true;
@@ -2972,7 +3069,7 @@ async function pushBenchmark(argv, io) {
             }, parsed, io, () => `Would push benchmark ${source.spec.name}.`);
             return 0;
         }
-        const { project, origin: nextOrigin, result } = await createHostedBenchmarkFromState({
+        const { project, origin: nextOrigin, result } = await createRemoteBenchmarkFromState({
             baseUrl,
             dir,
             state,
@@ -3001,7 +3098,7 @@ async function pushBenchmark(argv, io) {
     }
     const projectId = origin.projectId;
     if (!projectId) {
-        throw new UsageError("Missing hosted benchmark. Run workbench push from a source directory.");
+        throw new UsageError("Missing remote benchmark. Run workbench push from a source directory.");
     }
     if (dryRun) {
         const remoteProject = await verifyLinkedPushDryRunTarget({
@@ -3017,7 +3114,7 @@ async function pushBenchmark(argv, io) {
             baseUrl,
             benchmarkId: projectId,
             remote: origin.remote,
-            benchmark: hostedProjectSummaryForOutput(remoteProject),
+            benchmark: remoteProjectSummaryForOutput(remoteProject),
             benchmarkName: source.spec.name,
             visibility: visibility ?? "unchanged",
             sourceFileCount: sourceFileCount(source),
@@ -3031,7 +3128,7 @@ async function pushBenchmark(argv, io) {
         method: "PUT",
         body: state,
     }, baseUrl);
-    const responseProject = hostedProjectSummaryFromState(response.state);
+    const responseProject = remoteProjectSummaryFromState(response.state);
     const publishedProject = await applyRequestedProjectVisibility({
         baseUrl,
         projectId: responseProject.id,
@@ -3079,7 +3176,7 @@ async function verifyLinkedPushDryRunTarget(args) {
     }
     return response.benchmark;
 }
-function hostedProjectSummaryForOutput(project) {
+function remoteProjectSummaryForOutput(project) {
     return {
         ...(project.id ? { id: project.id } : {}),
         ...(project.ownerUsername ? { ownerUsername: project.ownerUsername } : {}),
@@ -3089,12 +3186,12 @@ function hostedProjectSummaryForOutput(project) {
         ...(typeof project.starCount === "number" ? { starCount: project.starCount } : {}),
     };
 }
-async function createHostedBenchmarkFromState(args) {
+async function createRemoteBenchmarkFromState(args) {
     const result = await apiRequest("/api/workbench/benchmarks/state", {
         method: "POST",
         body: args.state,
     }, args.baseUrl);
-    const project = hostedProjectSummaryFromState(result.state);
+    const project = remoteProjectSummaryFromState(result.state);
     const applied = await acceptPushedProjectStateToLocal({
         dir: args.dir,
         baseUrl: args.baseUrl,
@@ -3168,7 +3265,7 @@ async function pullProject(argv, io) {
     }
     const dir = resolveDir(parsed);
     const origin = await requireWorkbenchOrigin(dir);
-    const baseUrl = await effectiveBaseUrl(origin.baseUrl);
+    const baseUrl = await effectiveOriginBaseUrl(origin.baseUrl);
     const remoteRef = parseOriginRemote(origin);
     const state = await apiRequest(publicProjectStateApiPath(remoteRef), {}, baseUrl);
     if (parsed.flags["dry-run"] === true) {
@@ -3228,7 +3325,7 @@ async function acceptPushedProjectStateToLocal(args) {
     });
     return { origin, runtime: runtime.stats };
 }
-async function retryHostedWorkflow(argv, io) {
+async function retryRemoteWorkflow(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set([
         "dir",
@@ -3238,7 +3335,7 @@ async function retryHostedWorkflow(argv, io) {
         "timeout-ms",
         "json",
     ]));
-    rejectUnexpectedPositionals(parsed, "workbench retry --hosted", 1);
+    rejectUnexpectedPositionals(parsed, "workbench retry --remote", 1);
     const targetId = parsed.positionals[0];
     if (!targetId) {
         throw new UsageError("Missing required TARGET_ID.");
@@ -3247,8 +3344,8 @@ async function retryHostedWorkflow(argv, io) {
         parsed.flags["timeout-ms"] !== undefined)) {
         throw new UsageError("--interval-ms and --timeout-ms require --watch.");
     }
-    const target = await resolveHostedTarget(parsed, { requireProjectIdentity: true });
-    const retryTarget = await resolveHostedRetryTarget(target, targetId);
+    const target = await resolveRemoteTarget(parsed, { requireProjectIdentity: true });
+    const retryTarget = await resolveRemoteRetryTarget(target, targetId);
     const watchIntervalMs = parsed.flags.watch === true
         ? parsePositiveInt(parsed.flags["interval-ms"], 1000, "interval-ms")
         : undefined;
@@ -3259,23 +3356,23 @@ async function retryHostedWorkflow(argv, io) {
         method: "POST",
         body: retryTarget.request,
     }, target.baseUrl);
-    const runTarget = hostedTargetForRunStartResponse(target, response);
+    const runTarget = remoteTargetForRunStartResponse(target, response);
     const startedRun = withRunUrls(runTarget, response.run);
     if (parsed.flags.watch === true) {
         if (parsed.flags.json !== true) {
-            io.stdout.write(`${formatHostedRunStarted(startedRun, retryTarget.workflow).trimEnd()}\n${HOSTED_WATCH_LIFECYCLE_NOTE}\n`);
+            io.stdout.write(`${formatRemoteRunStarted(startedRun, retryTarget.workflow).trimEnd()}\n${REMOTE_WATCH_LIFECYCLE_NOTE}\n`);
         }
-        const watched = await watchHostedRun({
+        const watched = await watchRemoteRun({
             parsed,
             target: runTarget,
             runId: response.run.id,
             intervalMs: watchIntervalMs ?? 1000,
             timeoutMs: watchTimeoutMs,
         });
-        const outputRun = withRunUrls(runTarget, await withHostedRunFailureSummary(runTarget, watched));
-        await tryImportTerminalHostedProjectState({ target: runTarget, io });
+        const outputRun = withRunUrls(runTarget, await withRemoteRunFailureSummary(runTarget, watched));
+        await tryImportTerminalRemoteProjectState({ target: runTarget, io });
         const result = {
-            ok: hostedRunSucceeded(watched),
+            ok: remoteRunSucceeded(watched),
             retried: {
                 id: retryTarget.sourceId,
                 kind: retryTarget.sourceKind,
@@ -3290,7 +3387,7 @@ async function retryHostedWorkflow(argv, io) {
             ...(outputRun.error ? { error: outputRun.error } : {}),
         };
         writeOutput(result, parsed, io, formatRetryCommandResult);
-        return hostedRunSucceeded(watched) ? 0 : 1;
+        return remoteRunSucceeded(watched) ? 0 : 1;
     }
     const result = {
         ok: true,
@@ -3308,20 +3405,20 @@ async function retryHostedWorkflow(argv, io) {
     writeOutput(result, parsed, io, formatRetryCommandResult);
     return 0;
 }
-async function resolveHostedRetryTarget(target, targetId) {
+async function resolveRemoteRetryTarget(target, targetId) {
     if (targetId.startsWith("eval_")) {
-        return await resolveHostedEvaluationRetryTarget(target, targetId);
+        return await resolveRemoteEvaluationRetryTarget(target, targetId);
     }
-    const detail = await readHostedRunDetail(target, targetId);
+    const detail = await readRemoteRunDetail(target, targetId);
     const run = detail.run;
     if (run.status !== "finished") {
         throw new UsageError(`Run ${run.id} is ${run.status}; wait for it to finish before retrying.`);
     }
-    if (!hostedRunRecordFailed(run)) {
-        throw new UsageError(`Run ${run.id} did not fail; use workbench ${run.workflow ?? "eval"} --hosted to intentionally run it again.`);
+    if (!remoteRunRecordFailed(run)) {
+        throw new UsageError(`Run ${run.id} did not fail; use workbench ${run.workflow ?? "eval"} --remote to intentionally run it again.`);
     }
     if (run.workflow === "eval") {
-        const candidateId = hostedRunEvaluationCandidateId(run, detail.jobs);
+        const candidateId = remoteRunEvaluationCandidateId(run, detail.jobs);
         if (!candidateId) {
             throw new UsageError(`Run ${run.id} has no candidate id to retry.`);
         }
@@ -3330,17 +3427,18 @@ async function resolveHostedRetryTarget(target, targetId) {
             sourceKind: "run",
             workflow: "eval",
             request: {
+                schema: "workbench.remote.run.request.v1",
                 workflow: "eval",
                 samples: run.samples ?? 1,
                 candidateId,
-                sourceYaml: hostedRetrySourceYaml(run, run.id),
+                sourceYaml: remoteRetrySourceYaml(run, run.id),
                 preserveActive: true,
                 ...retrySampleSelectionFromJobs(detail.jobs),
             },
         };
     }
     if (run.workflow === "improve") {
-        const baseCandidateId = stringValue(readRecord(run.input)?.baseCandidateId);
+        const baseCandidateId = stringValue(readRecord(run.retry)?.baseCandidateId);
         if (!baseCandidateId) {
             throw new UsageError(`Run ${run.id} is missing its base candidate id.`);
         }
@@ -3349,41 +3447,43 @@ async function resolveHostedRetryTarget(target, targetId) {
             sourceKind: "run",
             workflow: "improve",
             request: {
+                schema: "workbench.remote.run.request.v1",
                 workflow: "improve",
                 samples: run.samples ?? 1,
                 budget: run.budget ?? run.attemptsRequested ?? 1,
                 candidateId: baseCandidateId,
-                sourceYaml: hostedRetrySourceYaml(run, run.id),
+                sourceYaml: remoteRetrySourceYaml(run, run.id),
                 preserveActive: true,
             },
         };
     }
     throw new UsageError(`Run ${run.id} has no retryable workflow.`);
 }
-async function resolveHostedEvaluationRetryTarget(target, evaluationId) {
+async function resolveRemoteEvaluationRetryTarget(target, evaluationId) {
     const snapshot = await apiRequest(projectApiPath(target.projectId, "/workbench/snapshot"), {}, target.baseUrl);
     const evaluation = snapshot.evaluations.find((entry) => entry.id === evaluationId);
     if (!evaluation) {
-        throw new UsageError(`Hosted evaluation not found: ${evaluationId}`);
+        throw new UsageError(`Remote evaluation not found: ${evaluationId}`);
     }
     const run = snapshot.runs.find((entry) => entry.id === evaluation.runId) ?? null;
     if (!evaluationScorecardFailed(evaluation, run)) {
-        throw new UsageError(`Evaluation ${evaluation.id} did not fail; use workbench eval --hosted to intentionally run it again.`);
+        throw new UsageError(`Evaluation ${evaluation.id} did not fail; use workbench eval --remote to intentionally run it again.`);
     }
     if (!run) {
         throw new UsageError(`Evaluation ${evaluation.id} is missing its run record.`);
     }
-    const detail = await readHostedRunDetail(target, run.id);
+    const detail = await readRemoteRunDetail(target, run.id);
     const detailedRun = detail.run;
     return {
         sourceId: evaluationId,
         sourceKind: "evaluation",
         workflow: "eval",
         request: {
+            schema: "workbench.remote.run.request.v1",
             workflow: "eval",
             samples: evaluation.sampleCount || detailedRun.samples || 1,
             candidateId: evaluation.candidateId,
-            sourceYaml: hostedRetrySourceYaml(detailedRun, detailedRun.id),
+            sourceYaml: remoteRetrySourceYaml(detailedRun, detailedRun.id),
             preserveActive: true,
             ...retrySampleSelectionFromJobs(detail.jobs),
         },
@@ -3392,7 +3492,7 @@ async function resolveHostedEvaluationRetryTarget(target, evaluationId) {
 function retrySampleSelectionFromJobs(jobs) {
     const selectedSamples = uniqueCaseSamplePairs(jobs
         .filter((job) => job.status !== "succeeded" &&
-        executionPurposeFromJobInput(job.input) === "attempt")
+        readRunJobPurpose(job) === "attempt")
         .map(caseSamplePairFromJob)
         .filter((pair) => pair !== null));
     return selectedSamples.length > 0
@@ -3407,10 +3507,10 @@ function uniqueCaseSamplePairs(pairs) {
     return [...byKey.values()].sort((left, right) => left.caseId.localeCompare(right.caseId) ||
         left.sampleIndex - right.sampleIndex);
 }
-async function readHostedRunDetail(target, runId) {
+async function readRemoteRunDetail(target, runId) {
     return await apiRequest(projectApiPath(target.projectId, `/runs/${encodeURIComponent(runId)}`), {}, target.baseUrl);
 }
-async function tryImportTerminalHostedProjectState(args) {
+async function tryImportTerminalRemoteProjectState(args) {
     const origin = args.target.origin;
     if (!origin || origin.projectId !== args.target.projectId) {
         return;
@@ -3426,23 +3526,23 @@ async function tryImportTerminalHostedProjectState(args) {
         });
     }
     catch (error) {
-        args.io.stderr.write(`Hosted run finished, but local project state was not updated: ${errorMessage(error)}\n`);
+        args.io.stderr.write(`Remote run finished, but local project state was not updated: ${errorMessage(error)}\n`);
     }
 }
-function hostedRetrySourceYaml(run, runId) {
-    const sourceYaml = stringValue(readRecord(run.input)?.sourceYaml);
+function remoteRetrySourceYaml(run, runId) {
+    const sourceYaml = stringValue(readRecord(run.retry)?.sourceYaml);
     if (!sourceYaml) {
         throw new UsageError(`Run ${runId} is missing its recorded source configuration.`);
     }
     return sourceYaml;
 }
-function hostedRunRecordFailed(run) {
+function remoteRunRecordFailed(run) {
     return run.outcome === "error" ||
         run.outcome === "cancelled" ||
         (run.failedJobCount ?? 0) > 0 ||
         Boolean(run.error);
 }
-async function startHostedWorkflow(workflow, argv, io) {
+async function startRemoteWorkflow(workflow, argv, io) {
     const parsed = parseArgs(argv);
     const allowedFlags = new Set([
         "dir",
@@ -3465,7 +3565,7 @@ async function startHostedWorkflow(workflow, argv, io) {
     }
     rejectUnknownFlags(parsed, allowedFlags);
     if (parsed.positionals.length > 1) {
-        throw new UsageError(`workbench ${workflow} --hosted accepts at most one source file or directory argument.`);
+        throw new UsageError(`workbench ${workflow} --remote accepts at most one source file or directory argument.`);
     }
     const sourceArg = resolveSourceDir(parsed);
     const samples = parsePositiveInt(parsed.flags.samples, 1, "samples");
@@ -3480,13 +3580,13 @@ async function startHostedWorkflow(workflow, argv, io) {
     const defaultProjectSource = await readLocalProjectSource(path.resolve(sourceArg));
     const selectedRunIds = workflow === "eval"
         ? resolveCandidateRunSelection(defaultProjectSource, runsFlag)
-        : [singleRequestedRunId(runsFlag, `workbench ${workflow} --hosted`) ?? defaultProjectSource.candidateRunId];
+        : [singleRequestedRunId(runsFlag, `workbench ${workflow} --remote`) ?? defaultProjectSource.candidateRunId];
     if (workflow === "eval" && selectedRunIds.length > 1) {
         let failed = 0;
         const results = [];
         for (const runId of selectedRunIds) {
             const captured = createCapturingIo(io);
-            const code = await startHostedWorkflow(workflow, hostedWorkflowArgsForRun({
+            const code = await startRemoteWorkflow(workflow, remoteWorkflowArgsForRun({
                 parsed,
                 sourceDir: defaultProjectSource.dir,
                 runId,
@@ -3501,7 +3601,7 @@ async function startHostedWorkflow(workflow, argv, io) {
             candidateRunIds: selectedRunIds,
             failedRunCount: failed,
             results,
-        }, parsed, io, () => `Processed ${selectedRunIds.length} hosted candidate run(s); ${failed} failed.`);
+        }, parsed, io, () => `Processed ${selectedRunIds.length} remote candidate run(s); ${failed} failed.`);
         return failed === 0 ? 0 : 1;
     }
     const selectedCandidateId = workflow === "eval"
@@ -3509,12 +3609,14 @@ async function startHostedWorkflow(workflow, argv, io) {
         : asOptionalString(parsed.flags.base);
     const request = workflow === "improve"
         ? {
+            schema: "workbench.remote.run.request.v1",
             workflow,
             budget,
             samples,
             ...(selectedCandidateId ? { candidateId: selectedCandidateId } : {}),
         }
         : {
+            schema: "workbench.remote.run.request.v1",
             workflow,
             samples,
             ...(selectedCandidateId ? { candidateId: selectedCandidateId } : {}),
@@ -3538,7 +3640,7 @@ async function startHostedWorkflow(workflow, argv, io) {
         : undefined;
     const dryRun = parsed.flags["dry-run"] === true;
     if (dryRun) {
-        const target = await resolveHostedDryRunTarget(parsed, { sourceDir: projectSource.dir });
+        const target = await resolveRemoteDryRunTarget(parsed, { sourceDir: projectSource.dir });
         writeOutput({
             ok: true,
             dryRun: true,
@@ -3547,20 +3649,21 @@ async function startHostedWorkflow(workflow, argv, io) {
             dir: target.dir,
             baseUrl: target.baseUrl,
             request,
-        }, parsed, io, () => `Would start hosted ${workflow} for ${target.projectRef}.`);
+        }, parsed, io, () => `Would start remote ${workflow} for ${target.projectRef}.`);
         return 0;
     }
-    const target = await resolveHostedTarget(parsed, {
+    const target = await resolveRemoteTarget(parsed, {
         requireProjectIdentity: true,
         sourceDir: projectSource.dir,
     });
     if (workflow === "improve") {
-        request.candidateId = await ensureHostedImproveBaseCandidate({
+        request.candidateId = await ensureRemoteImproveBaseCandidate({
             parsed,
             target,
             samples: request.samples,
             candidateId: selectedCandidateId,
             sourceYaml: projectSource.specSource,
+            candidateFiles: projectSource.candidateFiles,
             adapterFiles: projectSource.adapterFiles,
             intervalMs: watchIntervalMs ?? 1000,
             timeoutMs: watchTimeoutMs,
@@ -3571,53 +3674,53 @@ async function startHostedWorkflow(workflow, argv, io) {
         method: "POST",
         body: request,
     }, target.baseUrl);
-    const runTarget = hostedTargetForRunStartResponse(target, response);
+    const runTarget = remoteTargetForRunStartResponse(target, response);
     const startedRun = withRunUrls(runTarget, response.run);
     const startedRunOutput = response.reused === true
         ? { ...startedRun, reused: true }
         : startedRun;
     if (response.reused === true && response.run.status === "finished") {
-        await tryImportTerminalHostedProjectState({ target: runTarget, io });
+        await tryImportTerminalRemoteProjectState({ target: runTarget, io });
         writeOutput({
-            ok: hostedRunSucceeded(response.run),
+            ok: remoteRunSucceeded(response.run),
             reused: true,
             workflow,
             runId: startedRun.id,
             ...startedRun,
-        }, parsed, io, () => `Reused hosted ${workflow} ${startedRun.id}. Use --rerun to intentionally run it again.`);
-        return hostedRunSucceeded(response.run) ? 0 : 1;
+        }, parsed, io, () => `Reused remote ${workflow} ${startedRun.id}. Use --rerun to intentionally run it again.`);
+        return remoteRunSucceeded(response.run) ? 0 : 1;
     }
     if (parsed.flags.watch === true) {
         if (parsed.flags.json !== true) {
-            io.stdout.write(`${formatHostedRunStarted(startedRun, workflow).trimEnd()}\n${HOSTED_WATCH_LIFECYCLE_NOTE}\n`);
+            io.stdout.write(`${formatRemoteRunStarted(startedRun, workflow).trimEnd()}\n${REMOTE_WATCH_LIFECYCLE_NOTE}\n`);
         }
-        const watched = await watchHostedRun({
+        const watched = await watchRemoteRun({
             parsed,
             target: runTarget,
             runId: response.run.id,
             intervalMs: watchIntervalMs ?? 1000,
             timeoutMs: watchTimeoutMs,
         });
-        const outputRun = await withHostedRunFailureSummary(runTarget, watched);
-        await tryImportTerminalHostedProjectState({ target: runTarget, io });
-        writeOutput(withRunUrls(runTarget, outputRun), parsed, io, formatHostedRunResult);
-        return hostedRunSucceeded(watched) ? 0 : 1;
+        const outputRun = await withRemoteRunFailureSummary(runTarget, watched);
+        await tryImportTerminalRemoteProjectState({ target: runTarget, io });
+        writeOutput(withRunUrls(runTarget, outputRun), parsed, io, formatRemoteRunResult);
+        return remoteRunSucceeded(watched) ? 0 : 1;
     }
-    writeOutput(startedRunOutput, parsed, io, (run) => formatHostedRunStarted(run, workflow).trimEnd());
+    writeOutput(startedRunOutput, parsed, io, (run) => formatRemoteRunStarted(run, workflow).trimEnd());
     return 0;
 }
-async function ensureHostedImproveBaseCandidate(args) {
+async function ensureRemoteImproveBaseCandidate(args) {
     if (args.candidateId) {
-        const candidate = await readHostedCandidateSummary(args.target, args.candidateId);
+        const candidate = await readRemoteCandidateSummary(args.target, args.candidateId);
         if (!candidate) {
             throw new UsageError(`Base candidate ${args.candidateId} was not found for the current benchmark.`);
         }
-        if (hostedCandidateIsEvaluated(candidate)) {
+        if (remoteCandidateIsEvaluated(candidate)) {
             return args.candidateId;
         }
     }
     else {
-        const activeCandidate = await readEvaluatedActiveHostedCandidate(args.target);
+        const activeCandidate = await readEvaluatedActiveRemoteCandidate(args.target);
         if (activeCandidate) {
             return activeCandidate.id;
         }
@@ -3625,31 +3728,33 @@ async function ensureHostedImproveBaseCandidate(args) {
     const response = await apiRequest(projectApiPath(args.target.projectId, "/runs"), {
         method: "POST",
         body: {
+            schema: "workbench.remote.run.request.v1",
             workflow: "eval",
             samples: args.samples,
             ...(args.candidateId ? { candidateId: args.candidateId } : {}),
             sourceYaml: args.sourceYaml,
+            ...(args.candidateId ? {} : { candidateFiles: args.candidateFiles }),
             ...(args.adapterFiles.length > 0 ? { adapterFiles: args.adapterFiles } : {}),
         },
     }, args.target.baseUrl);
-    const runTarget = hostedTargetForRunStartResponse(args.target, response);
-    const watched = await watchHostedRun({
+    const runTarget = remoteTargetForRunStartResponse(args.target, response);
+    const watched = await watchRemoteRun({
         parsed: args.parsed,
         target: runTarget,
         runId: response.run.id,
         intervalMs: args.intervalMs,
         timeoutMs: args.timeoutMs,
     });
-    if (!hostedRunSucceeded(watched)) {
+    if (!remoteRunSucceeded(watched)) {
         throw new UsageError(`Parent candidate eval ${watched.id} failed; improve was not started.`);
     }
     if (!watched.candidateId) {
         throw new UsageError(`Parent candidate eval ${watched.id} did not produce a candidate.`);
     }
-    await tryImportTerminalHostedProjectState({ target: runTarget, io: args.io });
+    await tryImportTerminalRemoteProjectState({ target: runTarget, io: args.io });
     return watched.candidateId;
 }
-function hostedWorkflowArgsForRun(args) {
+function remoteWorkflowArgsForRun(args) {
     const next = ["--dir", args.sourceDir, "--runs", args.runId, "--json"];
     appendStringFlag(next, "benchmark", asOptionalString(args.parsed.flags.benchmark));
     appendStringFlag(next, "candidate", asOptionalString(args.parsed.flags.candidate));
@@ -3672,27 +3777,27 @@ function appendStringFlag(args, name, value) {
         args.push(`--${name}`, value);
     }
 }
-async function readHostedCandidateSummary(target, candidateId) {
+async function readRemoteCandidateSummary(target, candidateId) {
     const response = await apiRequest(projectApiPath(target.projectId, "/candidates"), {}, target.baseUrl);
     return response.candidates.find((entry) => entry.id === candidateId) ?? null;
 }
-async function readEvaluatedActiveHostedCandidate(target) {
+async function readEvaluatedActiveRemoteCandidate(target) {
     const response = await apiRequest(projectApiPath(target.projectId), {}, target.baseUrl);
     const activeCandidateId = response.benchmark.activeCandidateId;
     if (!activeCandidateId) {
         return null;
     }
-    const candidate = await readHostedCandidateSummary(target, activeCandidateId);
-    return candidate && hostedCandidateIsEvaluated(candidate) ? candidate : null;
+    const candidate = await readRemoteCandidateSummary(target, activeCandidateId);
+    return candidate && remoteCandidateIsEvaluated(candidate) ? candidate : null;
 }
-function hostedCandidateIsEvaluated(candidate) {
+function remoteCandidateIsEvaluated(candidate) {
     return candidate.status === "evaluated" || candidate.eval != null;
 }
 async function openWorkbench(argv, io) {
     const parsed = parseArgs(argv);
     rejectUnknownFlags(parsed, new Set(["dir", "benchmark", "no-open", "json"]));
     if (parsed.positionals.length > 1) {
-        throw new UsageError(`Unexpected argument for workbench open --hosted: ${parsed.positionals.slice(1).join(" ")}`);
+        throw new UsageError(`Unexpected argument for workbench open --remote: ${parsed.positionals.slice(1).join(" ")}`);
     }
     const target = await resolveOpenTarget(parsed);
     const ref = target.openRef;
@@ -3722,7 +3827,7 @@ function buildWorkbenchWebUrl(target, ref) {
     }
     return buildWorkbenchResourceUrls(target, { candidateId: ref }).candidateEvaluation;
 }
-async function resolveHostedTarget(parsed, options = {}) {
+async function resolveRemoteTarget(parsed, options = {}) {
     if (options.sourceArg !== undefined && parsed.flags.dir !== undefined) {
         throw new UsageError("Use either --dir or SOURCE, not both.");
     }
@@ -3731,7 +3836,7 @@ async function resolveHostedTarget(parsed, options = {}) {
         : resolveDir(parsed, options.sourceArg);
     const origin = await readWorkbenchOrigin(dir);
     const explicitProject = asOptionalString(parsed.flags.benchmark);
-    const baseUrl = await effectiveBaseUrl(origin?.baseUrl);
+    const baseUrl = await effectiveOriginBaseUrl(origin?.baseUrl);
     if (explicitProject && (!isRemoteProjectId(explicitProject) || options.requireProjectIdentity === true)) {
         const project = await resolveRemoteProject(explicitProject, baseUrl);
         return {
@@ -3745,7 +3850,7 @@ async function resolveHostedTarget(parsed, options = {}) {
     }
     const projectId = explicitProject ?? origin?.projectId;
     if (!projectId) {
-        throw new UsageError("Missing hosted benchmark. Run workbench push, workbench clone, or pass --benchmark OWNER/BENCHMARK.");
+        throw new UsageError("Missing remote benchmark. Run workbench push, workbench clone, or pass --benchmark OWNER/BENCHMARK.");
     }
     const originRemote = origin ? parseOriginRemote(origin) : null;
     return {
@@ -3759,7 +3864,7 @@ async function resolveHostedTarget(parsed, options = {}) {
         origin,
     };
 }
-async function resolveHostedDryRunTarget(parsed, options = {}) {
+async function resolveRemoteDryRunTarget(parsed, options = {}) {
     if (options.sourceArg !== undefined && parsed.flags.dir !== undefined) {
         throw new UsageError("Use either --dir or SOURCE, not both.");
     }
@@ -3768,7 +3873,7 @@ async function resolveHostedDryRunTarget(parsed, options = {}) {
         : resolveDir(parsed, options.sourceArg);
     const origin = await readWorkbenchOrigin(dir);
     const explicitProject = asOptionalString(parsed.flags.benchmark);
-    const baseUrl = await effectiveBaseUrl(origin?.baseUrl);
+    const baseUrl = await effectiveOriginBaseUrl(origin?.baseUrl);
     if (explicitProject) {
         if (isRemoteProjectId(explicitProject)) {
             return {
@@ -3801,7 +3906,7 @@ async function resolveHostedDryRunTarget(parsed, options = {}) {
             origin,
         };
     }
-    throw new UsageError("Missing hosted benchmark. Run workbench push, workbench clone, or pass --benchmark OWNER/BENCHMARK.");
+    throw new UsageError("Missing remote benchmark. Run workbench push, workbench clone, or pass --benchmark OWNER/BENCHMARK.");
 }
 async function resolveOpenTarget(parsed) {
     const ref = parsed.positionals[0];
@@ -3830,7 +3935,7 @@ async function resolveOpenTarget(parsed) {
         };
     }
     return {
-        ...(await resolveHostedTarget(parsed, { requireProjectIdentity: true })),
+        ...(await resolveRemoteTarget(parsed, { requireProjectIdentity: true })),
         ...(ref ? { openRef: ref } : {}),
     };
 }
@@ -3901,7 +4006,7 @@ function withRunUrls(target, run) {
         }),
     };
 }
-function hostedTargetForRunStartResponse(target, response) {
+function remoteTargetForRunStartResponse(target, response) {
     const projectId = response.benchmark?.id ?? response.run.projectId ?? target.projectId;
     if (projectId === target.projectId && !response.benchmark) {
         return target;
@@ -3926,7 +4031,7 @@ function hostedTargetForRunStartResponse(target, response) {
     }
     return next;
 }
-function hostedRunEvaluationCandidateId(run, jobs = []) {
+function remoteRunEvaluationCandidateId(run, jobs = []) {
     if (run.outputCandidateId) {
         return run.outputCandidateId;
     }
@@ -3986,7 +4091,7 @@ function runtimeBundleForProjectVisibility(runtime, visibility) {
     };
 }
 function localProjectStateSource(source) {
-    const request = hostedProjectSourceRequest(source);
+    const request = remoteProjectSourceRequest(source);
     const stateSource = {
         source: request.source,
         files: source.sourceFiles.map((file) => ({ ...file })),
@@ -4014,7 +4119,7 @@ function toSurfaceSnapshotFile(file) {
         executable: file.executable === true,
     };
 }
-function hostedProjectSummaryFromState(state) {
+function remoteProjectSummaryFromState(state) {
     return {
         id: state.project.id,
         ownerUsername: state.project.ownerUsername,
@@ -4025,12 +4130,12 @@ function hostedProjectSummaryFromState(state) {
 function sourceFileCount(source) {
     return source.sourceFiles.length;
 }
-function hostedProjectSourceRequest(source) {
-    const { network, resources } = hostedEnvironmentOptions(source);
+function remoteProjectSourceRequest(source) {
+    const { network, resources } = remoteEnvironmentOptions(source);
     return {
         source: source.specSource,
         candidateFiles: source.candidateFiles,
-        engineResolveFiles: hostedEngineResolveFiles(source),
+        engineResolveFiles: remoteEngineResolveFiles(source),
         engineResolveBinding: engineResolveBindingForSpec(source.spec),
         adapterFiles: source.adapterFiles,
         dockerfile: source.dockerfile,
@@ -4043,7 +4148,7 @@ function hostedProjectSourceRequest(source) {
 function isRemoteProjectId(value) {
     return /^wb_[a-f0-9]{12}$/u.test(value);
 }
-function hostedEnvironmentOptions(source) {
+function remoteEnvironmentOptions(source) {
     return {
         network: source.spec.environment.network?.egress === "open"
             ? "on"
@@ -4051,7 +4156,7 @@ function hostedEnvironmentOptions(source) {
         resources: runtimeResources(source.spec.environment),
     };
 }
-async function watchHostedRun(args) {
+async function watchRemoteRun(args) {
     const deadline = args.timeoutMs === undefined ? undefined : Date.now() + args.timeoutMs;
     let lastRun = null;
     while (true) {
@@ -4079,7 +4184,7 @@ async function watchHostedRun(args) {
         await sleep(args.intervalMs);
     }
 }
-function formatHostedRunResult(run) {
+function formatRemoteRunResult(run) {
     const candidateId = run.outputCandidateId ?? run.candidateId;
     const activeDetail = run.activeCandidateId && candidateId && run.activeCandidateId !== candidateId
         ? `; active ${run.activeCandidateId}`
@@ -4097,7 +4202,7 @@ function formatRetryCommandResult(result) {
     const runId = run?.id ?? result.runId ?? "unknown";
     const scope = `${result.retried.kind} ${result.retried.id}`;
     const verb = run
-        ? run.status === "finished" ? "finished as hosted run" : "started as hosted run"
+        ? run.status === "finished" ? "finished as remote run" : "started as remote run"
         : "finished as local run";
     return [
         `Retry of ${scope} ${verb} ${runId}.`,
@@ -4113,7 +4218,7 @@ function formatRetryCommandResult(result) {
             : result.urls?.benchmark ? [`Open benchmark: ${result.urls.benchmark}`] : []),
     ].join("\n");
 }
-function formatHostedRunStarted(run, fallbackWorkflow) {
+function formatRemoteRunStarted(run, fallbackWorkflow) {
     const candidateId = run.outputCandidateId ?? run.candidateId;
     return [
         `Started ${run.workflow ?? fallbackWorkflow} run ${run.id}; ${candidateId ? `candidate ${candidateId}` : `${run.jobCount ?? 0} jobs queued`}.`,
@@ -4124,10 +4229,7 @@ function formatHostedRunStarted(run, fallbackWorkflow) {
     ].join("\n");
 }
 function readRunJobPurpose(job) {
-    const input = readRecord(job.input);
-    const execution = readRecord(input?.execution);
-    const purpose = execution?.purpose;
-    return typeof purpose === "string" && purpose ? purpose : null;
+    return job.purpose && job.purpose.trim() ? job.purpose : null;
 }
 function readRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -4146,24 +4248,24 @@ function integerValue(value) {
 function readFiniteNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-async function withHostedRunFailureSummary(target, run) {
-    if (hostedRunSucceeded(run) || run.error || (run.failedJobCount ?? 0) <= 0) {
+async function withRemoteRunFailureSummary(target, run) {
+    if (remoteRunSucceeded(run) || run.error || (run.failedJobCount ?? 0) <= 0) {
         return run;
     }
-    const error = await readHostedRunFailureSummary(target, run.id);
+    const error = await readRemoteRunFailureSummary(target, run.id);
     return error ? { ...run, error } : run;
 }
-async function readHostedRunFailureSummary(target, runId) {
+async function readRemoteRunFailureSummary(target, runId) {
     try {
-        const project = await apiRequest(projectApiPath(target.projectId), {}, target.baseUrl);
-        const failed = project.benchmark.jobs.find((job) => job.runId === runId && job.status === "failed" && job.error);
+        const detail = await readRemoteRunDetail(target, runId);
+        const failed = detail.jobs.find((job) => job.status === "failed" && job.error);
         return failed?.error ? `First failed job ${failed.id}: ${failed.error}` : null;
     }
     catch {
         return null;
     }
 }
-function hostedRunSucceeded(run) {
+function remoteRunSucceeded(run) {
     if (run.status !== "finished") {
         return false;
     }
@@ -4179,16 +4281,6 @@ async function readWorkbenchOrigin(dir) {
             throw new UsageError(`Workbench origin is malformed: ${workbenchOriginPath(dir)}`);
         }
         const originRecord = parsed;
-        const keys = Object.keys(originRecord).sort();
-        const expectedKeys = [
-            "baseUrl",
-            "linkedAt",
-            "projectId",
-            "remote",
-            "runtimeFingerprint",
-            "sourceFingerprint",
-            "sourceRevisionId",
-        ];
         if (typeof originRecord.projectId !== "string" ||
             typeof originRecord.baseUrl !== "string" ||
             typeof originRecord.remote !== "string" ||
@@ -4202,9 +4294,6 @@ async function readWorkbenchOrigin(dir) {
             originRecord.runtimeFingerprint.length === 0) {
             throw new UsageError(`Workbench origin is malformed: ${workbenchOriginPath(dir)}`);
         }
-        if (JSON.stringify(keys) !== JSON.stringify(expectedKeys)) {
-            throw new UsageError(`Workbench origin is malformed: ${workbenchOriginPath(dir)}`);
-        }
         return {
             baseUrl: normalizeBaseUrl(originRecord.baseUrl),
             remote: normalizeOriginRemote(originRecord.remote),
@@ -4254,7 +4343,7 @@ async function writeWorkbenchOriginFromState(dir, args) {
     const runtimeFingerprint = args.state.base.runtimeFingerprint ??
         workbenchRuntimeBundleFingerprint(args.state.runtime);
     if (!sourceRevisionId || !sourceFingerprint || !runtimeFingerprint) {
-        throw new UsageError("Hosted project state is missing required origin metadata.");
+        throw new UsageError("Remote project state is missing required origin metadata.");
     }
     return await writeWorkbenchOrigin(dir, {
         baseUrl: args.baseUrl,
@@ -4290,18 +4379,29 @@ function originRemoteUrlParts(origin) {
 function workbenchOriginPath(dir) {
     return path.join(dir, ".workbench", "origin.json");
 }
-async function effectiveBaseUrl(preferred) {
+async function effectiveBaseUrl() {
+    const config = await loadConfig();
+    return selectWorkbenchBaseUrl({ configBaseUrl: config.baseUrl });
+}
+async function effectiveOriginBaseUrl(originBaseUrl) {
     const config = await loadConfig();
-    return normalizeBaseUrl(process.env.WORKBENCH_API_URL ??
-        preferred ??
-        config.baseUrl ??
+    return selectWorkbenchBaseUrl({
+        originBaseUrl,
+        configBaseUrl: config.baseUrl,
+    });
+}
+function selectWorkbenchBaseUrl(input = {}) {
+    return normalizeBaseUrl(input.explicitBaseUrl ??
+        input.originBaseUrl ??
+        process.env.WORKBENCH_API_URL ??
+        input.configBaseUrl ??
         DEFAULT_BASE_URL);
 }
 async function readWorkbenchProfileStatus(config) {
     if (!config.accessToken) {
         return { authenticated: false, profile: null };
     }
-    const baseUrl = await effectiveBaseUrl(config.baseUrl);
+    const baseUrl = selectWorkbenchBaseUrl({ configBaseUrl: config.baseUrl });
     try {
         const response = await fetch(`${baseUrl}/api/workbench/profile`, {
             headers: {
@@ -4327,10 +4427,9 @@ async function readWorkbenchProfileStatus(config) {
 }
 async function apiRequest(apiPath, options = {}, baseUrlOverride) {
     const config = await loadConfig();
-    const baseUrl = normalizeBaseUrl(baseUrlOverride ??
-        process.env.WORKBENCH_API_URL ??
-        config.baseUrl ??
-        DEFAULT_BASE_URL);
+    const baseUrl = baseUrlOverride !== undefined
+        ? normalizeBaseUrl(baseUrlOverride)
+        : selectWorkbenchBaseUrl({ configBaseUrl: config.baseUrl });
     const method = options.method ?? "GET";
     const canRetry = method === "GET";
     let lastError = null;
@@ -4868,6 +4967,24 @@ function formatMetricValue(value) {
     }
     return value.toFixed(2);
 }
+function formatNullableMetric(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? formatMetricValue(value)
+        : "n/a";
+}
+function formatFailureLine(failure) {
+    return [
+        failure.kind,
+        failure.id,
+        failure.status ?? "failed",
+        failure.runId ? `run=${failure.runId}` : null,
+        failure.candidateId ? `candidate=${failure.candidateId}` : null,
+        failure.jobId ? `job=${failure.jobId}` : null,
+        failure.caseId ? `case=${failure.caseId}` : null,
+        typeof failure.sampleIndex === "number" ? `sample=${failure.sampleIndex}` : null,
+        failure.error ?? null,
+    ].filter(Boolean).join("\t");
+}
 function resolveDir(parsed, positionalDir) {
     const resolved = path.resolve(asOptionalString(parsed.flags.dir) ?? positionalDir ?? process.cwd());
     return isWorkbenchSourceYamlPath(resolved) ? path.dirname(resolved) : resolved;
@@ -4928,28 +5045,12 @@ async function resolveLocalProjectForExecution(workspace, source) {
     };
 }
 function completedJobOutputFiles(job) {
-    const output = asJsonRecord(job.output);
+    const output = jsonRecord(job.output);
     const files = Array.isArray(output.files)
         ? output.files.filter(isSurfaceSnapshotFile)
         : [];
     return normalizeSurfaceFiles(files);
 }
-function asJsonRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-function isSurfaceSnapshotFile(value) {
-    const record = asJsonRecord(value);
-    return (typeof record.path === "string" &&
-        typeof record.content === "string" &&
-        (record.kind === undefined ||
-            record.kind === "text" ||
-            record.kind === "binary") &&
-        (record.encoding === undefined ||
-            record.encoding === "utf8" ||
-            record.encoding === "base64"));
-}
 function createLocalEvent(type, at, event) {
     return {
         id: `evt_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`,