self-bench 0.3.2 → 0.3.3

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

@@ -22,6 +22,9 @@ switch (command) {
   case "run":
     await run(rest);
     break;
+  case "down":
+    await down();
+    break;
   case "status":
     await passthrough("GET", `/v1/runs/${requiredArgument(rest, "run ID")}`);
     break;
@@ -97,6 +100,11 @@ async function up(args: string[]): Promise<void> {
   console.log(`SelfBench is running with the ${backend} backend 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> {
   const parsed = parseArgs({
     args,
@@ -333,6 +341,7 @@ function printHelp(): void {
 
 Usage:
   self-bench up [--backend docker|modal] [--modal-config PATH]
+  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

package/src/codex-review.ts

@@ -28,45 +28,54 @@ export const couplingReviewSchema = z.object({
 export type CouplingReview = z.infer<typeof couplingReviewSchema>;
 
 export async function reviewCouplingWithCodex(input: {
-  readonly authJson: string;
+  readonly apiKey?: string;
+  readonly authJson?: string;
   readonly prompt: string;
   readonly signal?: AbortSignal;
   readonly fetch?: typeof fetch;
 }): Promise<CouplingReview> {
-  const credential = parseCredential(input.authJson);
-  const accountId = accountIdFromToken(credential.access);
+  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("https://chatgpt.com/backend-api/codex/responses", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${credential.access}`,
-      "ChatGPT-Account-Id": accountId,
-      Originator: "selfbench",
-      "OpenAI-Beta": "responses=experimental",
-      Accept: "text/event-stream",
-      "Content-Type": "application/json",
+  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 } : {}),
     },
