claude-overnight 1.58.0 → 1.60.0

package/dist/bin/evolve-subcommands.d.ts

@@ -0,0 +1,3 @@
+export declare function runDiff(runIdA: string | undefined, runIdB: string | undefined): Promise<void>;
+export declare function runDownload(runIdArg?: string, ...rest: string[]): Promise<void>;
+export declare function runPromote(runIdArg?: string, ...rest: string[]): Promise<void>;

package/dist/bin/evolve-subcommands.js

@@ -0,0 +1,234 @@
+export async function runDiff(runIdA, runIdB) {
+    if (!runIdA || !runIdB) {
+        console.error("usage: claude-overnight-evolve diff <runIdA> <runIdB>");
+        process.exit(2);
+    }
+    const { loadRun } = await import("../prompt-evolution/persistence.js");
+    const a = loadRun(runIdA);
+    const b = loadRun(runIdB);
+    const collect = (run) => {
+        const out = new Map();
+        for (const rec of run.matrix) {
+            // Keep the latest-generation row per variantId so diff compares final state.
+            const existing = out.get(rec.variantId);
+            if (!existing || rec.generation > existing.generation) {
+                out.set(rec.variantId, { generation: rec.generation, variantId: rec.variantId, gmean: rec.gmean });
+            }
+        }
+        return out;
+    };
+    const rowsA = collect(a);
+    const rowsB = collect(b);
+    const ids = new Set([...rowsA.keys(), ...rowsB.keys()]);
+    console.log(`# Diff: ${runIdA} → ${runIdB}`);
+    console.log("");
+    console.log(`|  Variant  |  A gmean  |  B gmean  |   Δ   |  note  |`);
+    console.log(`|-----------|-----------|-----------|-------|--------|`);
+    const sorted = [...ids].sort();
+    for (const id of sorted) {
+        const ra = rowsA.get(id);
+        const rb = rowsB.get(id);
+        const ga = ra ? (ra.gmean * 100).toFixed(1) : "—";
+        const gb = rb ? (rb.gmean * 100).toFixed(1) : "—";
+        const delta = ra && rb ? ((rb.gmean - ra.gmean) * 100).toFixed(1) : "—";
+        const note = !ra ? "new in B" : !rb ? "missing in B" : ra.gmean < rb.gmean ? "↑" : ra.gmean > rb.gmean ? "↓" : "=";
+        console.log(`| ${id.padEnd(10)}| ${ga.padStart(9)} | ${gb.padStart(9)} | ${delta.padStart(5)} | ${note} |`);
+    }
+}
+export async function runDownload(runIdArg, ...rest) {
+    if (!runIdArg) {
+        console.error("usage: claude-overnight-evolve download <runId> --base-url <url> [--token <token>] [--project <id>]");
+        process.exit(2);
+    }
+    const runId = runIdArg;
+    let baseUrl;
+    let token;
+    let projectId;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--base-url" && rest[i + 1]) {
+            baseUrl = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--token" && rest[i + 1]) {
+            token = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--project" && rest[i + 1]) {
+            projectId = rest[i + 1];
+            i++;
+        }
+    }
+    if (!baseUrl) {
+        console.error("--base-url is required (e.g. https://fornace.net or http://localhost:8787)");
+        process.exit(2);
+    }
+    const authHeaders = {};
+    if (token)
+        authHeaders.Authorization = `Bearer ${token}`;
+    const prefix = projectId
+        ? `${baseUrl.replace(/\/$/, "")}/api/projects/${projectId}/prompt-evolution/${runId}`
+        : `${baseUrl.replace(/\/$/, "")}/runs/${runId}`;
+    const metaRes = await fetch(prefix, { headers: authHeaders });
+    if (!metaRes.ok) {
+        console.error(`Failed to fetch run metadata: HTTP ${metaRes.status}`);
+        process.exit(1);
+    }
+    const metaBody = (await metaRes.json());
+    const remoteMeta = typeof metaBody.meta === "object" && metaBody.meta
+        ? metaBody.meta
+        : metaBody;
+    const { runDir } = await import("../prompt-evolution/persistence.js");
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    const { dirname, join } = await import("node:path");
+    const localDir = runDir(runId);
+    mkdirSync(localDir, { recursive: true });
+    mkdirSync(join(localDir, "prompts"), { recursive: true });
+    const meta = {
+        runId,
+        promptPath: (remoteMeta.promptPath ?? remoteMeta.prompt ?? ""),
+        target: (remoteMeta.target ?? "claude-overnight"),
+        evalModel: (remoteMeta.evalModel ?? ""),
+        mutateModel: (remoteMeta.mutateModel ?? remoteMeta.evalModel ?? ""),
+        generations: (remoteMeta.generations ?? 10),
+        populationCap: (remoteMeta.populationCap ?? remoteMeta.population ?? 8),
+        startedAt: (remoteMeta.startedAt ?? remoteMeta.queuedAt ?? new Date().toISOString()),
+        status: (remoteMeta.status ?? "done"),
+        caseNames: [],
+    };
+    writeFileSync(join(localDir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+    const inlineReport = typeof metaBody.report === "string" ? metaBody.report : metaBody.report_md;
+    if (typeof inlineReport === "string") {
+        writeFileSync(join(localDir, "report.md"), inlineReport);
+        console.log("  ✓ report.md (inline)");
+    }
+    const listRes = await fetch(`${prefix}/files`, { headers: authHeaders });
+    let files = [];
+    if (listRes.ok) {
+        const listBody = (await listRes.json());
+        files = listBody.files ?? [];
+    }
+    else {
+        console.log(`  ⚠ File listing not available (HTTP ${listRes.status}); trying known files...`);
+        files = ["report.md", "best.md", "matrix.jsonl", "learning.jsonl"];
+    }
+    for (const file of files) {
+        const fileRes = await fetch(`${prefix}/files/${encodeURIComponent(file)}`, { headers: authHeaders });
+        if (!fileRes.ok) {
+            console.error(`  ⚠ ${file}: HTTP ${fileRes.status}`);
+            continue;
+        }
+        const data = Buffer.from(await fileRes.arrayBuffer());
+        const localPath = join(localDir, file);
+        mkdirSync(dirname(localPath), { recursive: true });
+        writeFileSync(localPath, data);
+        console.log(`  ✓ ${file}`);
+    }
+    const matrixPath = join(localDir, "matrix.jsonl");
+    const { existsSync, readFileSync } = await import("node:fs");
+    if (existsSync(matrixPath)) {
+        const variantIds = new Set();
+        for (const line of readFileSync(matrixPath, "utf-8").trim().split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const row = JSON.parse(line);
+                if (row.variantId)
+                    variantIds.add(row.variantId);
+            }
+            catch { /* ignore */ }
+        }
+        for (const vid of variantIds) {
+            const safeId = vid.replace(/[^a-zA-Z0-9_-]/g, "_");
+            const promptFile = `prompts/${safeId}.md`;
+            if (existsSync(join(localDir, promptFile)))
+                continue;
+            const fileRes = await fetch(`${prefix}/files/${encodeURIComponent(promptFile)}`, { headers: authHeaders });
+            if (!fileRes.ok)
+                continue;
+            const data = Buffer.from(await fileRes.arrayBuffer());
+            mkdirSync(dirname(join(localDir, promptFile)), { recursive: true });
+            writeFileSync(join(localDir, promptFile), data);
+            console.log(`  ✓ ${promptFile} (from matrix)`);
+        }
+    }
+    console.log(`\nDownloaded to ${localDir}`);
+}
+export async function runPromote(runIdArg, ...rest) {
+    if (!runIdArg) {
+        console.error("usage: claude-overnight-evolve promote <runId> [--variant <id>] [--into <block>]");
+        process.exit(2);
+    }
+    const runId = runIdArg;
+    let variantId;
+    let intoBlock;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === "--variant" && rest[i + 1]) {
+            variantId = rest[i + 1];
+            i++;
+        }
+        else if (rest[i] === "--into" && rest[i + 1]) {
+            intoBlock = rest[i + 1];
+            i++;
+        }
+    }
+    const { loadRun, runDir } = await import("../prompt-evolution/persistence.js");
+    const { PROMPTS_ROOT } = await import("../prompts/load.js");
+    const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const run = loadRun(runId);
+    const promptPath = run.meta.promptPath;
+    let sourceVariant = variantId;
+    if (!sourceVariant) {
+        const bestMatch = run.bestMd.match(/variantId\s*\|\s*`([^`]+)`/);
+        sourceVariant = bestMatch ? bestMatch[1] : undefined;
+        if (!sourceVariant) {
+            const rows = run.matrix;
+            if (rows.length)
+                sourceVariant = [...rows].sort((a, b) => b.gmean - a.gmean)[0].variantId;
+        }
+    }
+    if (!sourceVariant) {
+        console.error("Could not determine best variant for run. Use --variant <id>.");
+        process.exit(2);
+    }
+    const safeId = sourceVariant.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const variantFile = join(runDir(runId), "prompts", `${safeId}.md`);
+    if (!existsSync(variantFile)) {
+        console.error(`Variant file not found: ${variantFile}`);
+        process.exit(2);
+    }
+    const variantText = readFileSync(variantFile, "utf-8").replace(/^<!--\s*generation=[\s\S]*?-->\n\n?/, "");
+    const namedVariants = ["tight", "standard", "large", "wrap", "amend", "wave", "run", "file", "all", "postfailed", "nofiles"];
+    const targetBlock = intoBlock ?? (namedVariants.includes(sourceVariant.toLowerCase()) ? sourceVariant : undefined);
+    if (!targetBlock) {
+        console.error(`Variant "${sourceVariant}" is not a named seed variant. Use --into <block> to specify which marker block to overwrite.`);
+        process.exit(2);
+    }
+    const promptFile = join(PROMPTS_ROOT, promptPath + ".md");
+    if (!existsSync(promptFile)) {
+        console.error(`Prompt file not found: ${promptFile}`);
+        process.exit(2);
+    }
+    const newText = replaceVariantBlock(readFileSync(promptFile, "utf-8"), targetBlock, variantText);
+    writeFileSync(promptFile, newText);
+    console.log(`Promoted ${sourceVariant} → ${promptPath} (<!-- ${targetBlock.toUpperCase()} -->)`);
+    console.log(`  file: ${promptFile}`);
+}
+function replaceVariantBlock(fileText, blockName, newText) {
+    const separator = "\n<!-- @@@ -->\n";
+    const sections = fileText.split(separator);
+    const markerRegex = new RegExp(`<!--\\s*(?:[─\\-]+\\s*)?${blockName.toUpperCase()}\\s*-->`, "i");
+    let found = false;
+    const newSections = sections.map((section) => {
+        const lines = section.split("\n");
+        const markerIndex = lines.findIndex((line) => markerRegex.test(line));
+        if (markerIndex === -1)
+            return section;
+        found = true;
+        const before = lines.slice(0, markerIndex + 1);
+        return [...before, "", newText.trim(), ""].join("\n").trimEnd() + "\n";
+    });
+    if (!found)
+        throw new Error(`Variant block "${blockName.toUpperCase()}" not found in prompt file`);
+    return newSections.join(separator);
+}

package/dist/bin/evolve.js

@@ -19,6 +19,7 @@ import { evolvePrompt } from "../prompt-evolution/index.js";
 import { PLAN_CASES } from "../prompt-evolution/fixtures/plan-cases.js";
 import { harvestRealCases } from "../prompt-evolution/fixtures/harvest.js";
 import { generateCases } from "../prompt-evolution/fixtures/generate.js";
+import { runDiff, runDownload, runPromote } from "./evolve-subcommands.js";
 import { scenariosToCases, PLANNING_SCENARIOS, REVIEW_SCENARIOS, SUPERVISION_SCENARIOS, STUCK_SCENARIOS, hydrateCases, extractPrompt, } from "../prompt-evolution/adapters/mcp-browser.js";
 function help() {
     process.stdout.write(`Usage: claude-overnight-evolve [options]
