@tangle-network/agent-bench 0.11.3 → 0.13.0

package/src/swe-arena/implementation-ref.ts

@@ -1,62 +0,0 @@
-import { createHash } from 'node:crypto'
-import { lstat, readFile, readdir, readlink, realpath } from 'node:fs/promises'
-import { join, relative } from 'node:path'
-import { canonicalCandidateDigest } from '@tangle-network/agent-interface'
-
-const sha256Content = (value: Uint8Array): string =>
-  `sha256:${createHash('sha256').update(value).digest('hex')}`
-
-export async function fileTreeImplementationRef(root: string): Promise<string> {
-  const canonicalRoot = await realpath(root)
-  const files: Array<{ path: string; sha256?: string; symlink?: string }> = []
-
-  const walk = async (directory: string): Promise<void> => {
-    const entries = await readdir(directory, { withFileTypes: true })
-    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
-    for (const entry of entries) {
-      const path = join(directory, entry.name)
-      const relativePath = relative(canonicalRoot, path)
-      if (entry.isDirectory()) {
-        await walk(path)
-      } else if (entry.isSymbolicLink()) {
-        files.push({ path: relativePath, symlink: await readlink(path) })
-      } else if (entry.isFile() || (await lstat(path)).isFile()) {
-        files.push({ path: relativePath, sha256: sha256Content(await readFile(path)) })
-      }
-    }
-  }
-
-  await walk(canonicalRoot)
-  return canonicalCandidateDigest(files)
-}
-
-export async function pythonDistributionImplementationRef(
-  distribution: string,
-  runPython: (script: string, args: string[]) => Promise<string>,
-): Promise<string> {
-  const output = await runPython(
-    [
-      'import hashlib, importlib, importlib.metadata, json, pathlib, sys',
-      'name = sys.argv[1]',
-      'module = importlib.import_module(name)',
-      'root = pathlib.Path(module.__file__).resolve().parent',
-      'files = []',
-      'for path in sorted(p for p in root.rglob("*") if p.is_file()):',
-      '    if "__pycache__" in path.parts or path.suffix == ".pyc":',
-      '        continue',
-      '    files.append({"path": str(path.relative_to(root)), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()})',
-      'try:',
-      '    version = importlib.metadata.version(name)',
-      'except importlib.metadata.PackageNotFoundError:',
-      '    version = None',
-      'print(json.dumps({"distribution": name, "version": version, "python": sys.version, "files": files}, sort_keys=True))',
-    ].join('\n'),
-    [distribution],
-  )
-  const line = output.trim().split('\n').at(-1)
-  if (line === undefined) {
-    throw new Error(`python distribution ${distribution} returned no implementation manifest`)
-  }
-  const manifest = JSON.parse(line) as unknown
-  return canonicalCandidateDigest(manifest)
-}

package/src/swe-arena/judge-child.mts

@@ -1,37 +0,0 @@
-/**
- * Judge child entrypoint — the experiment's `judge.mts`, tracked. One patch,
- * one official swebench verdict, printed as a single `JUDGE_RESULT {...}` line
- * that serialized-judge.ts parses. Runs as a CHILD process (not in-process) so
- * the judge ceiling can SIGKILL a hung swebench run without taking the
- * experiment down, exactly like the bash `timeout N node judge.mts`.
- *
- * usage: node --import tsx src/swe-arena/judge-child.mts <instance_id> <patchPath>
- */
-
-import { readFileSync } from 'node:fs'
-import { createSweBenchAdapter } from '../benchmarks/swe-bench.ts'
-
-const [, , iid, patchPath] = process.argv
-if (!iid || !patchPath) {
-  console.error('usage: node --import tsx judge-child.mts <instance_id> <patchPath>')
-  process.exit(2)
-}
-const patch = readFileSync(patchPath, 'utf8')
-const adapter = createSweBenchAdapter()
-const [task] = await adapter.loadTasks({ ids: [iid], split: 'test' })
-if (!task) {
-  console.log(JSON.stringify({ iid, error: 'no-task' }))
-  process.exit(2)
-}
-const t0 = Date.now()
-const score = await adapter.judge(task, patch)
-console.log(
-  'JUDGE_RESULT ' +
-    JSON.stringify({
-      iid,
-      resolved: score.resolved,
-      score: score.score,
-      secs: Math.round((Date.now() - t0) / 1000),
-      patch_bytes: patch.length,
-    }),
-)

