self-bench 0.3.2 → 0.3.4

package/docs/operations.md

@@ -18,23 +18,29 @@ Temporal and artifact state live in the `selfbench_temporal-postgres` and `selfb
 
 ## Credentials
 
-SelfBench uses three separate credentials:
+self-bench requires GitHub and model credentials:
 
 - `gh auth login` supplies read access to merged pull requests. Export `GH_TOKEN="$(gh auth token)"` for the worker. Write access is not required.
-- Pi's `openai-codex` entry in `~/.pi/agent/auth.json` powers discovery, authoring, and review.
-- `~/.codex/auth.json` powers the constrained repair step and agent evaluation.
+- `OPENAI_API_KEY` powers discovery, authoring, review, constrained repair, and model evaluation. This is the recommended model-authentication path.
 
-Both model credentials must be backed by a ChatGPT subscription. SelfBench removes API-key fields and does not fall back to `OPENAI_API_KEY`.
+Existing deployments may continue using ChatGPT subscription authentication by providing both `SELFBENCH_PI_AUTH_JSON` and `SELFBENCH_CODEX_AUTH_JSON`. API-key authentication takes precedence when `OPENAI_API_KEY` is set.
 
-Compose mounts the default auth files read-only. Override their host paths before starting the stack when necessary:
+Sandbox-provider credentials are separate. Modal accepts its mounted profile or token pair. For a local Vercel worker, `self-bench setup vercel` stores a project-scoped token in an owner-only local profile. Unattended workers use the equivalent `VERCEL_TOKEN`, `VERCEL_TEAM_ID`, and `VERCEL_PROJECT_ID` environment variables. Keep provider credentials on the worker; the API does not need them.
+
+## Execution backends and Harbor
+
+SelfBench uses one provider for discovery, authoring, semantic review, and repair sandboxes. It separately invokes Harbor for nop/oracle validation. Docker and Modal default Harbor to the matching environment. Vercel has no Harbor environment, so `--harbor-environment docker|modal` is mandatory.
 
 ```bash
-export SELFBENCH_PI_AUTH_PATH=/absolute/path/to/pi-auth.json
-export SELFBENCH_CODEX_AUTH_PATH=/absolute/path/to/codex-auth.json
-self-bench up
+self-bench up --backend docker                         # Docker + Docker
+self-bench up --backend modal                          # Modal + Modal
+self-bench up --backend vercel --harbor-environment docker
+self-bench up --backend vercel --harbor-environment modal
+self-bench up --backend docker --harbor-environment modal
+self-bench up --backend modal --harbor-environment docker
 ```
 
-## Execution backends
+Use `--modal-config` whenever either side uses Modal. A worker has one fixed pairing; do not run workers with different provider settings on the same Temporal task queue. Run and export metadata record both choices, plus the effective Vercel timeout cap when applicable.
 
 ### Docker
 
@@ -59,10 +65,95 @@ self-bench up --backend modal
 self-bench up --backend modal --modal-config /absolute/path/to/.modal.toml
 ```
 
-`self-bench up` selects both sandbox execution and Harbor validation for the requested backend. Modal mounts `~/.modal.toml` by default; `--modal-config` overrides that path. A secret manager may provide `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET` instead. Empty token environment variables are removed at worker startup so they cannot override a valid mounted profile.
+When Modal is used for generation or Harbor, SelfBench mounts `~/.modal.toml` by default; `--modal-config` overrides that path. A secret manager may provide `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET` instead. Empty token environment variables are removed at worker startup so they cannot override a valid mounted profile.
 
 Modal defaults to 20 concurrent worker activities. Discovery starts eight independently retryable shards, and candidate slots are continuously refilled. Discovery and authoring stop after eight minutes without process output; review stops after five. Discovery also has a 45-minute per-attempt deadline and up to three attempts per shard.
 