@@ -39,12 +40,6 @@ Options:
   --plateau <n>           Stop early if no improvement for N generations (default: 3)
   --reps <n>              Repetitions per (variant, case, model) for noise floor (default: 1)
   --concurrency <n>       Max in-flight eval calls (default: 8; bump for slow endpoints)
-  --batch                 Use provider batch API (50% cheaper, slower wall-clock)
-  --batch-base-url <url>  Override base URL for batch only (e.g. api.moonshot.ai/v1
-                          when online uses api.kimi.com/coding)
-  --batch-auth-token <t>  Override auth token for batch only
-  --batch-model <model>   Override model for batch only (e.g. "kimi-k2.6" for
-                          Moonshot platform when online uses "kimi-for-coding")
   --adaptive-cap <n>      Adaptive sampling: extend reps up to N when σ > threshold (default: off)
   --adaptive-threshold <x> σ threshold that triggers an extra rep (default: 0.1)
   --judge                 Use llm-judge for content scoring (costs extra API calls)
@@ -63,6 +58,18 @@ Options:
   --gen-model <model>     Model used by the case generator (default: eval-model)
 
 Subcommands:
+  claude-overnight-evolve download <runId> --base-url <url> [--token <token>]
+                          [--project <id>]
+                          Pull a remote run (fornace or self-host) into the local
+                          ~/.claude-overnight/prompt-evolution/<runId>/ directory
+                          so you can audit, diff, or promote it offline. Use
+                          --project for fornace; omit for self-host.
+  claude-overnight-evolve promote <runId> [--variant <id>] [--into <block>]
+                          Write a run's winning variant back into the source
+                          prompt file's <!-- BLOCK --> marker. If --variant is
+                          omitted, uses the run's best variant. If the variant is
+                          a seed (tight/standard/large) --into defaults to its
+                          name; evo-* or default variants require --into.
   claude-overnight-evolve diff <runIdA> <runIdB>
                           Print a per-variant diff of two persisted runs
   --base-url <url>        API base URL override