-    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(
@@ -76,6 +85,27 @@ export async function reviewCouplingWithCodex(input: {
   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: ")) {
@@ -148,27 +178,6 @@ ${goldPatch}
 `;
 }
 
-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;
-}
-
 function reviewTool(): Record<string, unknown> {
   return {
     type: "function",

package/src/config.ts

@@ -3,7 +3,6 @@ import { z } from "zod";
 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_URL: z.string().url().default("http://127.0.0.1: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"),
@@ -36,7 +35,6 @@ const environmentSchema = z.object({
 export interface SelfBenchConfig {
   readonly apiHost: string;
   readonly apiPort: number;
-  readonly apiUrl: string;
   readonly apiToken?: string;
   readonly buildCommit?: string;
   readonly activityConcurrency: number;
@@ -81,7 +79,6 @@ export function loadConfig(environment: NodeJS.ProcessEnv = process.env): SelfBe
   return {
     apiHost: value.SELFBENCH_API_HOST,
     apiPort: value.SELFBENCH_API_PORT,
-    apiUrl: value.SELFBENCH_API_URL,
     ...(value.SELFBENCH_API_TOKEN ? { apiToken: value.SELFBENCH_API_TOKEN } : {}),
     ...(value.SELFBENCH_BUILD_COMMIT
       ? { buildCommit: value.SELFBENCH_BUILD_COMMIT.toLowerCase() }

package/src/contracts.ts

@@ -130,15 +130,10 @@ export type RunPhase =
   | "queued"
   | "discovering"
   | "authoring"
-  | "validating"
-  | "reviewing"
-  | "repairing"
-  | "auditing"
   | "exporting"
   | "complete"
   | "blocked"
   | "failed"
-  | "cancelling"
   | "cancelled";
 
 export interface TaskProgress {

package/src/eval-main.ts

@@ -18,7 +18,7 @@ const parsed = parseArgs({
   strict: true,
 });
 if (parsed.values.help) {
-  console.log(`Run Harbor tasks through the fixed Codex subscription model matrix.
+  console.log(`Run Harbor tasks through the fixed Codex model matrix.
 
 Usage:
   self-bench-eval (--export FILE.tar.gz | --tasks DIRECTORY) --jobs DIRECTORY [options]
@@ -29,7 +29,7 @@ Options:
   --environment docker|modal Execution environment (default: modal)
   --concurrency N            Concurrent trials (default: 3)
   --model MODEL              Run only this model; may be repeated
-  --auth FILE                Codex ChatGPT auth.json path
+  --auth FILE                Optional Codex ChatGPT auth.json fallback
   -h, --help                 Show this help`);
   process.exit(0);
 }

package/src/evaluate.ts

@@ -4,7 +4,7 @@ import { basename, join, resolve } from "node:path";
 import { archiveIncompleteHarborJob, tryReadHarborJobResult } from "./harbor-results.js";
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
-import { assertCodexSubscriptionAuth } from "./subscription-auth.js";
+import { assertCodexSubscriptionAuth, openAiApiKey } from "./subscription-auth.js";
 
 export const MATRIX_MODELS = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"] as const;
 export type MatrixModel = (typeof MATRIX_MODELS)[number];
@@ -40,8 +40,11 @@ export async function runMatrix(options: MatrixOptions): Promise<readonly Matrix
   const tasksDirectory = join(root, "tasks");
   await mkdir(root, { recursive: true });
   const taskDirectories = await resolveMatrixTasks(options, tasksDirectory);
+  const apiKey = openAiApiKey();
   const authPath = resolve(options.authPath ?? join(homedir(), ".codex/auth.json"));
-  await assertSubscriptionAuth(authPath);
+  if (!apiKey) {
+    await assertSubscriptionAuth(authPath);
+  }
   const models = options.models ?? MATRIX_MODELS;
   if (models.length < 1) {
     throw new Error("provide at least one evaluation model");
@@ -55,7 +58,7 @@ export async function runMatrix(options: MatrixOptions): Promise<readonly Matrix
       jobsDirectory: root,
       harborPath: options.harborPath ?? "harbor",
       environment: options.environment ?? "modal",
-      authPath,
+      ...(!apiKey ? { authPath } : {}),
       ...item,
     });
     completed += 1;
@@ -69,7 +72,7 @@ export async function runMatrix(options: MatrixOptions): Promise<readonly Matrix
         schemaVersion: 1,
         agent: "codex",
         agentVersion: CODEX_VERSION,
-        auth: "codex-subscription",
+        auth: apiKey ? "openai-api-key" : "codex-subscription",
         reasoningEffort: "high",
         models,
         taskCount: taskDirectories.length,
@@ -112,7 +115,7 @@ async function runTrial(input: {
   readonly jobsDirectory: string;
   readonly harborPath: string;
   readonly environment: "docker" | "modal";
-  readonly authPath: string;
+  readonly authPath?: string;
 }): Promise<MatrixTrialSummary> {
   const taskId = basename(input.taskDirectory);
   const jobName = `${taskId}-${input.model}`.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
@@ -123,9 +126,11 @@ async function runTrial(input: {
   await archiveIncompleteHarborJob(input.jobsDirectory, jobName);
 
   const environment = { ...process.env };
-  delete environment.OPENAI_API_KEY;
-  environment.CODEX_FORCE_AUTH_JSON = "1";
-  environment.CODEX_AUTH_JSON_PATH = input.authPath;
+  if (input.authPath) {
+    delete environment.OPENAI_API_KEY;
+    environment.CODEX_FORCE_AUTH_JSON = "1";
+    environment.CODEX_AUTH_JSON_PATH = input.authPath;
+  }
   let result: Awaited<ReturnType<typeof runCommand>>;
   try {
     result = await runCommand(

package/src/provenance.ts

@@ -4,7 +4,6 @@ import { assertPullRequestBelongsToRepository, githubRepository } from "./github
 import { runCommand } from "./process.js";
 
 export type SessionProvenanceFormat = "codex" | "claude-code" | "pi" | "generic";
-export type ProvenanceFormat = SessionProvenanceFormat | "github-pull-request";
 
 interface ProvenanceMessageBase {
   readonly sessionId: string;

package/src/reaudit-main.ts

@@ -20,7 +20,7 @@ import {
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
 import { createSandboxExecutor, type SandboxExecutor } from "./sandbox.js";
-import { loadPiSubscriptionAuth } from "./subscription-auth.js";
+import { loadPiModelAuth } from "./subscription-auth.js";
 
 const parsed = parseArgs({
   options: {
@@ -50,9 +50,9 @@ const outputPath = resolve(parsed.values.output ?? fail("--output is required"))
 const concurrency = positiveInteger(parsed.values.concurrency, "--concurrency");
 const config = loadConfig();
 const sandbox = createSandboxExecutor(config.execution);
-const [taskIds, piAuth, reviewer] = await Promise.all([
+const [taskIds, modelAuth, reviewer] = await Promise.all([
   readdir(tasksDirectory),
-  loadPiSubscriptionAuth(),
+  loadPiModelAuth(),
   readFile(join(assetRoot(), "dist/sandbox-review.bundle.js")),
 ]);
 const directories = (
@@ -79,7 +79,7 @@ const tasks = await parallelMap(directories, concurrency, async (taskDirectory)
   const taskId = basename(taskDirectory);
   console.error(`reviewing ${taskId}`);
   try {
-    const report = await auditTask(taskDirectory, taskId, piAuth, reviewer, sandbox);
+    const report = await auditTask(taskDirectory, taskId, modelAuth, reviewer, sandbox);
     console.error(`${taskId}: ${report.resolution.verdict}`);
     return report;
   } catch (error) {
@@ -113,7 +113,7 @@ console.log(JSON.stringify({ output: outputPath, ...report.summary }, null, 2));
 async function auditTask(
   taskDirectory: string,
   taskId: string,
-  piAuth: string,
+  modelAuth: { apiKey?: string; authJson?: string },
   reviewer: Uint8Array,
   sandbox: SandboxExecutor,
 ) {
@@ -151,7 +151,10 @@ async function auditTask(
         },
       ],
       outputPaths: ["/work/review.json"],
-      secrets: { SELFBENCH_PI_AUTH_JSON: piAuth },
+      secrets: {
+        ...(modelAuth.apiKey ? { OPENAI_API_KEY: modelAuth.apiKey } : {}),
+        ...(modelAuth.authJson ? { SELFBENCH_PI_AUTH_JSON: modelAuth.authJson } : {}),
+      },
       environment: { SELFBENCH_REVIEW_OUTPUT: "/work/review.json" },
       command: ["node", "/work/sandbox-review.js"],
     });

package/src/repair-main.ts

@@ -9,7 +9,7 @@ import { loadConfig } from "./config.js";
 import { parallelMap } from "./parallel.js";
 import { runCommand } from "./process.js";
 import { createSandboxExecutor } from "./sandbox.js";
-import { loadCodexSubscriptionAuth } from "./subscription-auth.js";
+import { loadCodexModelAuth } from "./subscription-auth.js";
 
 const parsed = parseArgs({
   options: {
@@ -79,8 +79,8 @@ for (const source of sourceTasks) {
 
 const config = loadConfig();
 const sandbox = createSandboxExecutor(config.execution);
-const [authJson, repairer] = await Promise.all([
-  loadCodexSubscriptionAuth(),
+const [modelAuth, repairer] = await Promise.all([
+  loadCodexModelAuth(),
   readFile(join(assetRoot(), "dist/sandbox-repair.bundle.js")),
 ]);
 const results = await parallelMap([...coupled.values()], concurrency, async (taskReview) => {
@@ -103,7 +103,10 @@ const results = await parallelMap([...coupled.values()], concurrency, async (tas
         { path: "/work/sandbox-repair.js", contents: repairer },
       ],
       outputPaths: ["/work/repaired-task.tar.gz", "/work/repair-report.json"],
-      secrets: { SELFBENCH_CODEX_AUTH_JSON: authJson },
+      secrets: {
+        ...(modelAuth.apiKey ? { OPENAI_API_KEY: modelAuth.apiKey } : {}),
+        ...(modelAuth.authJson ? { SELFBENCH_CODEX_AUTH_JSON: modelAuth.authJson } : {}),
+      },
       environment: { SELFBENCH_REPAIR_MODEL: parsed.values.model ?? "gpt-5.6-sol" },
       command: [
         "node",

package/src/sandbox-repair.ts

@@ -50,13 +50,15 @@ await runCommand("git", [
 ]);
 await runCommand("git", ["-C", repositoryDirectory, "add", "-N", "--all"]);
 
+const codexAuth = process.env.SELFBENCH_CODEX_AUTH_JSON;
+const apiKey = process.env.OPENAI_API_KEY;
+if (!apiKey && !codexAuth) {
+  fail("OPENAI_API_KEY or SELFBENCH_CODEX_AUTH_JSON is required");
+}
 const codexHome = join(homedir(), ".codex");
 const authPath = join(codexHome, "auth.json");
 await mkdir(codexHome, { recursive: true });
-await writeFile(
-  authPath,
-  process.env.SELFBENCH_CODEX_AUTH_JSON ?? fail("SELFBENCH_CODEX_AUTH_JSON is required"),
-);
+await writeFile(authPath, codexAuth ?? `${JSON.stringify({ OPENAI_API_KEY: apiKey })}\n`);
 await chmod(authPath, 0o600);
 const promptPath = join(tmpdir(), `selfbench-repair-${taskId}.md`);
 await writeFile(
@@ -86,7 +88,7 @@ const codex = await runCommand(
   {
     allowFailure: true,
     timeoutMs: 90 * 60 * 1000,
-    env: withoutApiKey(process.env),
+    env: process.env,
     input: await readFile(promptPath, "utf8"),
     onOutput: (stream, chunk) => {
       (stream === "stdout" ? process.stdout : process.stderr).write(chunk);
@@ -149,12 +151,6 @@ await writeFile(
   )}\n`,
 );
 
-function withoutApiKey(environment: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-  const output = { ...environment };
-  delete output.OPENAI_API_KEY;
-  return output;
-}
-
 function fail(message: string): never {
   throw new Error(message);
 }

package/src/sandbox-review.ts

@@ -1,17 +1,19 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { reviewCouplingWithCodex } from "./codex-review.js";
 
+const apiKey = process.env.OPENAI_API_KEY;
 const authJson = process.env.SELFBENCH_PI_AUTH_JSON;
 const outputPath = process.env.SELFBENCH_REVIEW_OUTPUT;
-if (!authJson) {
-  throw new Error("SELFBENCH_PI_AUTH_JSON is required");
+if (!apiKey && !authJson) {
+  throw new Error("OPENAI_API_KEY or SELFBENCH_PI_AUTH_JSON is required");
 }
 if (!outputPath) {
   throw new Error("SELFBENCH_REVIEW_OUTPUT is required");
 }
 
 const review = await reviewCouplingWithCodex({
-  authJson,
+  ...(apiKey ? { apiKey } : {}),
+  ...(authJson ? { authJson } : {}),
   prompt: await readFile("/work/review-input.md", "utf8"),
 });
 await writeFile(outputPath, `${JSON.stringify(review, null, 2)}\n`, { flag: "wx" });

package/src/sandbox-validation-repair.ts

@@ -68,10 +68,19 @@ await Promise.all([
 ]);
 
 const piHome = join(homedir(), ".pi/agent");
-const piAuth = process.env.SELFBENCH_PI_AUTH_JSON ?? fail("SELFBENCH_PI_AUTH_JSON is required");
+const piAuth = process.env.SELFBENCH_PI_AUTH_JSON;
+if (!process.env.OPENAI_API_KEY && !piAuth) {
+  fail("OPENAI_API_KEY or SELFBENCH_PI_AUTH_JSON is required");
+}
 await mkdir(piHome, { recursive: true });
 await Promise.all([
-  writeFile(join(piHome, "auth.json"), piAuth).then(() => chmod(join(piHome, "auth.json"), 0o600)),
+  ...(piAuth
+    ? [
+        writeFile(join(piHome, "auth.json"), piAuth).then(() =>
+          chmod(join(piHome, "auth.json"), 0o600),
+        ),
+      ]
+    : []),
   writeFile(join(piHome, "settings.json"), `${JSON.stringify({ transport: "auto" })}\n`),
 ]);
 const promptPath = join(tmpdir(), `selfbench-validation-repair-${originalDefinition.taskId}.md`);
@@ -98,7 +107,7 @@ const pi = await runCommand(
     "--no-context-files",
     "--no-extensions",
     "--provider",
-    "openai-codex",
+    process.env.OPENAI_API_KEY ? "openai" : "openai-codex",
     "--model",
     process.env.SELFBENCH_REPAIR_MODEL ?? "gpt-5.6-sol",
     "--thinking",
@@ -111,7 +120,7 @@ const pi = await runCommand(
     allowFailure: true,
     timeoutMs: 90 * 60 * 1000,
     cwd: repositoryDirectory,
-    env: withoutApiKey(process.env),
+    env: process.env,
     onOutput: (stream, chunk) => {
       (stream === "stdout" ? process.stdout : process.stderr).write(chunk);
     },
@@ -163,12 +172,6 @@ await Promise.all([
   ),
 ]);
 
-function withoutApiKey(environment: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-  const output = { ...environment };
-  delete output.OPENAI_API_KEY;
-  return output;
-}
-
 function fail(message: string): never {
   throw new Error(message);
 }

package/src/subscription-auth.ts

@@ -3,6 +3,34 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { runCommand } from "./process.js";
 
+export interface PiModelAuth {
+  readonly provider: "openai" | "openai-codex";
+  readonly apiKey?: string;
+  readonly authJson?: string;
+}
+
+export interface CodexModelAuth {
+  readonly apiKey?: string;
+  readonly authJson?: string;
+}
+
+export function openAiApiKey(): string | undefined {
+  const key = process.env.OPENAI_API_KEY?.trim();
+  return key || undefined;
+}
+
+export async function loadPiModelAuth(): Promise<PiModelAuth> {
+  const apiKey = openAiApiKey();
+  return apiKey
+    ? { provider: "openai", apiKey }
+    : { provider: "openai-codex", authJson: await loadPiSubscriptionAuth() };
+}
+
+export async function loadCodexModelAuth(): Promise<CodexModelAuth> {
+  const apiKey = openAiApiKey();
+  return apiKey ? { apiKey } : { authJson: await loadCodexSubscriptionAuth() };
+}
+
 export async function loadPiSubscriptionAuth(): Promise<string> {
   const raw =
     process.env.SELFBENCH_PI_AUTH_JSON ??
@@ -28,7 +56,8 @@ export function assertCodexSubscriptionAuth(value: unknown, source = "Codex auth
 
 export async function loadCodexSubscriptionAuth(): Promise<string> {
   const path = process.env.CODEX_AUTH_JSON_PATH ?? join(homedir(), ".codex/auth.json");
-  const parsed = JSON.parse(await readFile(path, "utf8")) as unknown;
+  const raw = process.env.SELFBENCH_CODEX_AUTH_JSON ?? (await readFile(path, "utf8"));
+  const parsed = JSON.parse(raw) as unknown;
   assertCodexSubscriptionAuth(parsed, path);
   const auth = parsed as Record<string, unknown>;
   return JSON.stringify({
@@ -38,22 +67,6 @@ export async function loadCodexSubscriptionAuth(): Promise<string> {
   });
 }
 
-export async function subscriptionBearerToken(model: string): Promise<string> {
-  const result = await runCommand("pi", [
-    "auth",
-    "print-bearer-token",
-    "--provider",
-    "openai-codex",
-    "--model",
-    model,
-  ]);
-  const token = result.stdout.trim();
-  if (!token) {
-    throw new Error(`Pi returned no openai-codex subscription bearer token for ${model}`);
-  }
-  return token;
-}
-
 export async function githubToken(): Promise<string | undefined> {
   if (process.env.GH_TOKEN) {
     return process.env.GH_TOKEN;