+### Vercel Sandbox
+
+Vercel is a generation backend only; choose Docker or Modal for Harbor. SelfBench supports both Vercel's 45-minute Hobby Sandbox ceiling and the longer paid-team ceiling. Discovery requests 45 minutes, review requests 15 minutes, and authoring and repair request two hours; setup detects the selected project's effective capability and caps every Vercel stage centrally when necessary. Sandbox use, VCR storage, memory, active CPU, and data transfer are metered by Vercel; configure Spend Management before unattended runs. Vercel Hobby use is intended for personal, non-commercial work.
+
+#### Interactive local setup
+
+Install the current Vercel CLI and make sure Docker is available for the runtime-image build:
+
+```bash
+npm install --global vercel@latest
+self-bench setup vercel
+```
+
+Interactive setup keeps long-running publication and capability checks compact, with a live elapsed timer that freezes when each step completes. Use `self-bench setup vercel --verbose` to stream the underlying Vercel CLI and Docker build output; compact mode reveals retained command output automatically when a step fails.
+
+Setup uses Vercel CLI browser login for control-plane selection and VCR publication. It then:
+
+1. shows a searchable team or personal-scope picker;
+2. offers a searchable existing-project picker or creation of a dedicated project;
+3. asks for a project name, defaulting to `selfbench-sandbox`, and retries rather than silently suffixing an unavailable name;
+4. publishes the pinned `Dockerfile.sandbox` runtime to the project's `selfbench-runtime` VCR repository;
+5. prints the Vercel token page and asks for a manually created access token restricted to the selected project, with terminal echo disabled;
+6. creates and immediately deletes a one-vCPU, nonpersistent probe sandbox to verify the token, image, command execution, cleanup, and effective duration ceiling;
+7. activates the profile only after every required check succeeds.
+
+The project does not need a deployment. Its metered use is billed to its owning Vercel scope. CLI login and worker configuration are deliberately separate: CLI login selects and provisions resources, while the project-scoped token plus team and project IDs configure the SelfBench worker. Although the Vercel SDK supports ambient OIDC on Vercel infrastructure, SelfBench does not use it.
+
+Profiles live in `~/.selfbench/config.json`; tokens live separately in `~/.selfbench/credentials.json`. The directory is mode `0700`, both files are mode `0600`, writes are atomic, and displayed setup output never includes the token. Override the directory with `SELFBENCH_CONFIG_DIR` when isolation is needed. To maintain more than one project profile:
+
+```bash
+self-bench setup vercel --profile secondary
+self-bench up --backend vercel --vercel-profile secondary --harbor-environment modal
+```
+
+Without `--vercel-profile`, `self-bench up` uses the active profile most recently saved by setup. Rerunning setup revalidates the existing project and token by default. It fingerprints the exact Dockerfile—including its digest-pinned base and pinned tool defaults—plus the fingerprint schema and target platform; if the matching immutable VCR image is already ready, publication is skipped. A changed runtime produces a new content-derived tag and digest. The final image reference is always digest-pinned, and existing digests are not deleted automatically. If the default VCR repository contains unrelated images, setup leaves it untouched and asks for another name.
+
+When rerunning setup for a named profile, the available actions are:
+
+- **Revalidate** keeps the saved team, project, and token. It verifies current access, reuses a compatible ready image, republishes only if the runtime fingerprint changed, reruns the temporary Sandbox capability probe, and refreshes the saved image digest and timeout cap.
+- **Replace the access token** keeps the saved team and project, requests a new project-scoped token, and activates it only after verification succeeds. It replaces only the locally stored credential; revoke the old token separately in Vercel if necessary.
+- **Choose another team or project** repoints the same local profile name after the new project, image, and token pass verification. It does not delete the previous Vercel project or images. Use a different `--profile` name instead when both configurations should remain available.
+
+If setup is interrupted after creating a project or VCR repository, it reports the failure and leaves the durable resource in place; rerun setup to continue. It never activates a partial profile. Vercel projects and VCR images are reusable across SelfBench runs and persist after `self-bench down`.
+
+#### Start the local worker
+
+```bash
+self-bench up --backend vercel --harbor-environment modal
+# self-bench up --backend vercel --harbor-environment docker
+```
+
+Modal Harbor also needs the Modal profile or token pair. Vercel control credentials are removed from the Harbor child process for both Harbor environments. `self-bench up` resolves the profile, then validates the complete credential triple, digest-pinned image, and timeout cap before starting Compose.
+
+The setup probe records a two-hour effective SelfBench ceiling when the requested two-hour sandbox is accepted. If Vercel returns its exact 45-minute limit response, setup verifies a 45-minute sandbox, explains the impact, and asks before saving that cap. Longer authoring and repair requests then run for at most 45 minutes and return exit 124 on timeout, so only the affected candidate is rejected. Discovery and review retain their shorter requested limits. The effective cap is included in run and export metadata.
+
+#### Environment-only and unattended workers
+
+`self-bench setup vercel` is intentionally interactive. CI and long-running workers can provide the same resolved values through environment variables or a secret manager:
+
+```bash
+export VERCEL_TOKEN=...
+export VERCEL_TEAM_ID=team_...
+export VERCEL_PROJECT_ID=prj_...
+export SELFBENCH_VERCEL_IMAGE='selfbench-runtime@sha256:...'
+export SELFBENCH_VERCEL_TIMEOUT_CAP=2h  # use 45m when that is the verified ceiling
+
+self-bench up --backend vercel --harbor-environment modal
+```
+
+The image must already have been published from `Dockerfile.sandbox` to the same project's VCR as `linux/amd64`. Use the bare repository-plus-digest form shown above; tags and rolling aliases are rejected. VCR repositories are project-scoped by default, so a sandbox in another project cannot use the image unless the repository is explicitly shared. Explicit token and image values take precedence over profile values, and a lower timeout cap may be supplied; an override cannot exceed the profile's verified ceiling. Supplying a complete credential/image environment requires no local profile; partial team or project overrides are rejected rather than combined across scopes.
+
+Vercel defaults to four concurrent worker activities. A standard SelfBench sandbox requests 4 vCPUs, which Vercel pairs with 8 GB of memory, plus 32 GB of ephemeral disk. Unsupported CPU/memory combinations are rejected before allocation. Raise `SELFBENCH_ACTIVITY_CONCURRENCY` only after considering the team's allocation limits and budget. Lower it—often to `1`—when using Docker Harbor on a smaller local machine, because the Vercel-oriented default does not account for local Harbor capacity.
+
+Each sandbox run uses a fresh nonpersistent sandbox (`persistent: false`). SelfBench does not create snapshots or resume stopped sandboxes, and it attempts to delete every sandbox when the run ends. If deletion cannot be confirmed, the activity fails so the cleanup problem remains visible. If the worker crashes before cleanup, compute may continue until the provider timeout; Vercel then discards the filesystem, although the stopped sandbox record may remain for up to 14 days unless manually deleted.
+
+Cancel active workflows and let cleanup finish before stopping the stack.
+
+Common failures:
+
+- A newly changed paid plan may take time to propagate its longer timeout entitlement. Rerun `self-bench setup vercel` to repeat the short-lived capability probe and update the saved cap; if a correctly scoped paid project continues to detect 45 minutes, verify team/project ownership before contacting Vercel Support.
+- `not_found` on create usually means the image belongs to another project or is private and unshared. Prefer the same project and a bare digest reference.
+- `image_not_ready` means VCR has not finished optimizing the `linux/amd64` image.
+- Repeated HTTP 429 allocation failures indicate project/team allocation pressure. The executor honors bounded `Retry-After` retries; reduce activity concurrency if pressure continues.
+- Cleanup errors fail the activity rather than silently leaving reusable state and include the exact `selfbench-...` sandbox name for diagnosis.
+
 ## CLI behavior
 
 `self-bench run` requires an absolute or relative path to a Git checkout whose `origin` is an HTTPS or SSH GitHub URL. It pins `HEAD`; uncommitted content is excluded.