@@ -85,7 +92,6 @@ function parseArgs() {
         population: 8,
         plateau: 3,
         reps: 1,
-        batch: false,
         useJudge: false,
         judgeTopN: 4,
         cases: "",
@@ -143,21 +149,6 @@ function parseArgs() {
                 opts.concurrency = parseInt(v, 10);
                 i++;
                 break;
-            case "--batch":
-                opts.batch = true;
-                break;
-            case "--batch-base-url":
-                opts.batchBaseUrl = v;
-                i++;
-                break;
-            case "--batch-auth-token":
-                opts.batchAuthToken = v;
-                i++;
-                break;
-            case "--batch-model":
-                opts.batchModel = v;
-                i++;
-                break;
             case "--adaptive-cap":
                 opts.adaptiveCap = parseInt(v, 10);
                 i++;
@@ -230,6 +221,16 @@ function parseArgs() {
     return opts;
 }
 async function main() {
+    // Subcommand: download a remote run for local audit/promote.
+    if (process.argv[2] === "download") {
+        await runDownload(process.argv[3], ...process.argv.slice(4));
+        return;
+    }
+    // Subcommand: promote a run variant back into the source prompt file.
+    if (process.argv[2] === "promote") {
+        await runPromote(process.argv[3], ...process.argv.slice(4));
+        return;
+    }
     // Subcommand: diff two persisted runs.
     if (process.argv[2] === "diff") {
         await runDiff(process.argv[3], process.argv[4]);
@@ -347,10 +348,6 @@ async function evolveOne(opts) {
         plateauGenerations: opts.plateau,
         repetitions: opts.reps > 1 ? opts.reps : undefined,
         concurrency: opts.concurrency,
-        batch: opts.batch || undefined,
-        batchBaseUrl: opts.batchBaseUrl,
-        batchAuthToken: opts.batchAuthToken,
-        batchModel: opts.batchModel,
         adaptiveReps: opts.adaptiveCap
             ? { cap: opts.adaptiveCap, threshold: opts.adaptiveThreshold }
             : undefined,
@@ -383,43 +380,6 @@ async function evolveOne(opts) {
     console.log(result.bestVariant.text);
     return result;
 }
-async function runDiff(runIdA, runIdB) {
-    if (!runIdA || !runIdB) {
-        console.error("usage: claude-overnight-evolve diff <runIdA> <runIdB>");
-        process.exit(2);
-    }
-    const { loadRun } = await import("../prompt-evolution/persistence.js");
-    const a = loadRun(runIdA);
-    const b = loadRun(runIdB);
-    const collect = (run) => {
-        const out = new Map();
-        for (const rec of run.matrix) {
-            // Keep the latest-generation row per variantId so diff compares final state.
-            const existing = out.get(rec.variantId);
-            if (!existing || rec.generation > existing.generation) {
-                out.set(rec.variantId, { generation: rec.generation, variantId: rec.variantId, gmean: rec.gmean });
-            }
-        }
-        return out;
-    };
-    const rowsA = collect(a);
-    const rowsB = collect(b);
-    const ids = new Set([...rowsA.keys(), ...rowsB.keys()]);
-    console.log(`# Diff: ${runIdA} → ${runIdB}`);
-    console.log("");
-    console.log(`|  Variant  |  A gmean  |  B gmean  |   Δ   |  note  |`);
-    console.log(`|-----------|-----------|-----------|-------|--------|`);
-    const sorted = [...ids].sort();
-    for (const id of sorted) {
-        const ra = rowsA.get(id);
-        const rb = rowsB.get(id);
-        const ga = ra ? (ra.gmean * 100).toFixed(1) : "—";
-        const gb = rb ? (rb.gmean * 100).toFixed(1) : "—";
-        const delta = ra && rb ? ((rb.gmean - ra.gmean) * 100).toFixed(1) : "—";
-        const note = !ra ? "new in B" : !rb ? "missing in B" : ra.gmean < rb.gmean ? "↑" : ra.gmean > rb.gmean ? "↓" : "=";
-        console.log(`| ${id.padEnd(10)}| ${ga.padStart(9)} | ${gb.padStart(9)} | ${delta.padStart(5)} | ${note} |`);
-    }
-}
 main().catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/core/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.58.0";
+export declare const VERSION = "1.60.0";

package/dist/core/_version.js

@@ -1,2 +1,2 @@
 // Auto-generated by build — do not edit manually.
-export const VERSION = "1.58.0";
+export const VERSION = "1.60.0";

package/dist/prompt-evolution/evaluator-judge.d.ts

@@ -1,20 +1,15 @@
 /**
  * LLM-judge pass over a built evaluation matrix.
  *
- * Split out of evaluator.ts to keep each file under the 500-line cap and
- * because the judge has its own concerns (top-N eligibility, batch vs
- * online path, crash-resumable state).
- *
  * The judge REPLACES the heuristic content score with a semantic grade.
  * We only judge top-N variants per generation to cap cost — a judge call
  * per (variant, case, model) on a large population explodes fast.
  */
 import { type JudgeOpts } from "./llm-judge.js";
 import type { BenchmarkCase, EvaluationResult } from "./types.js";
-import type { EvalOpts } from "./evaluator.js";
 export declare function runJudge(variants: Array<{
     id: string;
     text: string;
 }>, cases: BenchmarkCase[], models: string[], aggregated: Map<string, EvaluationResult>, judge: JudgeOpts & {
     topN?: number;
-}, opts: EvalOpts): Promise<void>;
+}): Promise<void>;

package/dist/prompt-evolution/evaluator-judge.js

@@ -1,20 +1,14 @@
 /**
  * LLM-judge pass over a built evaluation matrix.
  *
- * Split out of evaluator.ts to keep each file under the 500-line cap and
- * because the judge has its own concerns (top-N eligibility, batch vs
- * online path, crash-resumable state).
- *
  * The judge REPLACES the heuristic content score with a semantic grade.
  * We only judge top-N variants per generation to cap cost — a judge call
  * per (variant, case, model) on a large population explodes fast.
  */
-import { judgeOutput, buildJudgePrompt, parseJudgeOutput } from "./llm-judge.js";
-import { batchCallModel } from "./transport-batch.js";
-import { saveBatchState, loadBatchState, markBatchFinished } from "./persistence.js";
+import { judgeOutput } from "./llm-judge.js";
 import { gmean } from "./scorer.js";
 import { averageDimensions } from "./evaluator-utils.js";
-export async function runJudge(variants, cases, models, aggregated, judge, opts) {
+export async function runJudge(variants, cases, models, aggregated, judge) {
     const topN = judge.topN ?? 4;
     const variantGmeans = variants.map((v) => {
         const scores = [];
@@ -45,10 +39,6 @@ export async function runJudge(variants, cases, models, aggregated, judge, opts)
     }
     if (cells.length === 0)
         return;
-    if (opts.batch) {
-        await runJudgeBatch(cells, judge, opts);
-        return;
-    }
     const jobs = cells.map((cell) => async () => {
         try {
             const jr = await judgeOutput(cell.r.rawOutput, cell.c, judge);
@@ -71,53 +61,3 @@ export async function runJudge(variants, cases, models, aggregated, judge, opts)
     };
     await Promise.all(Array.from({ length: Math.min(judgeConcurrency, jobs.length) }, judgeWorker));
 }
-async function runJudgeBatch(cells, judge, opts) {
-    const batchJobs = cells.map((cell, i) => ({
-        customId: `j:${i}|k:${cell.key}`,
-        userText: buildJudgePrompt(cell.r.rawOutput, cell.c),
-        model: judge.model,
-    }));
-    const existing = opts.runId != null && opts.generation != null
-        ? loadBatchState(opts.runId, opts.generation, "judge")
-        : null;
-    const transport = opts.batchCallModel ?? batchCallModel;
-    const results = await transport(batchJobs, {
-        // Judge batch follows the same override hierarchy as eval batch: if a
-        // dedicated batch endpoint is set on EvalOpts, use it; else fall back
-        // to the judge's own endpoint or the main one.
-        baseUrl: opts.batchBaseUrl ?? judge.baseUrl ?? opts.baseUrl,
-        authToken: opts.batchAuthToken ?? judge.authToken ?? opts.authToken,
-        modelOverride: opts.batchModel,
-        maxTokens: judge.maxTokens ?? 2048,
-        resumeBatchId: existing?.batchId,
-        onSubmitted: (batchId, p) => {
-            if (opts.runId != null && opts.generation != null && !existing) {
-                saveBatchState(opts.runId, {
-                    generation: opts.generation,
-                    phase: "judge",
-                    batchId,
-                    provider: p,
-                    submittedAt: new Date().toISOString(),
-                });
-            }
-            opts.onBatchProgress?.(`judge batch submitted: ${batchId} (${p})`);
-        },
-        onProgress: (p) => opts.onBatchProgress?.(`judge batch ${p.batchId} ${p.phase}${p.succeeded != null ? `: ${p.succeeded}/${p.total ?? batchJobs.length}` : ""}`),
-    });
-    if (opts.runId != null && existing)
-        markBatchFinished(opts.runId, existing.batchId);
-    for (const cell of cells) {
-        const customId = batchJobs.find((b) => b.customId.includes(`|k:${cell.key}`))?.customId;
-        const got = customId ? results.get(customId) : undefined;
-        if (!got || !got.raw)
-            continue;
-        try {
-            const jr = parseJudgeOutput(got.raw);
-            cell.r.scores = { ...cell.r.scores, content: jr.score };
-            cell.r.judgeJustification = jr.justification;
-        }
-        catch {
-            // Judge parse failure is non-fatal — keep heuristic content.
-        }
-    }
-}

package/dist/prompt-evolution/evaluator.d.ts

@@ -17,7 +17,6 @@
  */
 import { type JudgeOpts } from "./llm-judge.js";
 import { type CallModel } from "./transport.js";
-import { batchCallModel } from "./transport-batch.js";
 import type { BenchmarkCase, VariantRow, PromptVars } from "./types.js";
 export interface EvalOpts {
     /** Primary generator model (retained for single-model compat). */
@@ -51,29 +50,8 @@ export interface EvalOpts {
     };
     /** Transport override for tests. */
     callModel?: CallModel;
-    /** Use provider batch API instead of online calls (50% cheaper, slower wall-clock). */
-    batch?: boolean;
-    /**
-     * Override base URL for batch submissions only — lets batch hit a
-     * different endpoint than online. Key use-case: Kimi users whose online
-     * traffic runs through api.kimi.com/coding (which has no batch) but
-     * whose batch traffic should go to api.moonshot.ai/v1.
-     */
-    batchBaseUrl?: string;
-    /** Override auth token for batch when batchBaseUrl needs a different key. */
-    batchAuthToken?: string;
-    /** Override model for batch submissions (e.g., kimi-k2.6 when online uses kimi-for-coding). */
-    batchModel?: string;
-    /** Run id — required when batch=true so state is crash-resumable. */
-    runId?: string;
-    /** Current generation number — used to key batch state. */
-    generation?: number;
-    /** Batch-transport override for tests. Same return shape as transport-batch.batchCallModel. */
-    batchCallModel?: typeof batchCallModel;
     /** Optional callback for progress */
     onProgress?: (done: number, total: number, caseName: string, variantId: string) => void;
-    /** Progress callback specific to batch-phase transitions. */
-    onBatchProgress?: (msg: string) => void;
 }
 export declare function buildMatrix(variants: Array<{
     id: string;

package/dist/prompt-evolution/evaluator.js

@@ -18,8 +18,6 @@
 import { renderPrompt } from "../prompts/load.js";
 import { scoreOutput, gmean, aggregateReps, bootstrapCI, kendallTau } from "./scorer.js";
 import { defaultCallModel, attemptJsonParse, } from "./transport.js";
-import { batchCallModel, detectBatchProvider, } from "./transport-batch.js";
-import { saveBatchState, loadBatchState, markBatchFinished } from "./persistence.js";
 import { averageDimensions } from "./evaluator-utils.js";
 import { runJudge } from "./evaluator-judge.js";
 export async function buildMatrix(variants, cases, opts) {
@@ -38,53 +36,30 @@ export async function buildMatrix(variants, cases, opts) {
             }
         }
     }
-    // Two execution paths:
-    //   batch=true  — submit every job to the provider batch API, poll, score
-    //                 results as they arrive. 50% cheaper, slower wall-clock.
-    //   batch=false — work-stealing pool: keep `concurrency` jobs in flight so
-    //                 a slow call doesn't block the others in its slice.
+    // Work-stealing pool: keep `concurrency` jobs in flight so a slow call
+    // doesn't block the others in its slice.
     const rawByKey = new Map();
-    const runOnlinePool = async () => {
-        let done = 0;
-        let next = 0;
-        const worker = async () => {
-            while (true) {
-                const i = next++;
-                if (i >= jobs.length)
-                    return;
-                const r = await runSingle(jobs[i], opts, transport);
-                const key = `${r.variantId}:${r.caseHash}:${r.model ?? ""}`;
-                const arr = rawByKey.get(key) ?? [];
-                arr.push(r);
-                rawByKey.set(key, arr);
-                done++;
-                opts.onProgress?.(done, jobs.length, r.caseName, r.variantId);
-            }
-        };
-        await Promise.all(Array.from({ length: Math.min(concurrency, jobs.length) }, worker));
-    };
-    if (opts.batch) {
-        try {
-            await runBatchPath(jobs, opts, rawByKey);
-        }
-        catch (err) {
-            // Batch submission failed (Kimi's /v1/files doesn't match OpenAI,
-            // OpenRouter has no batch at all, transient provider error, etc.).
-            // Fall back to the online pool so the whole run doesn't die — losing
-            // the 50% batch discount is better than losing the run.
-            const msg = err instanceof Error ? err.message : String(err);
-            opts.onBatchProgress?.(`batch path failed, falling back to online: ${msg.slice(0, 200)}`);
-            rawByKey.clear(); // discard any partial state
-            await runOnlinePool();
+    let done = 0;
+    let next = 0;
+    const worker = async () => {
+        while (true) {
+            const i = next++;
+            if (i >= jobs.length)
+                return;
+            const r = await runSingle(jobs[i], opts, transport);
+            const key = `${r.variantId}:${r.caseHash}:${r.model ?? ""}`;
+            const arr = rawByKey.get(key) ?? [];
+            arr.push(r);
+            rawByKey.set(key, arr);
+            done++;
+            opts.onProgress?.(done, jobs.length, r.caseName, r.variantId);
         }
-    }
-    else {
-        await runOnlinePool();
-    }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, jobs.length) }, worker));
     // Adaptive sampling: for cells where any score-dim σ exceeds threshold,
     // add one more rep and rerun — up to `cap` total reps. Converges on a
     // stable estimate without wasting reps on already-stable cells.
-    if (!opts.batch && opts.adaptiveReps) {
+    if (opts.adaptiveReps) {
         const cap = opts.adaptiveReps.cap;
         const threshold = opts.adaptiveReps.threshold ?? 0.1;
         for (let round = 0; round < cap - reps; round++) {
@@ -131,7 +106,7 @@ export async function buildMatrix(variants, cases, opts) {
     }
     // Optional llm-judge pass on top-N variants (by current heuristic content).
     if (opts.judge)
-        await runJudge(variants, cases, models, aggregated, opts.judge, opts);
+        await runJudge(variants, cases, models, aggregated, opts.judge);
     // Assemble rows: per-variant aggregate across all cases and models.
     const rows = [];
     for (const v of variants) {
@@ -244,81 +219,6 @@ function halfSplitMatrix(variants, cases, models, rawByKey, side) {
     scored.sort((a, b) => b.g - a.g);
     return scored.map((s) => s.id);
 }
-async function runBatchPath(jobs, opts, rawByKey) {
-    const provider = detectBatchProvider(opts.baseUrl);
-    if (provider === "unsupported") {
-        throw new Error(`Batch API not supported for baseUrl=${opts.baseUrl}; rerun without --batch or point at an Anthropic / OpenAI-compatible endpoint.`);
-    }
-    // Build custom_ids that route results back to the right cell. Index is
-    // included so reps of the same (variant, case, model) don't collide.
-    const keyed = jobs.map((job, i) => ({
-        job,
-        index: i,
-        customId: `v:${job.variantId}|h:${job.case.hash}|m:${job.model}|r:${job.rep}|i:${i}`,
-    }));
-    const batchJobs = keyed.map((k) => ({
-        customId: k.customId,
-        userText: k.job.text,
-        systemText: k.job.systemText,
-        model: k.job.model,
-    }));
-    const started = Date.now();
-    const existing = opts.runId != null && opts.generation != null
-        ? loadBatchState(opts.runId, opts.generation, "eval")
-        : null;
-    const transport = opts.batchCallModel ?? batchCallModel;
-    const results = await transport(batchJobs, {
-        baseUrl: opts.batchBaseUrl ?? opts.baseUrl,
-        authToken: opts.batchAuthToken ?? opts.authToken,
-        modelOverride: opts.batchModel,
-        maxTokens: opts.maxTokens,
-        resumeBatchId: existing?.batchId,
-        onSubmitted: (batchId, p) => {
-            if (opts.runId != null && opts.generation != null && !existing) {
-                saveBatchState(opts.runId, {
-                    generation: opts.generation,
-                    phase: "eval",
-                    batchId,
-                    provider: p,
-                    submittedAt: new Date().toISOString(),
-                });
-            }
-            opts.onBatchProgress?.(`batch submitted: ${batchId} (${p})`);
-        },
-        onProgress: (p) => {
-            if (p.phase === "polling") {
-                const ok = p.succeeded ?? 0;
-                const failed = p.failed ?? 0;
-                const total = p.total ?? batchJobs.length;
-                opts.onBatchProgress?.(`batch ${p.batchId} polling: ${ok}/${total} done${failed ? `, ${failed} failed` : ""}`);
-            }
-            else {
-                opts.onBatchProgress?.(`batch ${p.batchId} ${p.phase}`);
-            }
-        },
-    });
-    // Mark the state entry as finished so a crash after this point doesn't
-    // cause the next run to try resuming an already-consumed batch.
-    if (opts.runId != null && existing)
-        markBatchFinished(opts.runId, existing.batchId);
-    // Score each result and populate rawByKey the same way runSingle does.
-    const durationMs = Math.round((Date.now() - started) / Math.max(1, jobs.length));
-    let done = 0;
-    for (const k of keyed) {
-        const r = results.get(k.customId);
-        const raw = r?.raw ?? "batch returned no result for this custom_id";
-        const costUsd = r?.costUsd ?? 0;
-        const parsed = attemptJsonParse(raw);
-        const scored = scoreOutput(raw, parsed, costUsd, durationMs, k.job.case, { model: k.job.model });
-        scored.variantId = k.job.variantId;
-        const mapKey = `${scored.variantId}:${scored.caseHash}:${scored.model ?? ""}`;
-        const arr = rawByKey.get(mapKey) ?? [];
-        arr.push(scored);
-        rawByKey.set(mapKey, arr);
-        done++;
-        opts.onProgress?.(done, jobs.length, k.job.case.name, k.job.variantId);
-    }
-}
 async function runSingle(job, opts, transport) {
     const started = Date.now();
     const callOpts = {

package/dist/prompt-evolution/index.d.ts

@@ -54,14 +54,6 @@ export interface EvolveOpts {
     repetitions?: number;
     /** Max in-flight eval calls. Default 8. Raise for slow endpoints, lower for strict rate limits. */
     concurrency?: number;
-    /** Use provider batch API instead of online calls. 50% cheaper, slower wall-clock. */
-    batch?: boolean;
-    /** Override base URL for batch submissions only. */
-    batchBaseUrl?: string;
-    /** Override auth token for batch submissions only. */
-    batchAuthToken?: string;
-    /** Override model for batch submissions (e.g. kimi-k2.6 when online uses kimi-for-coding). */
-    batchModel?: string;
     /** Adaptive sampling cap (opt-in). Keeps adding reps to noisy cells up to this count. */
     adaptiveReps?: {
         cap: number;

package/dist/prompt-evolution/index.js

@@ -73,17 +73,10 @@ export async function evolvePrompt(opts) {
             concurrency: opts.concurrency ?? 8,
             repetitions: opts.repetitions,
             judge: opts.judge,
-            batch: opts.batch,
-            batchBaseUrl: opts.batchBaseUrl,
-            batchAuthToken: opts.batchAuthToken,
-            batchModel: opts.batchModel,
             adaptiveReps: opts.adaptiveReps,
-            runId,
-            generation: gen,
             onProgress: (done, total, caseName, variantId) => {
                 log(`  [${done}/${total}] ${variantId.slice(0, 16)} → ${caseName}`);
             },
-            onBatchProgress: (msg) => log(`  [batch] ${msg}`),
         };
         const matrix = await buildMatrix(population, trainCases, evalOpts);
         generationMatrices.push(matrix);
@@ -198,11 +191,7 @@ export async function evolvePrompt(opts) {
         concurrency: opts.concurrency ?? 8,
         repetitions: opts.repetitions,
         judge: opts.judge,
-        batch: opts.batch,
         adaptiveReps: opts.adaptiveReps,
-        runId,
-        generation: generations,
-        onBatchProgress: (msg) => log(`  [batch] ${msg}`),
     });
     generationMatrices.push(finalMatrix);
     snapshotPrompts(runId, finalMatrix);
@@ -222,14 +211,7 @@ export async function evolvePrompt(opts) {
             authToken: opts.authToken,
             concurrency: opts.concurrency ?? 8,
             repetitions: opts.repetitions,
-            batch: opts.batch,
-            batchBaseUrl: opts.batchBaseUrl,
-            batchAuthToken: opts.batchAuthToken,
-            batchModel: opts.batchModel,
             adaptiveReps: opts.adaptiveReps,
-            runId,
-            generation: generations + 1,
-            onBatchProgress: (msg) => log(`  [batch-test] ${msg}`),
         });
         log(formatMatrix(testMatrix, testCases.map((c) => c.name)));
     }

package/dist/prompt-evolution/persistence.d.ts

@@ -37,26 +37,6 @@ export declare function appendLearning(runId: string, entries: LearningEntry[]):
 export declare function snapshotPrompts(runId: string, rows: VariantRow[]): void;
 /** Finalise the run: write best.md and update meta.json. */
 export declare function finalizeRun(runId: string, result: EvolutionResult, metaPartial?: Partial<RunMeta>): void;
-/**
- * Persist batch submission state so a crashed or restarted run can resume
- * polling instead of resubmitting (which would duplicate the bill).
- *
- * Keyed by (generation, phase) so multi-generation runs and eval-vs-judge
- * submissions don't collide. Written append-only — the latest entry wins
- * on load.
- */
-export interface BatchStateEntry {
-    generation: number;
-    phase: "eval" | "judge";
-    batchId: string;
-    provider: "anthropic" | "openai-compatible";
-    submittedAt: string;
-    /** If set, we've already collected results for this entry — ignore on resume. */
-    finishedAt?: string;
-}
-export declare function saveBatchState(runId: string, entry: BatchStateEntry): void;
-export declare function loadBatchState(runId: string, generation: number, phase: "eval" | "judge"): BatchStateEntry | null;
-export declare function markBatchFinished(runId: string, batchId: string): void;
 /** List all runs, newest first. */
 export declare function listRuns(): Array<{
     runId: string;

package/dist/prompt-evolution/persistence.js

@@ -118,45 +118,6 @@ ${result.learningLog.map((l) => `| ${l.generation} | ${l.mutationSummary} | ${(l
 `;
     writeFileSync(join(root, "best.md"), report);
 }
-export function saveBatchState(runId, entry) {
-    const path = join(runDir(runId), "batch-jobs.jsonl");
-    writeFileSync(path, JSON.stringify(entry) + "\n", { flag: "a" });
-}
-export function loadBatchState(runId, generation, phase) {
-    const path = join(runDir(runId), "batch-jobs.jsonl");
-    if (!existsSync(path))
-        return null;
-    const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
-    let latest = null;
-    for (const line of lines) {
-        try {
-            const e = JSON.parse(line);
-            if (e.generation === generation && e.phase === phase)
-                latest = e;
-        }
-        catch { /* skip malformed */ }
-    }
-    // Only return if not yet finished — otherwise caller would re-poll a consumed batch.
-    return latest && !latest.finishedAt ? latest : null;
-}
-export function markBatchFinished(runId, batchId) {
-    const path = join(runDir(runId), "batch-jobs.jsonl");
-    if (!existsSync(path))
-        return;
-    const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
-    const updated = lines.map((line) => {
-        try {
-            const e = JSON.parse(line);
-            if (e.batchId === batchId && !e.finishedAt) {
-                e.finishedAt = new Date().toISOString();
-                return JSON.stringify(e);
-            }
-        }
-        catch { /* skip */ }
-        return line;
-    });
-    writeFileSync(path, updated.join("\n") + "\n");
-}
 /** List all runs, newest first. */
 export function listRuns() {
     const root = storeRoot();

package/dist/prompts/load.d.ts

@@ -1,3 +1,4 @@
+export declare const PROMPTS_ROOT: string;
 export type PromptVars = Record<string, string | number | boolean | undefined | null>;
 export interface RenderOpts {
     variant?: string;

package/dist/prompts/load.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 // Resolve <pkg>/prompts whether running from dist/ (installed) or src/ (dev).
-const PROMPTS_ROOT = (() => {
+export const PROMPTS_ROOT = (() => {
     const here = dirname(fileURLToPath(import.meta.url));
     for (const depth of [2, 3, 4]) {
         const candidate = join(here, ...Array(depth).fill(".."), "prompts");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.58.0",
+  "version": "1.60.0",
   "description": "Overnight parallel coding agents in git worktrees, with a self-curating skill memory that improves while the run is going. Mix Claude Opus as planner, Kimi 2.6 or Cursor composer-2 as cheap fast worker, Gemini or Qwen for bulk implementation. Multi-wave autonomous loop that plans, executes, reviews, and steers itself until the objective is met. Crash-safe resume, rate-limit aware, usage cap preserves headroom for your interactive Claude Code.",
   "type": "module",
   "bin": {

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.58.0",
+  "version": "1.60.0",
   "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs: overnight parallel coding agents in git worktrees with a self-curating skill memory, multi-wave steering, three-layer review, and crash-safe resume. Mix Opus planner with Kimi 2.6, Cursor composer-2, Gemini, Qwen, or any Anthropic-compatible worker.",
   "author": {
     "name": "Francesco Fornace"

package/dist/prompt-evolution/transport-batch.d.ts

@@ -1,62 +0,0 @@
-/**
- * Batch-API transport for prompt evolution.
- *
- * 50% cheaper than online calls on every major provider that supports
- * batch. Perfect fit for generations=1 benchmark rounds where interactive
- * progress isn't needed — we submit 120-1000 requests, poll every 30-300s,
- * then pull the results in one shot.
- *
- * Provider detection from baseUrl:
- *   - api.anthropic.com → Anthropic Message Batches API (one-shot submit)
- *   - kimi / moonshot / openai → OpenAI-compatible file-based batch
- *   - openrouter → NO batch support; throws (caller must fall back to online)
- *
- * Custom IDs route results back to the right (variant, case, model, rep)
- * cell. The evaluator builds ids like `v0:h_abc:kimi-for-coding:r0`.
- *
- * Poll state is persisted via `persistBatchState` so a crashed or
- * restarted run can resume without resubmitting.
- */
-import type { CallModelResult } from "./transport.js";
-export interface BatchJob {
-    customId: string;
-    userText: string;
-    systemText?: string;
-    model: string;
-}
-export interface BatchOpts {
-    baseUrl?: string;
-    authToken?: string;
-    /**
-     * Override model for the batch submission. Moonshot's batch API only
-     * accepts kimi-k2.5 or kimi-k2.6 — NOT the kimi-for-coding alias that the
-     * coding endpoint uses. When batch is enabled against a Kimi stack, set
-     * this so online eval keeps using kimi-for-coding while batch uses the
-     * concrete version.
-     */
-    modelOverride?: string;
-    maxTokens?: number;
-    /** Poll interval starts here and doubles to `pollMaxMs`. Defaults 30s → 5min. */
-    pollStartMs?: number;
-    pollMaxMs?: number;
-    /** Overall timeout for the whole batch. Default 24h — matches provider SLAs. */
-    batchTimeoutMs?: number;
-    /** Called with progress snapshots during polling. */
-    onProgress?: (p: BatchProgress) => void;
-    /** Restore a previously-submitted batch instead of resubmitting. */
-    resumeBatchId?: string;
-    /** Called after submit returns an id — use to persist for crash resume. */
-    onSubmitted?: (batchId: string, provider: BatchProvider) => void;
-}
-export interface BatchProgress {
-    provider: BatchProvider;
-    batchId: string;
-    phase: "submitted" | "polling" | "downloading" | "done";
-    processing?: number;
-    succeeded?: number;
-    failed?: number;
-    total?: number;
-}
-export type BatchProvider = "anthropic" | "openai-compatible" | "unsupported";
-export declare function detectBatchProvider(baseUrl: string | undefined): BatchProvider;
-export declare function batchCallModel(jobs: BatchJob[], opts: BatchOpts): Promise<Map<string, CallModelResult>>;

package/dist/prompt-evolution/transport-batch.js

@@ -1,235 +0,0 @@
-/**
- * Batch-API transport for prompt evolution.
- *
- * 50% cheaper than online calls on every major provider that supports
- * batch. Perfect fit for generations=1 benchmark rounds where interactive
- * progress isn't needed — we submit 120-1000 requests, poll every 30-300s,
- * then pull the results in one shot.
- *
- * Provider detection from baseUrl:
- *   - api.anthropic.com → Anthropic Message Batches API (one-shot submit)
- *   - kimi / moonshot / openai → OpenAI-compatible file-based batch
- *   - openrouter → NO batch support; throws (caller must fall back to online)
- *
- * Custom IDs route results back to the right (variant, case, model, rep)
- * cell. The evaluator builds ids like `v0:h_abc:kimi-for-coding:r0`.
- *
- * Poll state is persisted via `persistBatchState` so a crashed or
- * restarted run can resume without resubmitting.
- */
-import { VERSION } from "../core/_version.js";
-const USER_AGENT = `claude-overnight-evolve/${VERSION}`;
-export function detectBatchProvider(baseUrl) {
-    const url = (baseUrl ?? "https://api.anthropic.com").toLowerCase();
-    if (/(^|\/\/)(api\.)?anthropic\.com/.test(url))
-        return "anthropic";
-    // Providers with no batch support — caller auto-falls back to online.
-    // - OpenRouter: no batch API at all.
-    // - api.kimi.com/coding: Moonshot's coding-specific endpoint; synchronous
-    //   only (30 concurrent, 300-1200 req/5hr) with no /v1/files upload flow.
-    //   Moonshot's generic platform.moonshot.ai might have batch; this one
-    //   doesn't.
-    if (/openrouter/.test(url))
-        return "unsupported";
-    if (/(api\.)?kimi\.com\/coding/.test(url))
-        return "unsupported";
-    // Everything else that speaks /v1/chat/completions — OpenAI, DeepSeek,
-    // DashScope in OpenAI-compat mode — exposes an OpenAI-compatible batch
-    // endpoint we can ride.
-    return "openai-compatible";
-}
-export async function batchCallModel(jobs, opts) {
-    if (jobs.length === 0)
-        return new Map();
-    const provider = detectBatchProvider(opts.baseUrl);
-    if (provider === "unsupported") {
-        throw new Error(`Batch API not supported for baseUrl=${opts.baseUrl}. ` +
-            `Options: (1) omit --batch and use online transport, or (2) point ` +
-            `the batch call at a provider with batch support (e.g. set --batch-base-url ` +
-            `https://api.moonshot.ai/v1 --batch-model kimi-k2.6 for Kimi users whose ` +
-            `online endpoint is api.kimi.com/coding).`);
-    }
-    if (provider === "anthropic")
-        return runAnthropicBatch(jobs, opts);
-    return runOpenAIBatch(jobs, opts);
-}
-// ── Anthropic ──────────────────────────────────────────────────────────────
-async function runAnthropicBatch(jobs, opts) {
-    const baseUrl = (opts.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
-    const authToken = opts.authToken ?? process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.ANTHROPIC_API_KEY ?? "";
-    const headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${authToken}`,
-        "User-Agent": USER_AGENT,
-        "anthropic-version": "2023-06-01",
-        "anthropic-beta": "message-batches-2024-09-24",
-    };
-    let batchId = opts.resumeBatchId;
-    if (!batchId) {
-        const body = JSON.stringify({
-            requests: jobs.map((j) => {
-                const params = {
-                    model: opts.modelOverride ?? j.model,
-                    max_tokens: opts.maxTokens ?? 4096,
-                    messages: [{ role: "user", content: j.userText }],
-                };
-                if (j.systemText)
-                    params.system = j.systemText;
-                return { custom_id: j.customId, params };
-            }),
-        });
-        const res = await fetch(`${baseUrl}/v1/messages/batches`, { method: "POST", headers, body });
-        if (!res.ok)
-            throw new Error(`Anthropic batch submit: HTTP ${res.status} ${await res.text()}`);
-        const data = await res.json();
-        batchId = data.id;
-        opts.onSubmitted?.(batchId, "anthropic");
-    }
-    opts.onProgress?.({ provider: "anthropic", batchId, phase: "submitted", total: jobs.length });
-    const endedAt = await pollUntilDone(async () => {
-        const res = await fetch(`${baseUrl}/v1/messages/batches/${batchId}`, { headers });
-        if (!res.ok)
-            throw new Error(`Anthropic batch poll: HTTP ${res.status}`);
-        const d = await res.json();
-        opts.onProgress?.({
-            provider: "anthropic",
-            batchId: batchId,
-            phase: "polling",
-            processing: d.request_counts?.processing,
-            succeeded: d.request_counts?.succeeded,
-            failed: (d.request_counts?.errored ?? 0) + (d.request_counts?.canceled ?? 0) + (d.request_counts?.expired ?? 0),
-            total: jobs.length,
-        });
-        return d.processing_status === "ended" ? d : null;
-    }, opts);
-    opts.onProgress?.({ provider: "anthropic", batchId, phase: "downloading" });
-    const resultsUrl = endedAt.results_url ?? `${baseUrl}/v1/messages/batches/${batchId}/results`;
-    const res = await fetch(resultsUrl, { headers });
-    if (!res.ok)
-        throw new Error(`Anthropic batch results: HTTP ${res.status}`);
-    const text = await res.text();
-    const out = new Map();
-    for (const line of text.split("\n")) {
-        if (!line.trim())
-            continue;
-        const row = JSON.parse(line);
-        if (row.result.type === "succeeded") {
-            const raw = row.result.message.content.map((c) => c.text ?? "").join("");
-            const inp = row.result.message.usage?.input_tokens ?? 0;
-            const outp = row.result.message.usage?.output_tokens ?? 0;
-            out.set(row.custom_id, { raw, costUsd: (inp * 0.000003 + outp * 0.000015) * 0.5, inputTokens: inp, outputTokens: outp });
-        }
-        else {
-            const msg = row.result.type === "errored" ? row.result.error.message : row.result.type;
-            out.set(row.custom_id, { raw: `batch error: ${msg}`, costUsd: 0, inputTokens: 0, outputTokens: 0 });
-        }
-    }
-    opts.onProgress?.({ provider: "anthropic", batchId, phase: "done", succeeded: out.size, total: jobs.length });
-    return out;
-}
-// ── OpenAI-compatible (OpenAI, Kimi/Moonshot, DeepSeek) ────────────────────
-async function runOpenAIBatch(jobs, opts) {
-    const baseUrl = (opts.baseUrl ?? "https://api.openai.com").replace(/\/$/, "");
-    const authToken = opts.authToken ?? process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.ANTHROPIC_API_KEY ?? "";
-    const authHeaders = {
-        "Authorization": `Bearer ${authToken}`,
-        "User-Agent": USER_AGENT,
-    };
-    let batchId = opts.resumeBatchId;
-    let outputFileId;
-    if (!batchId) {
-        // Build the JSONL payload and upload as a file.
-        const jsonl = jobs.map((j) => {
-            const messages = [];
-            if (j.systemText)
-                messages.push({ role: "system", content: j.systemText });
-            messages.push({ role: "user", content: j.userText });
-            return JSON.stringify({
-                custom_id: j.customId,
-                method: "POST",
-                url: "/v1/chat/completions",
-                body: { model: opts.modelOverride ?? j.model, max_tokens: opts.maxTokens ?? 4096, max_completion_tokens: opts.maxTokens ?? 4096, messages },
-            });
-        }).join("\n");
-        const form = new FormData();
-        form.append("purpose", "batch");
-        form.append("file", new Blob([jsonl], { type: "application/jsonl" }), "batch-input.jsonl");
-        const fileRes = await fetch(`${baseUrl}/v1/files`, { method: "POST", headers: authHeaders, body: form });
-        if (!fileRes.ok) {
-            const body = await fileRes.text().catch(() => "");
-            throw new Error(`Batch file-upload failed: HTTP ${fileRes.status} at ${baseUrl}/v1/files. ` +
-                `This provider may not support OpenAI-compatible batch. Response: ${body.slice(0, 300)}`);
-        }
-        const fileData = await fileRes.json();
-        const createRes = await fetch(`${baseUrl}/v1/batches`, {
-            method: "POST",
-            headers: { ...authHeaders, "Content-Type": "application/json" },
-            body: JSON.stringify({ input_file_id: fileData.id, endpoint: "/v1/chat/completions", completion_window: "24h" }),
-        });
-        if (!createRes.ok)
-            throw new Error(`OpenAI-compat batch create: HTTP ${createRes.status} ${await createRes.text()}`);
-        const createData = await createRes.json();
-        batchId = createData.id;
-        opts.onSubmitted?.(batchId, "openai-compatible");
-    }
-    opts.onProgress?.({ provider: "openai-compatible", batchId, phase: "submitted", total: jobs.length });
-    const endedAt = await pollUntilDone(async () => {
-        const res = await fetch(`${baseUrl}/v1/batches/${batchId}`, { headers: authHeaders });
-        if (!res.ok)
-            throw new Error(`OpenAI-compat batch poll: HTTP ${res.status}`);
-        const d = await res.json();
-        opts.onProgress?.({
-            provider: "openai-compatible",
-            batchId: batchId,
-            phase: "polling",
-            succeeded: d.request_counts?.completed,
-            failed: d.request_counts?.failed,
-            total: d.request_counts?.total ?? jobs.length,
-        });
-        if (d.status === "completed")
-            return d;
-        if (d.status === "failed" || d.status === "expired" || d.status === "cancelled") {
-            throw new Error(`OpenAI-compat batch ${d.status}`);
-        }
-        return null;
-    }, opts);
-    outputFileId = endedAt.output_file_id;
-    if (!outputFileId)
-        throw new Error("OpenAI-compat batch completed with no output_file_id");
-    opts.onProgress?.({ provider: "openai-compatible", batchId, phase: "downloading" });
-    const contentRes = await fetch(`${baseUrl}/v1/files/${outputFileId}/content`, { headers: authHeaders });
-    if (!contentRes.ok)
-        throw new Error(`OpenAI-compat batch download: HTTP ${contentRes.status}`);
-    const text = await contentRes.text();
-    const out = new Map();
-    for (const line of text.split("\n")) {
-        if (!line.trim())
-            continue;
-        const row = JSON.parse(line);
-        if (row.error || !row.response) {
-            out.set(row.custom_id, { raw: `batch error: ${row.error?.message ?? "unknown"}`, costUsd: 0, inputTokens: 0, outputTokens: 0 });
-            continue;
-        }
-        const raw = row.response.body.choices?.[0]?.message?.content ?? "";
-        const inp = row.response.body.usage?.prompt_tokens ?? 0;
-        const outp = row.response.body.usage?.completion_tokens ?? 0;
-        out.set(row.custom_id, { raw, costUsd: (inp * 0.000003 + outp * 0.000015) * 0.5, inputTokens: inp, outputTokens: outp });
-    }
-    opts.onProgress?.({ provider: "openai-compatible", batchId, phase: "done", succeeded: out.size, total: jobs.length });
-    return out;
-}
-// ── Shared poll loop ───────────────────────────────────────────────────────
-async function pollUntilDone(check, opts) {
-    const start = Date.now();
-    const deadline = start + (opts.batchTimeoutMs ?? 24 * 60 * 60 * 1000);
-    let delay = opts.pollStartMs ?? 30_000;
-    const maxDelay = opts.pollMaxMs ?? 5 * 60_000;
-    while (Date.now() < deadline) {
-        const result = await check();
-        if (result != null)
-            return result;
-        await new Promise((r) => setTimeout(r, delay));
-        delay = Math.min(maxDelay, delay * 2);
-    }
-    throw new Error("Batch exceeded batchTimeoutMs without completing");
-}