package/src/swe-arena/ledger-orphans.mts

@@ -1,77 +0,0 @@
-/**
- * Crash-orphan reconciliation for the improve-run CostLedger.
- *
- * A killed outer-loop process leaves its in-flight paid call as a durable
- * 'pending' record with no receipt. On resume the ledger's fail-closed
- * admission guard ("N unresolved call(s) must be reconciled before new paid
- * work") then refuses EVERY new paid call, so a single crash permanently
- * blocks the run. This module settles those orphans at startup through the
- * ledger's dedicated crash-recovery verb, `CostLedger.reconcile()`.
- *
- * Safety contract — never settle a live run's call:
- *  - The caller must hold the outDir single-instance pid lock
- *    (`acquireInstanceLock` in outer-loop.mts) before invoking this, so no
- *    concurrent outer-loop shares the ledger file. Every pending record
- *    restored from disk is therefore from a dead process.
- *  - Belt and braces, only `state: 'interrupted'` pendings are touched:
- *    restored-from-persistence calls this process's ledger instance never
- *    started. An 'active'/'late' pending belongs to an in-flight
- *    `runPaidCall` and settles through its own path.
- *  - The ledger's persistence append is compare-and-swap on the file
- *    revision, so even an unexpected concurrent writer makes reconciliation
- *    fail loud (`CostCallConflictError`) instead of corrupting the log.
- *
- * The orphan settles as a FAILED receipt with zero usage and a fully-known
- * $0 actual cost (`actualCostUsd: 0`), reason 'process-crash-orphan'. A
- * `costUnknown`/`usageUnknown` receipt would be marginally more honest about
- * the crashed call's true spend, but an unknown-cost receipt marks the
- * ledger's accounting incomplete forever, which blocks all paid work in
- * capped runs — the same permanent lockout this module exists to fix.
- */
-
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import type { CostReceipt, PendingCostCallView } from '@tangle-network/agent-eval'
-import { createRunCostLedger, fsCampaignStorage } from '@tangle-network/agent-eval/campaign'
-
-export const CRASH_ORPHAN_REASON = 'process-crash-orphan'
-
-/** The two ledger verbs reconciliation needs, structural for testability. */
-export interface OrphanReconcilableLedger {
-  listPending(): PendingCostCallView[]
-  reconcile(
-    callId: string,
-    observed: {
-      model: string
-      inputTokens: number
-      outputTokens: number
-      actualCostUsd?: number
-    },
-    options?: { error?: string },
-  ): CostReceipt
-}
-
-/** Settle every crash-orphaned ('interrupted') pending call as a $0 failure. */
-export function reconcileCrashOrphanCalls(ledger: OrphanReconcilableLedger): CostReceipt[] {
-  return ledger
-    .listPending()
-    .filter((pending) => pending.state === 'interrupted')
-    .map((pending) =>
-      ledger.reconcile(
-        pending.callId,
-        { model: pending.model, inputTokens: 0, outputTokens: 0, actualCostUsd: 0 },
-        { error: CRASH_ORPHAN_REASON },
-      ),
-    )
-}
-
-/**
- * Open the durable ledger under `improveRunDir` and settle crash orphans.
- * No-op (empty result) when no ledger file exists yet — a fresh run.
- * PRECONDITION: the caller holds the outDir instance lock (see module doc).
- */
-export function reconcileCrashOrphansOnDisk(improveRunDir: string): CostReceipt[] {
-  if (!existsSync(join(improveRunDir, 'cost-ledger.jsonl'))) return []
-  const ledger = createRunCostLedger({ storage: fsCampaignStorage(), runDir: improveRunDir })
-  return reconcileCrashOrphanCalls(ledger)
-}

package/src/swe-arena/ledger-orphans.test.mts