@@ -121,21 +212,28 @@ SelfBench has no remote deletion route. Delete local artifact-volume data or GCS
 | `SELFBENCH_ARTIFACT_DIR` | `.selfbench/artifacts` | Local artifact store |
 | `SELFBENCH_GCS_BUCKET` | — | GCS artifact store |
 | `SELFBENCH_GCS_PREFIX` | `selfbench` | GCS artifact store |
-| `SELFBENCH_EXECUTION_BACKEND` | `docker` | Worker; set by `self-bench up --backend` locally |
-| `SELFBENCH_HARBOR_ENVIRONMENT` | execution backend | Worker; set by `self-bench up --backend` locally |
-| `SELFBENCH_ACTIVITY_CONCURRENCY` | `1` Docker, `20` Modal | Worker |
+| `SELFBENCH_EXECUTION_BACKEND` | `docker` | Worker; `docker`, `modal`, or `vercel` |
+| `SELFBENCH_DOCKER_IMAGE` | `selfbench-sandbox:local` | Docker worker |
+| `SELFBENCH_HARBOR_ENVIRONMENT` | matching Docker/Modal backend | Worker; required as `docker` or `modal` for Vercel |
+| `SELFBENCH_ACTIVITY_CONCURRENCY` | `1` Docker, `20` Modal, `4` Vercel | Worker |
 | `SELFBENCH_MODAL_APP` | `selfbench` | Modal worker |
 | `SELFBENCH_MODAL_ENVIRONMENT` | — | Modal worker |
 | `SELFBENCH_MODAL_IMAGE` | `node:22-bookworm` | Modal worker |
 | `SELFBENCH_MODAL_CONFIG_PATH` | `/dev/null` | Compose host mount; set by `self-bench up --modal-config` locally |
