self-bench 0.3.4 → 0.3.6

package/src/harbor-task.ts

@@ -6,7 +6,7 @@ import { runCommand } from "./process.js";
 import { patchPaths } from "./repair.js";
 
 const HARBOR_SCHEMA_VERSION = "1.4";
-const COMPILER_REVISION = 23;
+const COMPILER_REVISION = 24;
 
 export interface AuthoredTaskFiles {
   readonly definition: TaskDefinition;
@@ -70,6 +70,10 @@ export async function compileHarborTask(
   await Promise.all([
     cp(snapshot, join(environment, "repo.tar.gz")),
     cp(snapshot, join(tests, "repo.tar.gz")),
+    writeFile(
+      join(outputDirectory, "definition.json"),
+      `${JSON.stringify(task.definition, null, 2)}\n`,
+    ),
     writeFile(join(outputDirectory, "instruction.md"), `${task.definition.prompt.trim()}\n`),
     writeFile(join(solution, "gold.patch"), task.goldPatch),
     writeFile(join(solution, "solve.sh"), solutionScript()),
@@ -127,6 +131,7 @@ export async function refreshHarborTask(
   const preinstallGoldDependencies = dependencySetupPatch.length > 0;
   await writeFile(join(outputDirectory, "tests/test.sh"), testScript(definition, testPatch));
   await Promise.all([
+    writeFile(join(outputDirectory, "definition.json"), `${JSON.stringify(definition, null, 2)}\n`),
     writeFile(join(outputDirectory, "task.toml"), taskToml(definition)),
     writeFile(join(outputDirectory, "environment/Dockerfile"), agentDockerfile(definition)),
     writeFile(

package/src/project-paths.ts

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function projectRoot(moduleUrl: string): string {
+  let directory = dirname(fileURLToPath(moduleUrl));
+  const root = parse(directory).root;
+  while (directory !== root) {
+    if (existsSync(join(directory, "package.json"))) {
+      return directory;
+    }
+    directory = dirname(directory);
+  }
+  throw new Error(`could not find package.json above ${fileURLToPath(moduleUrl)}`);
+}

package/src/provenance-associations.ts

@@ -0,0 +1,311 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { assertPullRequestBelongsToRepository, githubRepository } from "./github.js";
+import { sha256 } from "./hash.js";
+import { runCommand } from "./process.js";
+import type {
+  LocalSessionMetadata,
+  ProvenanceMessage,
+  SessionProvenanceFormat,
+} from "./provenance.js";
+
+const localSourceTypeSchema = z.enum(["pi", "claude-code", "codex"]);
+type LocalSourceType = z.infer<typeof localSourceTypeSchema>;
+
+const associationMessageSchema = z
+  .object({
+    sourceType: localSourceTypeSchema,
+    sessionId: z.string().min(1),
+    messageIndex: z.number().int().nonnegative(),
+    contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  })
+  .strict();
+
+export const provenanceAssociationManifestSchema = z
+  .object({
+    schemaVersion: z.literal(1),
+    repository: z.string().regex(/^[^/]+\/[^/]+$/),
+    sourcePr: z.number().int().positive(),
+    sourceUrl: z.string().url(),
+    messages: z.array(associationMessageSchema).min(1),
+  })
+  .strict();
+
+export type ProvenanceAssociationManifest = z.infer<typeof provenanceAssociationManifestSchema>;
+
+export interface AssociationSessionSummary {
+  readonly selector: string;
+  readonly sourceType: LocalSourceType;
+  readonly sessionId: string;
+  readonly messageCount: number;
+  readonly modifiedAt?: string;
+  readonly paths?: readonly string[];
+}
+
+export interface MergedPullRequest {
+  readonly sourcePr: number;
+  readonly sourceUrl: string;
+}
+
+export function associationSessionSummaries(
+  messages: readonly ProvenanceMessage[],
+  metadata: readonly LocalSessionMetadata[] = [],
+): AssociationSessionSummary[] {
+  const metadataBySelector = new Map<string, { modifiedAt: string; paths: Set<string> }>();
+  for (const session of metadata) {
+    if (!isLocalSourceType(session.sourceType)) {
+      continue;
+    }
+    const selector = sessionSelector(session.sourceType, session.sessionId);
+    const existing = metadataBySelector.get(selector);
+    metadataBySelector.set(selector, {
+      modifiedAt:
+        !existing || session.modifiedAt > existing.modifiedAt
+          ? session.modifiedAt
+          : existing.modifiedAt,
+      paths: new Set([...(existing?.paths ?? []), session.path]),
+    });
+  }
+
+  const counts = new Map<string, AssociationSessionSummary>();
+  for (const message of messages) {
+    if (!isLocalSourceType(message.sourceType)) {
+      continue;
+    }
+    const selector = sessionSelector(message.sourceType, message.sessionId);
+    const existing = counts.get(selector);
+    const sessionMetadata = metadataBySelector.get(selector);
+    counts.set(selector, {
+      selector,
+      sourceType: message.sourceType,
+      sessionId: message.sessionId,
+      messageCount: (existing?.messageCount ?? 0) + 1,
+      ...(sessionMetadata
+        ? {
+            modifiedAt: sessionMetadata.modifiedAt,
+            paths: [...sessionMetadata.paths].sort(),
+          }
+        : {}),
+    });
+  }
+  return [...counts.values()].sort(
+    (left, right) =>
+      (right.modifiedAt ?? "").localeCompare(left.modifiedAt ?? "") ||
+      left.selector.localeCompare(right.selector),
+  );
+}
+
+export function createProvenanceAssociationManifest(input: {
+  readonly repositoryUrl: string;
+  readonly pullRequest: MergedPullRequest;
+  readonly messages: readonly ProvenanceMessage[];
+  readonly sessionSelectors: readonly string[];
+}): ProvenanceAssociationManifest {
+  const repository = githubRepository(input.repositoryUrl);
+  assertPullRequestBelongsToRepository(
+    input.repositoryUrl,
+    input.pullRequest.sourceUrl,
+    input.pullRequest.sourcePr,
+  );
+  if (input.sessionSelectors.length === 0) {
+    throw new Error("at least one --session is required to create an association manifest");
+  }
+
+  const selected = new Set(input.sessionSelectors.map(parseSessionSelector));
+  if (selected.size !== input.sessionSelectors.length) {
+    throw new Error("each --session selector must be unique");
+  }
+  const available = new Set(
+    associationSessionSummaries(input.messages).map(({ selector }) => selector),
+  );
+  for (const selector of selected) {
+    if (!available.has(selector)) {
+      throw new Error(`local session ${selector} was not found for this repository`);
+    }
+  }
+
+  const messageKeys = new Set<string>();
+  const messages = input.messages
+    .filter(
+      (message): message is ProvenanceMessage & { sourceType: LocalSourceType } =>
+        isLocalSourceType(message.sourceType) &&
+        selected.has(sessionSelector(message.sourceType, message.sessionId)),
+    )
+    .map((message) => {
+      const key = messageKey(message.sourceType, message.sessionId, message.messageIndex);
+      if (messageKeys.has(key)) {
+        throw new Error(`local provenance contains duplicate message identity ${key}`);
+      }
+      messageKeys.add(key);
+      return {
+        sourceType: message.sourceType,
+        sessionId: message.sessionId,
+        messageIndex: message.messageIndex,
+        contentSha256: sha256(message.content),
+      };
+    })
+    .sort(compareAssociationMessages);
+
+  return provenanceAssociationManifestSchema.parse({
+    schemaVersion: 1,
+    repository,
+    sourcePr: input.pullRequest.sourcePr,
+    sourceUrl: input.pullRequest.sourceUrl,
+    messages,
+  });
+}
+
+export async function writeProvenanceAssociationManifest(
+  path: string,
+  manifest: ProvenanceAssociationManifest,
+): Promise<void> {
+  await writeFile(path, `${JSON.stringify(manifest, null, 2)}\n`, { flag: "wx", mode: 0o600 });
+}
+
+export async function applyProvenanceAssociationManifests(
+  messages: readonly ProvenanceMessage[],
+  repositoryUrl: string,
+  paths: readonly string[],
+): Promise<ProvenanceMessage[]> {
+  if (paths.length === 0) {
+    return [...messages];
+  }
+  const repository = githubRepository(repositoryUrl);
+  const manifests = await Promise.all(
+    paths.map(async (path) => {
+      const value = JSON.parse(await readFile(path, "utf8"));
+      return { path, manifest: provenanceAssociationManifestSchema.parse(value) };
+    }),
+  );
+  const messageByKey = new Map<string, ProvenanceMessage>();
+  for (const message of messages) {
+    const key = messageKey(message.sourceType, message.sessionId, message.messageIndex);
+    if (messageByKey.has(key)) {
+      throw new Error(`local provenance contains duplicate message identity ${key}`);
+    }
+    messageByKey.set(key, message);
+  }
+
+  const associations = new Map<string, MergedPullRequest>();
+  for (const { path, manifest } of manifests) {
+    if (manifest.repository.toLowerCase() !== repository) {
+      throw new Error(
+        `association manifest ${path} belongs to ${manifest.repository}, not ${repository}`,
+      );
+    }
+    assertPullRequestBelongsToRepository(repositoryUrl, manifest.sourceUrl, manifest.sourcePr);
+    for (const selector of new Set(
+      manifest.messages.map((message) => sessionSelector(message.sourceType, message.sessionId)),
+    )) {
+      const expected = manifest.messages
+        .filter((message) => sessionSelector(message.sourceType, message.sessionId) === selector)
+        .sort(compareAssociationMessages);
+      const current = messages
+        .filter(
+          (message): message is ProvenanceMessage & { sourceType: LocalSourceType } =>
+            isLocalSourceType(message.sourceType) &&
+            sessionSelector(message.sourceType, message.sessionId) === selector,
+        )
+        .map((message) => ({
+          sourceType: message.sourceType,
+          sessionId: message.sessionId,
+          messageIndex: message.messageIndex,
+          contentSha256: sha256(message.content),
+        }))
+        .sort(compareAssociationMessages);
+      if (JSON.stringify(current) !== JSON.stringify(expected)) {
+        throw new Error(`association manifest ${path} does not match local session ${selector}`);
+      }
+    }
+    for (const reference of manifest.messages) {
+      const key = messageKey(reference.sourceType, reference.sessionId, reference.messageIndex);
+      const message = messageByKey.get(key);
+      if (!message || sha256(message.content) !== reference.contentSha256) {
+        throw new Error(`association manifest ${path} does not match local message ${key}`);
+      }
+      if (associations.has(key)) {
+        throw new Error(`local message ${key} is associated more than once`);
+      }
+      associations.set(key, {
+        sourcePr: manifest.sourcePr,
+        sourceUrl: manifest.sourceUrl,
+      });
+    }
+  }
+
+  return messages.map((message) => {
+    const association = associations.get(
+      messageKey(message.sourceType, message.sessionId, message.messageIndex),
+    );
+    return association ? { ...message, ...association } : message;
+  });
+}
+
+export async function resolveMergedPullRequest(
+  repositoryUrl: string,
+  sourcePr: number,
+): Promise<MergedPullRequest> {
+  const repository = githubRepository(repositoryUrl);
+  const result = await runCommand("gh", [
+    "pr",
+    "view",
+    String(sourcePr),
+    "--repo",
+    repository,
+    "--json",
+    "number,url,state,mergedAt",
+  ]);
+  const parsed = z
+    .object({
+      number: z.number().int().positive(),
+      url: z.string().url(),
+      state: z.string(),
+      mergedAt: z.string().nullable(),
+    })
+    .parse(JSON.parse(result.stdout));
+  if (parsed.number !== sourcePr) {
+    throw new Error(`GitHub returned pull request ${parsed.number}; expected ${sourcePr}`);
+  }
+  assertPullRequestBelongsToRepository(repositoryUrl, parsed.url, sourcePr);
+  if (parsed.state !== "MERGED" || !parsed.mergedAt) {
+    throw new Error(`pull request ${repository}#${sourcePr} is not merged`);
+  }
+  return { sourcePr, sourceUrl: parsed.url };
+}
+
+function parseSessionSelector(value: string): string {
+  const separator = value.indexOf(":");
+  if (separator < 1 || separator === value.length - 1) {
+    throw new Error(`invalid session selector ${JSON.stringify(value)}; expected TYPE:SESSION_ID`);
+  }
+  const sourceType = value.slice(0, separator);
+  localSourceTypeSchema.parse(sourceType);
+  return sessionSelector(sourceType as LocalSourceType, value.slice(separator + 1));
+}
+
+function sessionSelector(sourceType: LocalSourceType, sessionId: string): string {
+  return `${sourceType}:${sessionId}`;
+}
+
+function messageKey(
+  sourceType: SessionProvenanceFormat | "github-pull-request",
+  sessionId: string,
+  messageIndex: number,
+): string {
+  return `${sourceType}:${sessionId}:${messageIndex}`;
+}
+
+function compareAssociationMessages(
+  left: z.infer<typeof associationMessageSchema>,
+  right: z.infer<typeof associationMessageSchema>,
+): number {
+  return (
+    left.sourceType.localeCompare(right.sourceType) ||
+    left.sessionId.localeCompare(right.sessionId) ||
+    left.messageIndex - right.messageIndex
+  );
+}
+
+function isLocalSourceType(value: string): value is LocalSourceType {
+  return value === "pi" || value === "claude-code" || value === "codex";
+}

package/src/provenance.ts

@@ -1,23 +1,50 @@
-import { readdir, readFile } from "node:fs/promises";
-import { basename, join } from "node:path";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, join, relative } from "node:path";
+import { z } from "zod";
 import { assertPullRequestBelongsToRepository, githubRepository } from "./github.js";
 import { runCommand } from "./process.js";
 
 export type SessionProvenanceFormat = "codex" | "claude-code" | "pi" | "generic";
 
-interface ProvenanceMessageBase {
+const provenanceMessageBaseSchema = z.object({
+  sessionId: z.string().min(1),
+  messageIndex: z.number().int().nonnegative(),
+  content: z.string().min(1),
+});
+
+const localProvenanceMessageSchema = provenanceMessageBaseSchema
+  .extend({
+    sourceType: z.enum(["codex", "claude-code", "pi", "generic"]),
+    sourcePr: z.number().int().positive().optional(),
+    sourceUrl: z.string().url().optional(),
+  })
+  .refine(
+    (message) => (message.sourcePr === undefined) === (message.sourceUrl === undefined),
+    "sourcePr and sourceUrl must be supplied together",
+  );
+
+export const provenanceMessageSchema = z.union([
+  localProvenanceMessageSchema,
+  provenanceMessageBaseSchema.extend({
+    sourceType: z.literal("github-pull-request"),
+    sourcePr: z.number().int().positive(),
+    sourceUrl: z.string().url(),
+  }),
+]);
+
+export type ProvenanceMessage = z.infer<typeof provenanceMessageSchema>;
+
+export interface LocalSessionMetadata {
+  readonly sourceType: SessionProvenanceFormat;
   readonly sessionId: string;
-  readonly messageIndex: number;
-  readonly content: string;
+  readonly path: string;
+  readonly modifiedAt: string;
 }
 
-export type ProvenanceMessage =
-  | (ProvenanceMessageBase & { readonly sourceType: SessionProvenanceFormat })
-  | (ProvenanceMessageBase & {
-      readonly sourceType: "github-pull-request";
-      readonly sourcePr: number;
-      readonly sourceUrl: string;
-    });
+export interface RepositoryProvenanceCollection {
+  readonly messages: readonly ProvenanceMessage[];
+  readonly sessions: readonly LocalSessionMetadata[];
+}
 
 interface JsonRecord {
   readonly [key: string]: unknown;
@@ -51,9 +78,19 @@ export async function collectRepositoryProvenance(
   repositoryPath: string,
   homeDirectory: string,
 ): Promise<ProvenanceMessage[]> {
+  return [
+    ...(await collectRepositoryProvenanceWithMetadata(repositoryPath, homeDirectory)).messages,
+  ];
+}
+
+export async function collectRepositoryProvenanceWithMetadata(
+  repositoryPath: string,
+  homeDirectory: string,
+): Promise<RepositoryProvenanceCollection> {
   const worktrees = await repositoryWorktrees(repositoryPath);
   const encodedWorktrees = worktrees.flatMap((path) => [path, encodeSessionPath(path)]);
   const messages: ProvenanceMessage[] = [];
+  const sessions: LocalSessionMetadata[] = [];
 
   for (const [format, relativeRoot] of SOURCE_ROOTS) {
     const root = join(homeDirectory, relativeRoot);
@@ -65,29 +102,54 @@ export async function collectRepositoryProvenance(
       ) {
         continue;
       }
-      messages.push(...extractProvenanceMessages(raw, format, basename(path)));
+      const extracted = extractProvenanceMessages(raw, format, basename(path));
+      if (extracted.length === 0) {
+        continue;
+      }
+      messages.push(...extracted);
+      const file = await stat(path).catch(() => undefined);
+      if (file) {
+        const sessionIds = new Set(extracted.map((message) => message.sessionId));
+        for (const sessionId of sessionIds) {
+          sessions.push({
+            sourceType: format,
+            sessionId,
+            path: displaySessionPath(path, homeDirectory),
+            modifiedAt: file.mtime.toISOString(),
+          });
+        }
+      }
     }
   }
 
-  return deduplicateMessages(messages);
+  return { messages: deduplicateMessages(messages), sessions };
 }
 
 export async function collectGitHubPullRequestProvenance(
   repositoryUrl: string,
+  token?: string,
+  signal?: AbortSignal,
 ): Promise<ProvenanceMessage[]> {
   const repository = githubRepository(repositoryUrl);
-  const result = await runCommand("gh", [
-    "pr",
-    "list",
-    "--repo",
-    repository,
-    "--state",
-    "merged",
-    "--limit",
-    String(GITHUB_PULL_REQUEST_LIMIT),
-    "--json",
-    "number,title,body,url,author,isDraft,additions,deletions,changedFiles",
-  ]);
+  const result = await runCommand(
+    "gh",
+    [
+      "pr",
+      "list",
+      "--repo",
+      repository,
+      "--state",
+      "merged",
+      "--limit",
+      String(GITHUB_PULL_REQUEST_LIMIT),
+      "--json",
+      "number,title,body,url,author,isDraft,additions,deletions,changedFiles",
+    ],
+    {
+      env: token ? { ...process.env, GH_TOKEN: token } : process.env,
+      ...(signal ? { signal } : {}),
+    },
+  );
   return extractGitHubPullRequestProvenance(result.stdout, repositoryUrl);
 }
 
@@ -130,19 +192,55 @@ export function extractGitHubPullRequestProvenance(
   return messages;
 }
 
+export function combineRunProvenance(
+  repositoryUrl: string,
+  local: readonly ProvenanceMessage[],
+  github: readonly ProvenanceMessage[],
+): ProvenanceMessage[] {
+  const explicitlyAssociatedPrs = new Set<number>();
+  for (const message of local) {
+    if (message.sourcePr === undefined || message.sourceUrl === undefined) {
+      continue;
+    }
+    assertPullRequestBelongsToRepository(repositoryUrl, message.sourceUrl, message.sourcePr);
+    explicitlyAssociatedPrs.add(message.sourcePr);
+  }
+  return [
+    ...local,
+    ...github.filter(
+      (message) =>
+        message.sourceType !== "github-pull-request" ||
+        !explicitlyAssociatedPrs.has(message.sourcePr),
+    ),
+  ];
+}
+
 export function assertProvenanceMatchesPullRequest(
   message: ProvenanceMessage,
   sourcePr: number,
   sourceUrl: string,
+  provenance: readonly ProvenanceMessage[] = [message],
 ): void {
   if (
-    message.sourceType === "github-pull-request" &&
+    (message.sourcePr !== undefined || message.sourceUrl !== undefined) &&
     (message.sourcePr !== sourcePr || message.sourceUrl !== sourceUrl)
   ) {
     throw new Error(
       `pull request ${sourceUrl}#${sourcePr} does not match provenance ${message.sourceUrl}#${message.sourcePr}`,
     );
   }
+  const hasExplicitLocalAssociation = provenance.some(
+    (item) => item.sourceType !== "github-pull-request" && item.sourcePr === sourcePr,
+  );
+  if (
+    hasExplicitLocalAssociation &&
+    message.sourceType !== "github-pull-request" &&
+    (message.sourcePr !== sourcePr || message.sourceUrl !== sourceUrl)
+  ) {
+    throw new Error(
+      `pull request ${sourceUrl}#${sourcePr} has explicit local provenance; unbound local provenance cannot be selected`,
+    );
+  }
 }
 
 export function extractProvenanceMessages(
@@ -418,13 +516,19 @@ async function listJsonFiles(root: string): Promise<string[]> {
   const entries = await readdir(root, { recursive: true, withFileTypes: true }).catch(() => []);
   return entries
     .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
-    .map((entry) => join(entry.parentPath, entry.name));
+    .map((entry) => join(entry.parentPath, entry.name))
+    .sort();
 }
 
 function encodeSessionPath(path: string): string {
   return path.replaceAll("/", "-");
 }
 
+function displaySessionPath(path: string, homeDirectory: string): string {
+  const fromHome = relative(homeDirectory, path);
+  return fromHome && !fromHome.startsWith("..") ? `~/${fromHome}` : path;
+}
+
 function deduplicateMessages(messages: readonly ProvenanceMessage[]): ProvenanceMessage[] {
   const seen = new Set<string>();
   return messages.filter((message) => {

package/src/reaudit-main.ts

@@ -3,7 +3,6 @@
 import { access, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import {
   COUPLING_REVIEW_MODEL,
@@ -19,7 +18,8 @@ import {
 } from "./coupling.js";
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
-import { createSandboxExecutor, type SandboxExecutor } from "./sandbox.js";
+import { projectRoot } from "./project-paths.js";
+import { createSandboxExecutor, type SandboxExecutor } from "./sandbox/index.js";
 import { loadPiModelAuth } from "./subscription-auth.js";
 
 const parsed = parseArgs({
@@ -182,7 +182,7 @@ async function auditTask(
 }
 
 function assetRoot(): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  return projectRoot(import.meta.url);
 }
 
 function positiveInteger(value: string | undefined, label: string): number {

package/src/repair-main.ts

@@ -2,13 +2,13 @@
 
 import { access, cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { defaultStandaloneConcurrency, loadWorkerConfig } from "./config.js";
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
-import { createSandboxExecutor } from "./sandbox.js";
+import { projectRoot } from "./project-paths.js";
+import { createSandboxExecutor } from "./sandbox/index.js";
 import { loadCodexModelAuth } from "./subscription-auth.js";
 
 const parsed = parseArgs({
@@ -189,7 +189,7 @@ function reviewReport(value: unknown): { readonly tasks: readonly ReviewTask[] }
 }
 
 function assetRoot(): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  return projectRoot(import.meta.url);
 }
 
 function positiveInteger(value: string | undefined, label: string): number {

package/src/{sandbox.ts → sandbox/contracts.ts}

@@ -1,9 +1,3 @@
-import type { SelfBenchWorkerConfig } from "./config.js";
-import { DockerSandboxExecutor } from "./docker-executor.js";
-import { ModalSandboxExecutor } from "./modal-executor.js";
-import { TimeoutCappedSandboxExecutor } from "./sandbox-timeout.js";
-import { VercelSandboxExecutor } from "./vercel-executor.js";
-
 export interface SandboxFile {
   readonly path: string;
   readonly contents: Uint8Array | string;
@@ -41,21 +35,18 @@ export interface SandboxResult {
   readonly outputs: Readonly<Record<string, Uint8Array>>;
 }
 
+export class SandboxExecutionError extends Error {
+  constructor(
+    message: string,
+    readonly result: SandboxResult,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "SandboxExecutionError";
+  }
+}
+
 export interface SandboxExecutor {
   run(request: SandboxRequest, options?: SandboxRunOptions): Promise<SandboxResult>;
   close(): void;
 }
-
-export function createSandboxExecutor(config: SelfBenchWorkerConfig["execution"]): SandboxExecutor {
-  switch (config.kind) {
-    case "docker":
-      return new DockerSandboxExecutor(config);
-    case "modal":
-      return new ModalSandboxExecutor(config);
-    case "vercel":
-      return new TimeoutCappedSandboxExecutor(
-        new VercelSandboxExecutor(config),
-        config.timeoutCapMs,
-      );
-  }
-}