@@ -1,149 +0,0 @@
-/**
- * Crash-orphan ledger reconciliation: a synthetic durable ledger with one
- * orphaned pending call (crashed process — call opened, no receipt) and one
- * resolved call. Reconciliation must settle ONLY the orphan, as a $0
- * failure receipt tagged 'process-crash-orphan', after which the ledger's
- * fail-closed admission guard passes new paid work again — the exact resume
- * path improve() rides.
- */
-
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { CostReceipt, PendingCostCallView } from '@tangle-network/agent-eval'
-import { createRunCostLedger, fsCampaignStorage } from '@tangle-network/agent-eval/campaign'
-import {
-  CRASH_ORPHAN_REASON,
-  reconcileCrashOrphanCalls,
-  reconcileCrashOrphansOnDisk,
-  type OrphanReconcilableLedger,
-} from './ledger-orphans.mts'
-
-const ATTRIBUTION = { channel: 'agent', phase: 'search.baseline', model: 'm' }
-
-/**
- * Write one settled receipt and then terminate a process with a real pending
- * call. The child uses the public ledger API so this fixture cannot shadow its
- * private JSONL event format.
- */
-function writeCrashedLedger(dir: string): void {
-  const child = `
-    import { createRunCostLedger, fsCampaignStorage } from '@tangle-network/agent-eval/campaign'
-    const runDir = process.env.COST_LEDGER_RUN_DIR
-    if (typeof runDir !== 'string' || runDir.length === 0) throw new Error('missing COST_LEDGER_RUN_DIR')
-    const attribution = { channel: 'agent', phase: 'search.baseline', model: 'm' }
-    const ledger = createRunCostLedger({ storage: fsCampaignStorage(), runDir })
-    await ledger.runPaidCall({
-      ...attribution,
-      callId: 'settled-1',
-      actor: 'worker:astropy#r0',
-      execute: async () => 'settled',
-      receipt: () => ({ model: 'm', inputTokens: 10, outputTokens: 5, actualCostUsd: 0.01 }),
-    })
-    let started
-    const pending = new Promise((resolve) => { started = resolve })
-    void ledger.runPaidCall({
-      ...attribution,
-      callId: 'orphan-1',
-      actor: 'worker:xarray#r0',
-      tags: { cellId: 'pydata__xarray-4687:0' },
-      execute: async () => { started(); return await new Promise(() => {}) },
-      receipt: () => ({ model: 'm', inputTokens: 0, outputTokens: 0, actualCostUsd: 0 }),
-    })
-    await pending
-  `
-  execFileSync(process.execPath, ['--input-type=module', '--eval', child], {
-    cwd: process.cwd(),
-    env: { ...process.env, COST_LEDGER_RUN_DIR: dir },
-  })
-}
-
-const openLedger = (dir: string) =>
-  createRunCostLedger({ storage: fsCampaignStorage(), runDir: dir })
-
-describe('reconcileCrashOrphansOnDisk', () => {
-  it('settles only the orphan, and the admission guard passes afterwards', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'ledger-orphans-'))
-    writeCrashedLedger(dir)
-
-    // The bug being fixed: with the orphan unresolved, ALL new paid work is refused.
-    const blocked = await openLedger(dir).runPaidCall({
-      ...ATTRIBUTION,
-      actor: 'worker:next',
-      execute: async () => 'ok',
-      receipt: () => ({ model: 'm', inputTokens: 1, outputTokens: 1, actualCostUsd: 0 }),
-    })
-    expect(blocked.succeeded).toBe(false)
-    if (!blocked.succeeded) {
-      expect(blocked.error.message).toContain('unresolved call(s) must be reconciled')
-    }
-
-    const receipts = reconcileCrashOrphansOnDisk(dir)
-    expect(receipts.map((r) => r.callId)).toEqual(['orphan-1'])
-    expect(receipts[0]).toMatchObject({
-      status: 'settled',
-      error: CRASH_ORPHAN_REASON,
-      inputTokens: 0,
-      outputTokens: 0,
-      costUsd: 0,
-      costUnknown: false,
-    })
-
-    // Durable: a fresh ledger instance sees zero unresolved calls, the
-    // settled call untouched, and admits new paid work again.
-    const reopened = openLedger(dir)
-    const summary = reopened.summary()
-    expect(summary.unresolvedCalls).toBe(0)
-    expect(summary.pendingCalls).toBe(0)
-    expect(summary.accountingComplete).toBe(true)
-    const settled = reopened.list().find((r) => r.callId === 'settled-1')
-    expect(settled?.costUsd).toBe(0.01)
-    expect(settled?.error).toBeUndefined()
-    const admitted = await reopened.runPaidCall({
-      ...ATTRIBUTION,
-      actor: 'worker:next',
-      execute: async () => 'ok',
-      receipt: () => ({ model: 'm', inputTokens: 1, outputTokens: 1, actualCostUsd: 0 }),
-    })
-    expect(admitted.succeeded).toBe(true)
-
-    // The durable log carries the orphan's failure receipt verbatim.
-    const persisted = readFileSync(join(dir, 'cost-ledger.jsonl'), 'utf8')
-    expect(persisted).toContain(CRASH_ORPHAN_REASON)
-  })
-
-  it('is idempotent — a second startup pass finds nothing to settle', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'ledger-orphans-'))
-    writeCrashedLedger(dir)
-    expect(reconcileCrashOrphansOnDisk(dir)).toHaveLength(1)
-    expect(reconcileCrashOrphansOnDisk(dir)).toHaveLength(0)
-  })
-
-  it('is a no-op on a fresh run dir with no ledger file', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'ledger-orphans-'))
-    expect(reconcileCrashOrphansOnDisk(dir)).toEqual([])
-  })
-})
-
-describe('reconcileCrashOrphanCalls', () => {
-  it("never settles a live in-process call — only 'interrupted' pendings", () => {
-    const base = { ...ATTRIBUTION, status: 'pending' as const, timestamp: 1 }
-    const pendings: PendingCostCallView[] = [
-      { ...base, callId: 'live-1', actor: 'a', state: 'active' },
-      { ...base, callId: 'late-1', actor: 'b', state: 'late' },
-      { ...base, callId: 'orphan-1', actor: 'c', state: 'interrupted' },
-    ]
-    const settled: string[] = []
-    const ledger: OrphanReconcilableLedger = {
-      listPending: () => pendings,
-      reconcile: (callId) => {
-        settled.push(callId)
-        return { callId } as CostReceipt
-      },
-    }
-    reconcileCrashOrphanCalls(ledger)
-    expect(settled).toEqual(['orphan-1'])
-  })
-})