+| `SELFBENCH_VERCEL_IMAGE` | profile or — | Required digest-pinned VCR image for Vercel execution |
+| `SELFBENCH_VERCEL_TIMEOUT_CAP` | `2h` | Vercel worker and API; accepts integer milliseconds or `ms`, `s`, `m`, `h` units |
+| `SELFBENCH_CONFIG_DIR` | `~/.selfbench` | Local CLI profile directory; not needed with a complete Vercel environment |
+| `VERCEL_TOKEN` | profile or unset | Vercel worker; explicit project-scoped access token |
+| `VERCEL_TEAM_ID` | profile or unset | Vercel worker |
+| `VERCEL_PROJECT_ID` | profile or unset | Vercel worker; must be able to resolve the configured image |
 | `SELFBENCH_TEMPORAL_ADDRESS` | `127.0.0.1:7233` | API and worker |
 | `SELFBENCH_TEMPORAL_NAMESPACE` | `default` | API and worker |
 | `SELFBENCH_TASK_QUEUE` | `selfbench-dev` | API and worker |
-| `SELFBENCH_PI_AUTH_PATH` | `~/.pi/agent/auth.json` | Compose host mount |
-| `SELFBENCH_PI_AUTH_JSON` | — | Worker secret alternative |
-| `SELFBENCH_CODEX_AUTH_PATH` | `~/.codex/auth.json` | Compose host mount |
+| `OPENAI_API_KEY` | — | Worker sandboxes and matrix harness |
+| `SELFBENCH_PI_AUTH_JSON` | — | Optional Pi subscription-auth fallback |
+| `SELFBENCH_CODEX_AUTH_JSON` | — | Optional Codex subscription-auth fallback |
 | `GH_TOKEN` | — | Worker GitHub reads |
-| `CODEX_AUTH_JSON_PATH` | `~/.codex/auth.json` | Worker and matrix harness |
+| `CODEX_AUTH_JSON_PATH` | `~/.codex/auth.json` | Optional matrix subscription-auth file |
 
 ## Cloud topology
 
@@ -153,7 +251,7 @@ SELFBENCH_TEMPORAL_API_KEY=...
 SELFBENCH_TEMPORAL_TLS=true
 ```
 
-Run `node dist/worker-main.js` from the same image digest on a long-running container platform, not a scale-to-zero request service. Give it the same Temporal, task queue, and GCS configuration plus:
+Run `node dist/temporal/worker-main.js` from the same image digest on a long-running container platform, not a scale-to-zero request service. Give it the same Temporal, task queue, and GCS configuration plus:
 
 ```text
 SELFBENCH_EXECUTION_BACKEND=modal
@@ -161,11 +259,25 @@ SELFBENCH_HARBOR_ENVIRONMENT=modal
 MODAL_TOKEN_ID=...
 MODAL_TOKEN_SECRET=...
 GH_TOKEN=...
