self-bench 0.3.6 → 0.3.8

package/src/codex-review.ts

@@ -1,229 +0,0 @@
-import { z } from "zod";
-import type { CouplingEvidence } from "./coupling.js";
-
-export const COUPLING_REVIEW_MODEL = "gpt-5.6-sol";
-
-export const couplingReviewSchema = z.object({
-  verdict: z.enum(["clean", "coupled"]),
-  reason: z.string().min(1),
-  findings: z
-    .array(
-      z.object({
-        artifact: z.string().min(1),
-        category: z.enum(["endpoint_path", "field_name", "header_name", "media_type", "other"]),
-        disposition: z.enum([
-          "base_contract",
-          "prompt_contract",
-          "external_contract",
-          "gold_only",
-          "not_contract",
-        ]),
-        evidence: z.string().min(1),
-      }),
-    )
-    .min(1),
-  counterexample: z.string().min(1),
-});
-
-export type CouplingReview = z.infer<typeof couplingReviewSchema>;
-
-export async function reviewCouplingWithCodex(input: {
-  readonly apiKey?: string;
-  readonly authJson?: string;
-  readonly prompt: string;
-  readonly signal?: AbortSignal;
-  readonly fetch?: typeof fetch;
-}): Promise<CouplingReview> {
-  const subscription =
-    !input.apiKey && input.authJson ? parseCredential(input.authJson) : undefined;
-  if (!input.apiKey && !subscription) {
-    throw new Error("OpenAI model authentication is required");
-  }
-  const request = input.fetch ?? fetch;
-  const response = await request(
-    subscription
-      ? "https://chatgpt.com/backend-api/codex/responses"
-      : "https://api.openai.com/v1/responses",
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${subscription?.access ?? input.apiKey}`,
-        ...(subscription ? { "ChatGPT-Account-Id": accountIdFromToken(subscription.access) } : {}),
-        Originator: "selfbench",
-        "OpenAI-Beta": "responses=experimental",
-        Accept: "text/event-stream",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        model: COUPLING_REVIEW_MODEL,
-        store: false,
-        stream: true,
-        instructions:
-          "You are an independent benchmark-quality reviewer. Analyze the supplied evidence and call submit_review exactly once.",
-        input: [
-          {
-            role: "user",
-            content: [{ type: "input_text", text: input.prompt }],
-          },
-        ],
-        reasoning: { effort: "high", summary: "auto" },
-        text: { verbosity: "low" },
-        include: ["reasoning.encrypted_content"],
-        tools: [reviewTool()],
-        tool_choice: { type: "function", name: "submit_review" },
-        parallel_tool_calls: false,
-      }),
-      ...(input.signal ? { signal: input.signal } : {}),
-    },
-  );
-  const responseText = await response.text();
-  if (!response.ok) {
-    throw new Error(
-      `Codex coupling review failed (${response.status}): ${responseText.slice(0, 500)}`,
-    );
-  }
-  return parseCodexReviewEvents(responseText);
-}
-
-function parseCredential(value: string): { access: string } {
-  const parsed = JSON.parse(value) as unknown;
-  const credential = isRecord(parsed) ? parsed["openai-codex"] : undefined;
-  if (!isRecord(credential) || typeof credential.access !== "string") {
-    throw new Error("Pi auth does not contain an OpenAI Codex subscription access token");
-  }
-  return { access: credential.access };
-}
-
-function accountIdFromToken(token: string): string {
-  const payload = JSON.parse(
-    Buffer.from(token.split(".")[1] ?? "", "base64url").toString("utf8"),
-  ) as unknown;
-  const auth = isRecord(payload) ? payload["https://api.openai.com/auth"] : undefined;
-  const accountId = isRecord(auth) ? auth.chatgpt_account_id : undefined;
-  if (typeof accountId !== "string" || !accountId) {
-    throw new Error("OpenAI Codex subscription token has no ChatGPT account ID");
-  }
-  return accountId;
-}
-
-export function parseCodexReviewEvents(value: string): CouplingReview {
-  for (const line of value.split("\n")) {
-    if (!line.startsWith("data: ")) {
-      continue;
-    }
-    const data = line.slice("data: ".length);
-    if (data === "[DONE]") {
-      continue;
-    }
-    const event = JSON.parse(data) as unknown;
-    if (!isRecord(event)) {
-      continue;
-    }
-    const item = event.item;
-    if (
-      event.type === "response.output_item.done" &&
-      isRecord(item) &&
-      item.type === "function_call" &&
-      item.name === "submit_review" &&
-      typeof item.arguments === "string"
-    ) {
-      return couplingReviewSchema.parse(JSON.parse(item.arguments));
-    }
-    if (event.type === "error") {
-      throw new Error(`Codex coupling review stream failed: ${JSON.stringify(event)}`);
-    }
-  }
-  throw new Error("Codex coupling review returned no submit_review tool call");
-}
-
-export function couplingReviewPrompt(): string {
-  return `Independently review this hard benchmark for test-to-gold coupling.
-
-For every exact endpoint path, response/request field, header, media type, helper/module, error string, schema/index name, UI copy/order, or other implementation artifact asserted by the held-out tests, cite either the authentic prompt text that requires it or deterministic evidence that the exact base repository already establishes it. A name merely appearing in the gold patch is not evidence. Reject a test that would fail a coherent implementation of the request using different names, file boundaries, payload presentation, or internal structure.
-
-Resolve every artifact listed in couplingEvidence.blockers with a finding whose artifact exactly matches it. Use external_contract only when the authentic request names a standard protocol that fixes the exact artifact independently of the gold patch, and cite that protocol. Use not_contract only for incidental test-language or framework syntax that is not an asserted product contract. A clean verdict with a missing blocker finding or a gold_only finding is rejected automatically.
-
-Your findings must identify the artifact, classify it, give its disposition, and cite concrete evidence. The counterexample must describe a plausible alternative correct implementation and whether the tests would accept it. Also reject prompt leakage of PRs, commits, test names, or the solution.`;
-}
-
-export function couplingReviewInput(
-  prompt: string,
-  testPatch: string,
-  goldPatch: string,
-  evidence: CouplingEvidence,
-): string {
-  return `${couplingReviewPrompt()}
-
-# Authentic request
-
-${prompt}
-
-# Deterministic base-contract evidence
-
-The exact-artifact scan compared the held-out tests with the authentic request, gold additions, and exact base snapshot. Every blocker below is asserted by tests and introduced by gold, but absent verbatim from both request and base. Resolve each blocker explicitly.
-
-${JSON.stringify(evidence, null, 2)}
-
-# Held-out test patch
-
-\`\`\`diff
-${testPatch}
-\`\`\`
-
-# Gold implementation patch
-
-\`\`\`diff
-${goldPatch}
-\`\`\`
-`;
-}
-
-function reviewTool(): Record<string, unknown> {
-  return {
-    type: "function",
-    name: "submit_review",
-    description: "Submit the final independent test-coupling verdict exactly once.",
-    strict: true,
-    parameters: {
-      type: "object",
-      additionalProperties: false,
-      required: ["verdict", "reason", "findings", "counterexample"],
-      properties: {
-        verdict: { type: "string", enum: ["clean", "coupled"] },
-        reason: { type: "string", minLength: 1 },
-        findings: {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["artifact", "category", "disposition", "evidence"],
-            properties: {
-              artifact: { type: "string", minLength: 1 },
-              category: {
-                type: "string",
-                enum: ["endpoint_path", "field_name", "header_name", "media_type", "other"],
-              },
-              disposition: {
-                type: "string",
-                enum: [
-                  "base_contract",
-                  "prompt_contract",
-                  "external_contract",
-                  "gold_only",
-                  "not_contract",
-                ],
-              },
-              evidence: { type: "string", minLength: 1 },
-            },
-          },
-        },
-        counterexample: { type: "string", minLength: 1 },
-      },
-    },
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/config.ts

@@ -1,239 +0,0 @@
-import { z } from "zod";
-import {
-  EXECUTION_BACKENDS,
-  type ExecutionBackend,
-  HARBOR_ENVIRONMENTS,
-  type HarborEnvironment,
-  matchingHarborEnvironment,
-} from "./providers.js";
-import { parseSandboxTimeoutCapText, STANDARD_VERCEL_TIMEOUT_CAP_MS } from "./sandbox/timeout.js";
-
-const emptyStringAsUndefined = (value: unknown): unknown =>
-  typeof value === "string" && value.trim() === "" ? undefined : value;
-
-const environmentSchema = z.object({
-  SELFBENCH_API_HOST: z.string().default("127.0.0.1"),
-  SELFBENCH_API_PORT: z.coerce.number().int().min(1).max(65535).default(8080),
-  SELFBENCH_API_TOKEN: z.string().min(1).optional(),
-  SELFBENCH_ARTIFACT_BACKEND: z.enum(["local", "gcs"]).default("local"),
-  SELFBENCH_ARTIFACT_DIR: z.string().default(".selfbench/artifacts"),
-  SELFBENCH_GCS_BUCKET: z.string().optional(),
-  SELFBENCH_GCS_PREFIX: z.string().default("selfbench"),
-  SELFBENCH_EXECUTION_BACKEND: z.enum(EXECUTION_BACKENDS).default("docker"),
-  SELFBENCH_DOCKER_IMAGE: z.string().default("selfbench-sandbox:local"),
-  SELFBENCH_HARBOR_ENVIRONMENT: z.preprocess(
-    emptyStringAsUndefined,
-    z.enum(HARBOR_ENVIRONMENTS).optional(),
-  ),
-  SELFBENCH_MODAL_APP: z.string().default("selfbench"),
-  SELFBENCH_MODAL_ENVIRONMENT: z.string().optional(),
-  SELFBENCH_MODAL_IMAGE: z.string().default("node:22-bookworm"),
-  SELFBENCH_VERCEL_IMAGE: z.preprocess(emptyStringAsUndefined, z.string().trim().min(1).optional()),
-  // Keep provider-specific validation in the Vercel branch so a stale Vercel
-  // variable cannot break an otherwise unrelated Docker or Modal worker.
-  SELFBENCH_VERCEL_TIMEOUT_CAP: z.preprocess(emptyStringAsUndefined, z.string().optional()),
-  SELFBENCH_BUILD_COMMIT: z.preprocess(
-    (value) => (value === "" ? undefined : value),
-    z
-      .string()
-      .regex(/^[0-9a-f]{40}$/i)
-      .optional(),
-  ),
-  SELFBENCH_ACTIVITY_CONCURRENCY: z.preprocess(
-    emptyStringAsUndefined,
-    z.coerce.number().int().min(1).max(100).optional(),
-  ),
-  SELFBENCH_TASK_QUEUE: z.string().default("selfbench-dev"),
-  SELFBENCH_TEMPORAL_ADDRESS: z.string().default("127.0.0.1:7233"),
-  SELFBENCH_TEMPORAL_NAMESPACE: z.string().default("default"),
-  SELFBENCH_TEMPORAL_API_KEY: z.string().optional(),
-  SELFBENCH_TEMPORAL_TLS: z
-    .enum(["true", "false"])
-    .transform((value) => value === "true")
-    .default(false),
-});
-
-export interface VercelCredentials {
-  readonly token: string;
-  readonly teamId: string;
-  readonly projectId: string;
-}
-
-type ExecutionConfig =
-  | { readonly kind: "docker"; readonly image: string }
-  | {
-      readonly kind: "modal";
-      readonly app: string;
-      readonly environment?: string;
-      readonly image: string;
-    }
-  | { readonly kind: "vercel"; readonly image: string; readonly timeoutCapMs: number };
-
-type WorkerExecutionConfig =
-  | Exclude<ExecutionConfig, { readonly kind: "vercel" }>
-  | {
-      readonly kind: "vercel";
-      readonly image: string;
-      readonly timeoutCapMs: number;
-      readonly credentials: VercelCredentials;
-    };
-
-const DEFAULT_ACTIVITY_CONCURRENCY = {
-  docker: 1,
-  modal: 20,
-  vercel: 4,
-} as const satisfies Record<ExecutionBackend, number>;
-
-export interface SelfBenchConfig {
-  readonly apiHost: string;
-  readonly apiPort: number;
-  readonly apiToken?: string;
-  readonly buildCommit?: string;
-  readonly activityConcurrency: number;
-  readonly artifact:
-    | { readonly kind: "local"; readonly directory: string }
-    | { readonly kind: "gcs"; readonly bucket: string; readonly prefix: string };
-  readonly execution: ExecutionConfig;
-  readonly harborEnvironment: HarborEnvironment;
-  readonly temporal: {
-    readonly address: string;
-    readonly namespace: string;
-    readonly apiKey?: string;
-    readonly tls: boolean;
-    readonly taskQueue: string;
-  };
-}
-
-export interface SelfBenchWorkerConfig extends Omit<SelfBenchConfig, "execution"> {
-  readonly execution: WorkerExecutionConfig;
-}
-
-export function isDigestPinnedOciImage(image: string): boolean {
-  return /^[^@\s]+@sha256:[0-9a-f]{64}$/i.test(image);
-}
-
-export function loadConfig(environment: NodeJS.ProcessEnv = process.env): SelfBenchConfig {
-  const value = environmentSchema.parse(environment);
-  if (
-    !["127.0.0.1", "::1", "localhost"].includes(value.SELFBENCH_API_HOST) &&
-    !value.SELFBENCH_API_TOKEN
-  ) {
-    throw new Error("SELFBENCH_API_TOKEN is required when the API listens beyond loopback");
-  }
-  const artifact =
-    value.SELFBENCH_ARTIFACT_BACKEND === "gcs"
-      ? {
-          kind: "gcs" as const,
-          bucket: value.SELFBENCH_GCS_BUCKET ?? fail("SELFBENCH_GCS_BUCKET is required for GCS"),
-          prefix: value.SELFBENCH_GCS_PREFIX,
-        }
-      : { kind: "local" as const, directory: value.SELFBENCH_ARTIFACT_DIR };
-
-  const harborEnvironment =
-    value.SELFBENCH_HARBOR_ENVIRONMENT ??
-    matchingHarborEnvironment(value.SELFBENCH_EXECUTION_BACKEND) ??
-    fail(
-      `SELFBENCH_HARBOR_ENVIRONMENT is required for ${value.SELFBENCH_EXECUTION_BACKEND} execution`,
-    );
-  let execution: ExecutionConfig;
-  switch (value.SELFBENCH_EXECUTION_BACKEND) {
-    case "docker":
-      execution = { kind: "docker", image: value.SELFBENCH_DOCKER_IMAGE };
-      break;
-    case "modal":
-      execution = {
-        kind: "modal",
-        app: value.SELFBENCH_MODAL_APP,
-        image: value.SELFBENCH_MODAL_IMAGE,
-        ...(value.SELFBENCH_MODAL_ENVIRONMENT
-          ? { environment: value.SELFBENCH_MODAL_ENVIRONMENT }
-          : {}),
-      };
-      break;
-    case "vercel": {
-      const image =
-        value.SELFBENCH_VERCEL_IMAGE ??
-        fail("SELFBENCH_VERCEL_IMAGE is required for Vercel execution");
-      if (!isDigestPinnedOciImage(image)) {
-        fail("SELFBENCH_VERCEL_IMAGE must be pinned by sha256 digest");
-      }
-      execution = {
-        kind: "vercel",
-        image,
-        timeoutCapMs: vercelTimeoutCap(value.SELFBENCH_VERCEL_TIMEOUT_CAP),
-      };
-      break;
-    }
-  }
-
-  return {
-    apiHost: value.SELFBENCH_API_HOST,
-    apiPort: value.SELFBENCH_API_PORT,
-    ...(value.SELFBENCH_API_TOKEN ? { apiToken: value.SELFBENCH_API_TOKEN } : {}),
-    ...(value.SELFBENCH_BUILD_COMMIT
-      ? { buildCommit: value.SELFBENCH_BUILD_COMMIT.toLowerCase() }
-      : {}),
-    activityConcurrency:
-      value.SELFBENCH_ACTIVITY_CONCURRENCY ??
-      DEFAULT_ACTIVITY_CONCURRENCY[value.SELFBENCH_EXECUTION_BACKEND],
-    artifact,
-    harborEnvironment,
-    execution,
-    temporal: {
-      address: value.SELFBENCH_TEMPORAL_ADDRESS,
-      namespace: value.SELFBENCH_TEMPORAL_NAMESPACE,
-      tls: value.SELFBENCH_TEMPORAL_TLS,
-      taskQueue: value.SELFBENCH_TASK_QUEUE,
-      ...(value.SELFBENCH_TEMPORAL_API_KEY ? { apiKey: value.SELFBENCH_TEMPORAL_API_KEY } : {}),
-    },
-  };
-}
-
-export function loadWorkerConfig(
-  environment: NodeJS.ProcessEnv = process.env,
-): SelfBenchWorkerConfig {
-  const config = loadConfig(environment);
-  if (config.execution.kind !== "vercel") {
-    return { ...config, execution: config.execution };
-  }
-  return {
-    ...config,
-    execution: {
-      ...config.execution,
-      credentials: vercelCredentials(environment),
-    },
-  };
-}
-
-export function defaultStandaloneConcurrency(
-  config: Pick<SelfBenchConfig, "activityConcurrency" | "execution">,
-  existingDefault: number,
-): number {
-  return config.execution.kind === "vercel" ? config.activityConcurrency : existingDefault;
-}
-
-function vercelCredentials(environment: NodeJS.ProcessEnv): VercelCredentials {
-  const token = environment.VERCEL_TOKEN?.trim();
-  const teamId = environment.VERCEL_TEAM_ID?.trim();
-  const projectId = environment.VERCEL_PROJECT_ID?.trim();
-  if (!token || !teamId || !projectId) {
-    fail("VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID are required for Vercel execution");
-  }
-  return { token, teamId, projectId };
-}
-
-function vercelTimeoutCap(value: string | undefined): number {
-  if (value === undefined) {
-    return STANDARD_VERCEL_TIMEOUT_CAP_MS;
-  }
-  return z
-    .number()
-    .int()
-    .min(100)
-    .max(STANDARD_VERCEL_TIMEOUT_CAP_MS)
-    .parse(parseSandboxTimeoutCapText(value));
-}
-
-function fail(message: string): never {
-  throw new Error(message);
-}

package/src/contracts.ts

@@ -1,233 +0,0 @@
-import { z } from "zod";
-import { EXECUTION_BACKENDS, HARBOR_ENVIRONMENTS, matchingHarborEnvironment } from "./providers.js";
-
-export const commitSchema = z.string().regex(/^[0-9a-f]{40}$/i, "expected a full commit SHA");
-
-export const repositoryRefSchema = z.object({
-  url: z.string().url(),
-  commit: commitSchema,
-});
-
-export type RepositoryRef = z.infer<typeof repositoryRefSchema>;
-
-export const artifactRefSchema = z.object({
-  uri: z.string().min(1),
-  sha256: z.string().regex(/^[0-9a-f]{64}$/),
-  sizeBytes: z.number().int().nonnegative(),
-  contentType: z.string().min(1),
-});
-
-export type ArtifactRef = z.infer<typeof artifactRefSchema>;
-
-export const difficultySchema = z.enum(["easy", "medium", "hard"]);
-export type Difficulty = z.infer<typeof difficultySchema>;
-
-export const MAX_CANDIDATES_PER_RUN = 10_000;
-
-const candidateCountsSchema = z
-  .object({
-    easy: z.number().int().min(0).max(MAX_CANDIDATES_PER_RUN),
-    medium: z.number().int().min(0).max(MAX_CANDIDATES_PER_RUN),
-    hard: z.number().int().min(0).max(MAX_CANDIDATES_PER_RUN),
-  })
-  .refine(({ easy, medium, hard }) => easy + medium + hard >= 1, {
-    message: "at least one candidate must be requested",
-  })
-  .refine(({ easy, medium, hard }) => easy + medium + hard <= MAX_CANDIDATES_PER_RUN, {
-    message: `at most ${MAX_CANDIDATES_PER_RUN} candidates may be requested`,
-  });
-
-const runVersionSchema = z
-  .object({
-    selfbenchCommit: commitSchema,
-    executionBackend: z.enum(EXECUTION_BACKENDS),
-    harborEnvironment: z.enum(HARBOR_ENVIRONMENTS).optional(),
-    sandboxImage: z.string().min(1),
-    sandboxTimeoutCapMs: z.number().int().min(100).optional(),
-    schema: z.literal(1),
-  })
-  .transform((version, context) => {
-    const harborEnvironment =
-      version.harborEnvironment ?? matchingHarborEnvironment(version.executionBackend);
-    if (!harborEnvironment) {
-      context.addIssue({
-        code: "custom",
-        message: `harborEnvironment is required for ${version.executionBackend} execution`,
-        path: ["harborEnvironment"],
-      });
-      return z.NEVER;
-    }
-    if (version.sandboxTimeoutCapMs !== undefined && version.executionBackend !== "vercel") {
-      context.addIssue({
-        code: "custom",
-        message: "sandboxTimeoutCapMs is only valid for Vercel execution",
-        path: ["sandboxTimeoutCapMs"],
-      });
-      return z.NEVER;
-    }
-    return { ...version, harborEnvironment };
-  });
-
-export const runRequestSchema = z.object({
-  runId: z.string().regex(/^[a-z0-9][a-z0-9-]{2,62}$/),
-  repository: repositoryRefSchema,
-  provenance: artifactRefSchema,
-  candidateCounts: candidateCountsSchema,
-  authoring: z.object({
-    provider: z.literal("openai-codex"),
-    model: z.string().min(1),
-    reasoningEffort: z.literal("high"),
-  }),
-  version: runVersionSchema,
-});
-
-export type RunRequest = z.infer<typeof runRequestSchema>;
-
-export const candidateSchema = z.object({
-  candidateId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
-  difficulty: difficultySchema,
-  sourcePr: z.number().int().positive(),
-  sourceUrl: z.string().url(),
-  baseCommit: commitSchema,
-  completedCommit: commitSchema,
-  request: z.string().min(1),
-  provenance: artifactRefSchema,
-});
-
-export type Candidate = z.infer<typeof candidateSchema>;
-
-export const taskDefinitionSchema = z.object({
-  schemaVersion: z.literal(1),
-  difficulty: difficultySchema,
-  taskId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
-  repo: z.string().min(1),
-  baseCommit: commitSchema,
-  workdir: z.string().min(1),
-  setupCommand: z.string().min(1),
-  testCommand: z.string().refine((value) => value.includes("{tests}"), {
-    message: 'testCommand must contain "{tests}"',
-  }),
-  failToPass: z.array(z.string().min(1)).min(1),
-  passToPass: z.array(z.string().min(1)),
-  testPaths: z.array(z.string().min(1)).min(1),
-  toolchains: z.array(z.enum(["uv", "bun", "go", "node", "python", "rust"])).min(1),
-  sourcePr: z.number().int().positive(),
-  sourceUrl: z.string().url(),
-  prompt: z.string().min(1),
-  timeouts: z.object({
-    setupSeconds: z.number().int().positive(),
-    agentSeconds: z.number().int().positive(),
-    testsSeconds: z.number().int().positive(),
-  }),
-  resources: z.object({
-    cpus: z.number().positive(),
-    memoryMb: z.number().int().positive(),
-    storageMb: z.number().int().positive(),
-  }),
-});
-
-export type TaskDefinition = z.infer<typeof taskDefinitionSchema>;
-
-export const authoredTaskSchema = z.object({
-  candidateId: z.string().min(1),
-  taskId: z.string().min(1),
-  definition: artifactRefSchema,
-  bundle: artifactRefSchema,
-});
-
-export type AuthoredTask = z.infer<typeof authoredTaskSchema>;
-
-export const validationResultSchema = z.object({
-  taskId: z.string().min(1),
-  accepted: z.boolean(),
-  nop: z.object({
-    passed: z.boolean(),
-    result: artifactRefSchema,
-    output: artifactRefSchema.optional(),
-  }),
-  oracle: z.object({
-    passed: z.boolean(),
-    result: artifactRefSchema,
-    output: artifactRefSchema.optional(),
-  }),
-  reason: z.string().optional(),
-});
-
-export type ValidationResult = z.infer<typeof validationResultSchema>;
-
-export type RunPhase =
-  | "queued"
-  | "discovering"
-  | "authoring"
-  | "exporting"
-  | "complete"
-  | "blocked"
-  | "failed"
-  | "cancelled";
-
-export interface TaskProgress {
-  taskId: string;
-  candidateId: string;
-  difficulty: Difficulty;
-  status:
-    | "authoring"
-    | "auditing"
-    | "validating"
-    | "reviewing"
-    | "repairing"
-    | "infrastructure_failed"
-    | "rejected"
-    | "accepted";
-  reason?: string;
-}
-
-export interface DiscoveryProgress {
-  readonly wave: number;
-  readonly totalShards: number;
-  readonly completedShards: number;
-  readonly failedShards: number;
-  readonly candidates: number;
-}
-
-export interface RunStatus {
-  readonly runId: string;
-  readonly phase: RunPhase;
-  readonly requested: number;
-  readonly requestedByDifficulty: Readonly<Record<Difficulty, number>>;
-  readonly discovered: number;
-  readonly accepted: number;
-  readonly rejected: number;
-  readonly tasks: readonly TaskProgress[];
-  readonly discovery?: DiscoveryProgress;
-  readonly export?: ArtifactRef;
-  readonly error?: string;
-}
-
-export interface RunResult {
-  readonly runId: string;
-  readonly export: ArtifactRef;
-  readonly acceptedTaskIds: readonly string[];
-}
-
-export interface DiscoveryResult {
-  readonly candidates: readonly Candidate[];
-  readonly report: ArtifactRef;
-}
-
-export type AuthorOutcome =
-  | { readonly kind: "authored"; readonly task: AuthoredTask }
-  | { readonly kind: "rejected"; readonly candidateId: string; readonly reason: string };
-
-export interface ReviewResult {
-  readonly taskId: string;
-  readonly accepted: boolean;
-  readonly report: ArtifactRef;
-  readonly reason?: string;
-}
-
-export interface AuditResult {
-  readonly taskId: string;
-  readonly accepted: boolean;
-  readonly report: ArtifactRef;
-  readonly reason?: string;
-}