package/src/swe-arena/manifest.mts

@@ -1,293 +0,0 @@
-/**
- * Rollout manifest — a pure READER/JOIN over what the round already writes.
- * No new capture pipeline: the lib's improve() run emits loop-provenance.json,
- * per-cell cached results, and the durable cost log; the swe-arena dispatch
- * emits arm result/judge files, candidate patches, and proposer-shot receipts.
- * This module joins them into one versioned per-generation manifest of
- * (state, action, outcome, cost, artifactPaths) triples.
- *
- *   tsx src/swe-arena/manifest.mts <outDir>   # writes <outDir>/rollout-manifest.json
- *
- * Sources (all optional — a missing file is a labeled gap, never a crash):
- *   - <outDir>/improve-run/loop-provenance.json            (lib)
- *   - <outDir>/improve-run/cost-ledger.jsonl               (lib, durable receipts)
- *   - <outDir>/improve-run/baseline and gen-N/candidate-K  (lib, per-cell caches)
- *   - <outDir>/candidates/<commit10>.patch                 (ours, diff writing)
- *   - <outDir>/proposer-shots/genN-candK-shotS.json        (ours, shot receipts)
- *   - per-cell artifact.runDir result.json + judge.json    (ours, arm + judge)
- */
-
-import { readdir, readFile, writeFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { pathToFileURL } from 'node:url'
-import {
-  loadCampaignCells,
-  loadCandidateCellGroups,
-  perInstanceFromCells,
-  replicateRunsFromCells,
-  resolvedInstanceCount,
-  sumWallSFromCells,
-  type EvidenceCell,
-  type StaircasePerInstance,
-} from './cell-evidence.mts'
-
-export const ROLLOUT_SCHEMA = 'swe-arena.rollout.v1'
-
-export interface RolloutCost {
-  /** Σ campaign-cell CostLedger spend (worker receipts) across the cells. */
-  cellCostUsd: number
-  cellTokensIn: number
-  cellTokensOut: number
-  /** Σ runtime spend-tree usd/tokens off the artifacts (telemetry-gap nulls skipped). */
-  armSpentUsd: number
-  armSpentTokens: number
-  wallS: number
-  judgeWallS: number
-  /** Durable cost-ledger receipts whose tags name this campaign dir. */
-  receiptCallIds: string[]
-}
-
-export interface RolloutEntry {
-  state: {
-    generation: number
-    /** -1 candidateIndex = the baseline campaign. */
-    candidateIndex: number
-    campaignDir: string
-    commit: string | null
-  }
-  action: {
-    /** Candidate diff written at dispatch time (null for the baseline / a
-     *  resumed-only run whose diff was not rewritten). */
-    diffPath: string | null
-    /** Persisted proposer-shot receipts for this (generation, candidate). */
-    shotReceiptPaths: string[]
-  }
-  outcome: {
-    perInstance: StaircasePerInstance[]
-    resolvedCount: number
-    cellsCached: number
-  }
-  cost: RolloutCost
-  artifactPaths: {
-    cells: string[]
-    armResults: string[]
-    judgeVerdicts: string[]
-    patches: string[]
-  }
-}
-
-export interface RolloutGeneration {
-  generation: number
-  rollouts: RolloutEntry[]
-}
-
-export interface RolloutManifest {
-  schema: typeof ROLLOUT_SCHEMA
-  outDir: string
-  at: string
-  /** The lib's durable provenance record, verbatim (null = not emitted). */
-  provenance: unknown | null
-  /** Improvement-set ids inferred from the baseline cells. */
-  instances: string[]
-  generations: RolloutGeneration[]
-}
-
-interface LedgerReceipt {
-  callId: string
-  tags?: Record<string, string>
-  [k: string]: unknown
-}
-
-/** Settled receipts out of the lib's append-only cost-ledger.jsonl. */
-export async function loadLedgerReceipts(improveRunDir: string): Promise<LedgerReceipt[]> {
-  const raw = await readFile(join(improveRunDir, 'cost-ledger.jsonl'), 'utf8').catch(() => '')
-  const receipts: LedgerReceipt[] = []
-  for (const line of raw.split('\n')) {
-    if (!line.trim()) continue
-    let event: Record<string, unknown>
-    try {
-      event = JSON.parse(line) as Record<string, unknown>
-    } catch {
-      continue
-    }
-    const record = event.record as Record<string, unknown> | undefined
-    if (record && record.status === 'settled' && typeof record.callId === 'string') {
-      receipts.push(record as unknown as LedgerReceipt)
-    }
-  }
-  return receipts
-}
-
-function costFromCells(
-  cells: EvidenceCell[],
-  campaignDir: string,
-  receipts: LedgerReceipt[],
-): RolloutCost {
-  let cellCostUsd = 0
-  let cellTokensIn = 0
-  let cellTokensOut = 0
-  let armSpentUsd = 0
-  let armSpentTokens = 0
-  let judgeWallS = 0
-  for (const cell of cells) {
-    cellCostUsd += cell.costUsd ?? 0
-    cellTokensIn += cell.tokenUsage?.input ?? 0
-    cellTokensOut += cell.tokenUsage?.output ?? 0
-    const a = cell.artifact
-    if (a !== null && a.kind === 'swe-arm') {
-      armSpentUsd += a.spentUsd ?? 0
-      armSpentTokens += a.spentTokens ?? 0
-      judgeWallS += a.judgeWallS ?? 0
-    }
-  }
-  return {
-    cellCostUsd: Number(cellCostUsd.toFixed(6)),
-    cellTokensIn,
-    cellTokensOut,
-    armSpentUsd: Number(armSpentUsd.toFixed(6)),
-    armSpentTokens,
-    wallS: sumWallSFromCells(cells),
-    judgeWallS,
-    receiptCallIds: receipts
-      .filter((r) => r.tags?.runDir === campaignDir)
-      .map((r) => r.callId)
-      .sort(),
-  }
-}
-
-function artifactPathsFromCells(cells: EvidenceCell[], campaignDir: string): RolloutEntry['artifactPaths'] {
-  const armResults: string[] = []
-  const judgeVerdicts: string[] = []
-  const patches: string[] = []
-  for (const cell of cells) {
-    const a = cell.artifact
-    if (a === null || a.kind !== 'swe-arm') continue
-    if (a.runDir) {
-      const resultPath = join(a.runDir, 'result.json')
-      const judgePath = join(a.runDir, 'judge.json')
-      if (existsSync(resultPath)) armResults.push(resultPath)
-      if (existsSync(judgePath)) judgeVerdicts.push(judgePath)
-    }
-    if (a.patchPath && existsSync(a.patchPath)) patches.push(a.patchPath)
-  }
-  return {
-    // The campaign dir holds the per-cell cached-result.json score records.
-    cells: cells.length > 0 ? [campaignDir] : [],
-    armResults: [...new Set(armResults)].sort(),
-    judgeVerdicts: [...new Set(judgeVerdicts)].sort(),
-    patches: [...new Set(patches)].sort(),
-  }
-}
-
-async function shotReceiptPathsFor(
-  outDir: string,
-  generation: number,
-  candidateIndex: number,
-): Promise<string[]> {
-  const shotDir = join(outDir, 'proposer-shots')
-  const names = await readdir(shotDir).catch(() => [])
-  return names
-    .filter((n) => n.startsWith(`gen${generation}-cand${candidateIndex}-`) && n.endsWith('.json'))
-    .sort()
-    .map((n) => join(shotDir, n))
-}
-
-/** Build the rollout manifest for one round outDir. Pure join — reads only. */
-export async function buildRolloutManifest(outDir: string): Promise<RolloutManifest> {
-  const improveRunDir = join(outDir, 'improve-run')
-  const provenanceRaw = await readFile(join(improveRunDir, 'loop-provenance.json'), 'utf8').catch(() => null)
-  const provenance = provenanceRaw === null ? null : (JSON.parse(provenanceRaw) as unknown)
-  const receipts = await loadLedgerReceipts(improveRunDir)
-
-  const baselineDir = join(improveRunDir, 'baseline')
-  const baselineCells = await loadCampaignCells(baselineDir)
-  const instances = [...new Set(baselineCells.map((c) => c.scenarioId))].sort()
-
-  const generations = new Map<number, RolloutGeneration>()
-  const genOf = (g: number): RolloutGeneration => {
-    const existing = generations.get(g)
-    if (existing) return existing
-    const fresh: RolloutGeneration = { generation: g, rollouts: [] }
-    generations.set(g, fresh)
-    return fresh
-  }
-
-  if (baselineCells.length > 0) {
-    genOf(-1).rollouts.push({
-      state: { generation: -1, candidateIndex: -1, campaignDir: baselineDir, commit: baselineCells[0]?.artifact?.commit ?? null },
-      action: { diffPath: null, shotReceiptPaths: [] },
-      outcome: {
-        perInstance: perInstanceFromCells(baselineCells),
-        resolvedCount: resolvedInstanceCount(
-          replicateRunsFromCells(baselineCells),
-          instances,
-          maxRep(baselineCells) + 1,
-        ),
-        cellsCached: baselineCells.length,
-      },
-      cost: costFromCells(baselineCells, baselineDir, receipts),
-      artifactPaths: artifactPathsFromCells(baselineCells, baselineDir),
-    })
-  }
-
-  for (const group of await loadCandidateCellGroups(improveRunDir)) {
-    const diffPath = group.commit ? join(outDir, 'candidates', `${group.commit.slice(0, 10)}.patch`) : null
-    genOf(group.generation).rollouts.push({
-      state: {
-        generation: group.generation,
-        candidateIndex: group.candidateIndex,
-        campaignDir: group.dir,
-        commit: group.commit,
-      },
-      action: {
-        diffPath: diffPath !== null && existsSync(diffPath) ? diffPath : null,
-        shotReceiptPaths: await shotReceiptPathsFor(outDir, group.generation, group.candidateIndex),
-      },
-      outcome: {
-        perInstance: perInstanceFromCells(group.cells),
-        resolvedCount: resolvedInstanceCount(
-          replicateRunsFromCells(group.cells),
-          instances,
-          maxRep(group.cells) + 1,
-        ),
-        cellsCached: group.cells.length,
-      },
-      cost: costFromCells(group.cells, group.dir, receipts),
-      artifactPaths: artifactPathsFromCells(group.cells, group.dir),
-    })
-  }
-
-  return {
-    schema: ROLLOUT_SCHEMA,
-    outDir,
-    at: new Date().toISOString(),
-    provenance,
-    instances,
-    generations: [...generations.values()].sort((a, b) => a.generation - b.generation),
-  }
-}
-
-/** Replicate count inferred from the cells themselves (reps = max rep index
- *  + 1). The manifest is a reader with no config in scope; an incomplete
- *  candidate under-infers reps and its resolvedCount stays fail-closed. */
-const maxRep = (cells: EvidenceCell[]): number => cells.reduce((m, c) => Math.max(m, c.rep), 0)
-
-export async function writeRolloutManifest(outDir: string): Promise<string> {
-  const manifest = await buildRolloutManifest(outDir)
-  const path = join(outDir, 'rollout-manifest.json')
-  await writeFile(path, JSON.stringify(manifest, null, 2))
-  return path
-}
-
-const isMain = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href
-
-if (isMain) {
-  const outDir = process.argv[2]
-  if (!outDir) {
-    console.error('usage: tsx src/swe-arena/manifest.mts <outDir>')
-    process.exit(2)
-  }
-  const path = await writeRolloutManifest(outDir)
-  console.log(`rollout manifest → ${path}`)
-}