-SELFBENCH_PI_AUTH_JSON=...
+OPENAI_API_KEY=...
 ```
 
 The worker owns model, GitHub, Modal, and Harbor credentials. Use separate least-privilege service accounts and a secret manager. Grant GCS object access only to the configured prefix, use a TLS-enabled Temporal namespace, and keep API/worker image digests and `SELFBENCH_TASK_QUEUE` identical.
 
+For Vercel generation, replace the execution settings above with:
+
+```text
+SELFBENCH_EXECUTION_BACKEND=vercel
+SELFBENCH_HARBOR_ENVIRONMENT=modal  # or docker
+SELFBENCH_VERCEL_IMAGE=selfbench-runtime@sha256:...
+SELFBENCH_VERCEL_TIMEOUT_CAP=2h     # or the verified 45m ceiling
+VERCEL_TOKEN=...
+VERCEL_TEAM_ID=team_...
+VERCEL_PROJECT_ID=prj_...
+```
+
+Keep the Vercel credential triple on the worker only. A project-scoped token is sufficient when the runtime image belongs to that project. The API must also receive `SELFBENCH_EXECUTION_BACKEND`, `SELFBENCH_HARBOR_ENVIRONMENT`, `SELFBENCH_VERCEL_IMAGE`, and `SELFBENCH_VERCEL_TIMEOUT_CAP` because it stamps the generation backend, Harbor environment, image, and effective timeout cap into each run manifest; it never needs the credential triple.
+
 This repository defines the application boundary, not turnkey cloud infrastructure. Project, region, ingress, IAM, GCS, and Temporal provisioning remain deployment-specific.
 
 ## Security boundary
@@ -173,6 +285,7 @@ This repository defines the application boundary, not turnkey cloud infrastructu
 - Exports contain source snapshots, held-out tests, and reference solutions. They are sensitive and unencrypted.
 - Artifact references carry byte length and SHA-256; reads verify integrity.
 - Local artifact paths and GCS object names are confined to their configured roots. GCS IAM should enforce the same prefix independently.
-- Author and review sandboxes receive only Pi's validated `openai-codex` OAuth entry. Repair receives a validated ChatGPT Codex token set with API-key fields removed.
+- Sandboxes receive only the selected model credential: `OPENAI_API_KEY` by default, or a stage-specific subscription credential for compatibility deployments.
 - Sandboxes contain both a source checkout and a short-lived model credential. Use SelfBench only with repositories you trust to execute; it is not a malware-analysis service.
-- Docker uses disposable containers and volumes and removes them after normal completion. A host crash can leave resources for an operator to inspect and remove. Modal uses disposable Sandboxes.
+- Docker uses disposable containers and volumes and removes them after normal completion. A host crash can leave resources for an operator to inspect and remove. Modal uses disposable Sandboxes. Vercel uses nonpersistent named sandboxes, attempts permanent deletion after each run, and fails the activity when deletion cannot be confirmed; inspect the project after worker crashes or cleanup failures.
+- Vercel control credentials authenticate only the worker's Sandbox control plane and are stripped before Harbor starts. They are never workload command secrets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "self-bench",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Turn completed repository changes into durable, private Harbor evaluations",
   "license": "MIT",
   "repository": {
@@ -50,36 +50,38 @@
     "check": "biome check . && tsc --noEmit -p tsconfig.json && bun run typecheck:review",
     "dev:api": "tsx src/api-main.ts",
     "dev:review": "vite --config review/vite.config.ts",
-    "dev:worker": "tsx src/worker-main.ts",
+    "dev:worker": "tsx src/temporal/worker-main.ts",
     "format": "biome format --write .",
     "start:api": "node dist/api-main.js",
-    "start:worker": "node dist/worker-main.js",
+    "start:worker": "node dist/temporal/worker-main.js",
     "test": "bun test tests review/src",
     "typecheck:review": "tsc --noEmit -p review/tsconfig.json",
     "validate": "bun run check && bun run test && bun run build && bun run verify:package"
   },
   "dependencies": {
+    "@clack/prompts": "1.7.0",
     "@google-cloud/storage": "^7.17.0",
-    "@pierre/diffs": "1.2.12",
     "@temporalio/activity": "^1.13.2",
     "@temporalio/client": "^1.13.2",
     "@temporalio/common": "^1.13.2",
     "@temporalio/worker": "^1.13.2",
     "@temporalio/workflow": "^1.13.2",
+    "@vercel/sandbox": "3.0.0",
     "modal": "^0.9.0",
-    "react": "19.2.7",
-    "react-dom": "19.2.7",
     "zod": "^4.1.12"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.6",
     "@earendil-works/pi-coding-agent": "0.84.0",
+    "@pierre/diffs": "1.2.12",
     "@sinclair/typebox": "0.34.41",
     "@types/bun": "^1.3.14",
     "@types/node": "24.10.13",
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "@vitejs/plugin-react": "4.7.0",
+    "react": "19.2.7",
+    "react-dom": "19.2.7",
     "tsx": "^4.20.6",
     "typescript": "5.9.3",
     "vite": "7.3.1"

package/src/agent-smoke-main.ts

@@ -2,6 +2,7 @@
 
 import { parseArgs } from "node:util";
 import { smokeAllAdapters } from "./agent-smoke.js";
+import { isHarborEnvironment } from "./providers.js";
 
 const parsed = parseArgs({
   options: {
@@ -27,8 +28,8 @@ Options:
   -h, --help                 Show this help`);
   process.exit(0);
 }
-const environment = parsed.values.environment;
-if (environment !== "docker" && environment !== "modal") {
+const environment = parsed.values.environment ?? "modal";
+if (!isHarborEnvironment(environment)) {
   throw new Error("--environment must be docker or modal");
 }
 const results = await smokeAllAdapters({

package/src/agent-smoke.ts

@@ -1,7 +1,9 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { harborChildEnvironment } from "./harbor-environment.js";
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
+import type { HarborEnvironment } from "./providers.js";
 
 export const HARBOR_AGENT_ADAPTERS = [
   "oracle",
@@ -48,7 +50,7 @@ export interface AdapterSmokeOptions {
   readonly taskDirectory: string;
   readonly jobsDirectory: string;
   readonly harborPath?: string;
-  readonly environment?: "docker" | "modal";
+  readonly environment?: HarborEnvironment;
   readonly concurrency?: number;
 }
 
@@ -99,7 +101,11 @@ export async function smokeAllAdapters(
           "--yes",
           "--quiet",
         ],
-        { allowFailure: true, timeoutMs: 60 * 60 * 1000 },
+        {
+          allowFailure: true,
+          env: harborChildEnvironment(),
+          timeoutMs: 60 * 60 * 1000,
+        },
       );
       const summary: AdapterSmokeResult = {
         agent,

package/src/api.ts

@@ -1,6 +1,9 @@
 import { timingSafeEqual } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { dirname, join } from "node:path";
 import { pipeline } from "node:stream/promises";
+import { fileURLToPath } from "node:url";
 import { Client } from "@temporalio/client";
 import { z } from "zod";
 import { createArtifactStore } from "./artifacts.js";
@@ -8,12 +11,13 @@ import type { SelfBenchConfig } from "./config.js";
 import {
   artifactRefSchema,
   type RunPhase,
+  type RunRequest,
   type RunStatus,
   repositoryRefSchema,
   runRequestSchema,
 } from "./contracts.js";
-import { connectTemporalClient } from "./temporal.js";
-import { selfBenchRunWorkflow, statusQuery } from "./workflow.js";
+import { connectTemporalClient } from "./temporal/connection.js";
+import { selfBenchRunWorkflow, statusQuery } from "./temporal/workflow.js";
 
 const submissionSchema = z.object({
   runId: z.string().regex(/^[a-z0-9][a-z0-9-]{2,62}$/),
@@ -39,6 +43,13 @@ export async function startApi(config: SelfBenchConfig): Promise<() => Promise<v
         sendJson(response, 200, { ok: true });
         return;
       }
+      if (
+        request.method === "GET" &&
+        (url.pathname === "/" || url.pathname.startsWith("/assets/"))
+      ) {
+        await sendReviewAsset(response, url.pathname);
+        return;
+      }
       if (!authorized(request, config.apiToken)) {
         sendJson(response, 401, { error: "unauthorized" });
         return;
@@ -58,26 +69,10 @@ export async function startApi(config: SelfBenchConfig): Promise<() => Promise<v
         return;
       }
       if (request.method === "POST" && url.pathname === "/v1/runs") {
-        const submission = submissionSchema.parse(
+        const workflowInput = buildRunRequest(
+          config,
           JSON.parse((await readBody(request)).toString("utf8")),
         );
-        const workflowInput = runRequestSchema.parse({
-          runId: submission.runId,
-          repository: submission.repository,
-          provenance: submission.provenance,
-          candidateCounts: submission.candidateCounts,
-          authoring: {
-            provider: "openai-codex",
-            model: submission.authoringModel,
-            reasoningEffort: "high",
-          },
-          version: {
-            selfbenchCommit: config.buildCommit ?? submission.selfbenchCommit,
-            executionBackend: config.execution.kind,
-            sandboxImage: config.execution.image,
-            schema: 1,
-          },
-        });
         await client.workflow.start(selfBenchRunWorkflow, {
           workflowId: workflowInput.runId,
           taskQueue: config.temporal.taskQueue,
@@ -157,6 +152,34 @@ export async function startApi(config: SelfBenchConfig): Promise<() => Promise<v
   };
 }
 
+export function buildRunRequest(
+  config: SelfBenchConfig,
+  submission: z.input<typeof submissionSchema>,
+): RunRequest {
+  const parsed = submissionSchema.parse(submission);
+  return runRequestSchema.parse({
+    runId: parsed.runId,
+    repository: parsed.repository,
+    provenance: parsed.provenance,
+    candidateCounts: parsed.candidateCounts,
+    authoring: {
+      provider: "openai-codex",
+      model: parsed.authoringModel,
+      reasoningEffort: "high",
+    },
+    version: {
+      selfbenchCommit: config.buildCommit ?? parsed.selfbenchCommit,
+      executionBackend: config.execution.kind,
+      harborEnvironment: config.harborEnvironment,
+      sandboxImage: config.execution.image,
+      ...(config.execution.kind === "vercel"
+        ? { sandboxTimeoutCapMs: config.execution.timeoutCapMs }
+        : {}),
+      schema: 1,
+    },
+  });
+}
+
 async function queryStatus(
   handle: ReturnType<Client["workflow"]["getHandle"]>,
 ): Promise<RunStatus | object> {
@@ -229,6 +252,34 @@ function authorized(request: IncomingMessage, token: string | undefined): boolea
   );
 }
 
+async function sendReviewAsset(response: ServerResponse, pathname: string): Promise<void> {
+  const relativePath = pathname === "/" ? "index.html" : pathname.slice(1);
+  const root = join(dirname(fileURLToPath(import.meta.url)), "review");
+  const path = join(root, relativePath);
+  if (!path.startsWith(`${root}/`)) {
+    sendJson(response, 400, { error: "invalid asset path" });
+    return;
+  }
+  try {
+    const body = await readFile(path);
+    response.writeHead(200, {
+      "content-type": contentType(path),
+      "content-length": body.byteLength,
+      "cache-control": pathname === "/" ? "no-cache" : "public, max-age=31536000, immutable",
+    });
+    response.end(body);
+  } catch {
+    sendJson(response, 404, { error: "asset not found" });
+  }
+}
+
+function contentType(path: string): string {
+  if (path.endsWith(".html")) return "text/html; charset=utf-8";
+  if (path.endsWith(".css")) return "text/css; charset=utf-8";
+  if (path.endsWith(".js")) return "text/javascript; charset=utf-8";
+  return "application/octet-stream";
+}
+
 function sendJson(response: ServerResponse, status: number, value: unknown): void {
   const body = `${JSON.stringify(value, null, 2)}\n`;
   response.writeHead(status, {

package/src/artifacts.ts

@@ -355,7 +355,3 @@ function verifyArtifact(reference: ArtifactRef, value: Uint8Array): void {
     throw new Error(`artifact integrity check failed: ${reference.uri}`);
   }
 }
-
-export async function artifactSize(path: string): Promise<number> {
-  return (await stat(path)).size;
-}

package/src/cli.ts

@@ -10,18 +10,29 @@ import type { ReadableStream as NodeReadableStream } from "node:stream/web";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { buildCommit } from "./build-metadata.js";
+import { loadWorkerConfig } from "./config.js";
 import { runCommand } from "./process.js";
 import { collectGitHubPullRequestProvenance, collectRepositoryProvenance } from "./provenance.js";
+import { isExecutionBackend, isHarborEnvironment, matchingHarborEnvironment } from "./providers.js";
 import { type PolledRunStatus, waitForRun } from "./run-wait.js";
+import { SetupCanceledError } from "./terminal-prompts.js";
+import { applyVercelProfile } from "./vercel-profile.js";
+import { setupVercel } from "./vercel-setup.js";
 
 const [command, ...rest] = process.argv.slice(2);
 switch (command) {
+  case "setup":
+    await setup(rest);
+    break;
   case "up":
     await up(rest);
     break;
   case "run":
     await run(rest);
     break;
+  case "down":
+    await down();
+    break;
   case "status":
     await passthrough("GET", `/v1/runs/${requiredArgument(rest, "run ID")}`);
     break;
@@ -44,31 +55,74 @@ switch (command) {
     throw new Error(`unknown command: ${command}`);
 }
 
+async function setup(args: string[]): Promise<void> {
+  const [provider, ...providerArgs] = args;
+  if (provider !== "vercel") {
+    fail("setup currently supports only: self-bench setup vercel");
+  }
+  const parsed = parseArgs({
+    args: providerArgs,
+    options: {
+      profile: { type: "string", default: "default" },
+      verbose: { type: "boolean", default: false },
+    },
+    strict: true,
+  });
+  try {
+    await setupVercel({
+      profileName: parsed.values.profile,
+      verbose: parsed.values.verbose,
+    });
+  } catch (error) {
+    if (error instanceof SetupCanceledError) {
+      process.exitCode = 130;
+      return;
+    }
+    throw error;
+  }
+}
+
 async function up(args: string[]): Promise<void> {
   const parsed = parseArgs({
     args,
     options: {
       backend: { type: "string", default: "docker" },
+      "harbor-environment": { type: "string" },
       "modal-config": { type: "string" },
+      "vercel-profile": { type: "string" },
     },
     strict: true,
   });
-  if (parsed.values.backend !== "docker" && parsed.values.backend !== "modal") {
-    fail('--backend must be "docker" or "modal"');
+  if (!isExecutionBackend(parsed.values.backend)) {
+    fail('--backend must be "docker", "modal", or "vercel"');
   }
-  if (parsed.values.backend === "docker" && parsed.values["modal-config"] !== undefined) {
-    fail("--modal-config requires --backend modal");
+  if (
+    parsed.values["harbor-environment"] !== undefined &&
+    !isHarborEnvironment(parsed.values["harbor-environment"])
+  ) {
+    fail('--harbor-environment must be "docker" or "modal"');
   }
 
   const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
   const composeFile = resolve(projectRoot, "compose.yaml");
   const backend = parsed.values.backend;
-  const environment = {
+  const harborEnvironment =
+    parsed.values["harbor-environment"] ??
+    matchingHarborEnvironment(backend) ??
+    fail(`--harbor-environment is required with --backend ${backend}`);
+  const usesModal = backend === "modal" || harborEnvironment === "modal";
+  if (!usesModal && parsed.values["modal-config"] !== undefined) {
+    fail("--modal-config requires Modal generation or Harbor");
+  }
+  if (backend !== "vercel" && parsed.values["vercel-profile"] !== undefined) {
+    fail("--vercel-profile requires Vercel generation");
+  }
+  let environment: NodeJS.ProcessEnv = {
     ...process.env,
     SELFBENCH_BUILD_COMMIT: await resolveSelfBenchCommit(),
     SELFBENCH_EXECUTION_BACKEND: backend,
-    SELFBENCH_HARBOR_ENVIRONMENT: backend,
-    ...(backend === "modal"
+    SELFBENCH_HARBOR_ENVIRONMENT: harborEnvironment,
+    ...(usesModal
       ? {
           SELFBENCH_MODAL_CONFIG_PATH: resolve(
             parsed.values["modal-config"] ?? resolve(homedir(), ".modal.toml"),
@@ -76,6 +130,10 @@ async function up(args: string[]): Promise<void> {
         }
       : {}),
   };
+  if (backend === "vercel") {
+    environment = await applyVercelProfile(environment, parsed.values["vercel-profile"]);
+    loadWorkerConfig(environment);
+  }
 
   if (backend === "docker") {
     await runCommand(
@@ -94,7 +152,14 @@ async function up(args: string[]): Promise<void> {
   await runCommand("docker", ["compose", "--file", composeFile, "up", "-d", "--build"], {
     env: environment,
   });
-  console.log(`SelfBench is running with the ${backend} backend at http://127.0.0.1:8080`);
+  console.log(
+    `SelfBench is running with ${backend} generation and ${harborEnvironment} Harbor at http://127.0.0.1:8080`,
+  );
+}
+
+async function down(): Promise<void> {
+  const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  await runCommand("docker", ["compose", "--file", resolve(projectRoot, "compose.yaml"), "down"]);
 }
 
 async function run(args: string[]): Promise<void> {
@@ -332,7 +397,10 @@ function printHelp(): void {
   console.log(`SelfBench creates durable tiered Harbor evaluations.
 
 Usage:
-  self-bench up [--backend docker|modal] [--modal-config PATH]
+  self-bench setup vercel [--profile NAME] [--verbose]
+  self-bench up [--backend docker|modal|vercel] [--harbor-environment docker|modal]
+                [--modal-config PATH] [--vercel-profile NAME]
+  self-bench down
   self-bench run --repo PATH [--easy-count N] [--medium-count N] [--hard-count N]
                   [--model MODEL] [--run-id ID] [--wait] [--output OUTPUT.tar.gz]
   self-bench status RUN_ID
@@ -340,8 +408,10 @@ Usage:
   self-bench download RUN_ID OUTPUT.tar.gz
   self-bench list
 
-The up command starts the local stack and configures both sandbox execution and Harbor validation for
-one backend. Modal uses ~/.modal.toml unless --modal-config overrides it.
+The up command starts the local stack. Docker and Modal default Harbor to the matching backend; Vercel
+requires --harbor-environment because Harbor does not support Vercel. Modal generation or Harbor uses
+~/.modal.toml unless --modal-config overrides it. Run self-bench setup vercel once to create or select a
+project, publish the pinned runtime image, verify access, and save an owner-only local profile.
 
 The tier counts are candidate authoring budgets, not accepted-task targets. Rejected candidates are not
 replaced, and the export contains only accepted tasks. The run command performs only repository metadata