@tangle-network/agent-bench 0.11.2 → 0.13.0

package/src/swe-arena/parity.test.mts

@@ -1,87 +0,0 @@
-/**
- * PARITY GATE for M2: the typed execution path (materialize → patch apply →
- * extractPatch → serialized-judge → official swebench verdict) must reproduce
- * the pinned M1 fixture verdicts for two committed arm patches — one resolved
- * (pallets__flask-5014 SOLO), one unresolved (pydata__xarray-4687 SUP) —
- * WITHOUT executing any arm. Zero model tokens; docker time only (it pulls the
- * two instance images if absent and runs the official judge, ~5-25 min each).
- *
- * Opt-in because of that docker cost:
- *
- *   SWE_ARENA_PARITY=1 ../node_modules/.bin/vitest run src/swe-arena/parity.test.mts
- *
- * Expected verdicts are DERIVED from the pinned fixtures (ledger + rejudge
- * reconciliation), not hardcoded — parity means agreeing with the record.
- *
- * TODO(operator approval): the full 12-instance ARM parity re-run (typed path
- * vs the bash harness on the same 12 ids, both arms) costs ~$1 model spend +
- * ~4h wall. Do not run without an explicit operator go — this 2-patch gate is
- * the milestone check.
- */
-
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { loadLedger, loadRejudge } from './fixtures.ts'
-import { reconcile } from './reconcile.ts'
-import { createSerializedJudge } from './serialized-judge.ts'
-import { PARITY_CASES, replayPatchParity, type ParityCaseResult } from './run-experiment.mts'
-
-const RUN_PARITY = process.env.SWE_ARENA_PARITY === '1'
-// materialize + image pull + official judge, twice; generous but finite.
-const PARITY_BUDGET_MS = 5_400_000
-
-describe.runIf(RUN_PARITY)('dry-run parity vs pinned M1 verdicts (docker, no tokens)', () => {
-  let results: ParityCaseResult[] = []
-  let workDir = ''
-
-  beforeAll(async () => {
-    workDir = await mkdtemp(join(tmpdir(), 'swe-arena-parity-'))
-    const judge = createSerializedJudge() // real judge child, 1800s ceiling, serialized
-    results = await replayPatchParity(PARITY_CASES, { workDir, judge })
-    for (const r of results) {
-      console.log(`PARITY ${r.iid} [${r.arm}] verdict=${JSON.stringify(r.verdict)}`)
-    }
-  }, PARITY_BUDGET_MS)
-
-  afterAll(async () => {
-    if (workDir) await rm(workDir, { recursive: true, force: true })
-  })
-
-  it('re-extraction preserves each committed patch’s changed-file set', () => {
-    expect(results).toHaveLength(2)
-    for (const r of results) {
-      expect(r.applyRc).toBe(0)
-      expect(r.extractedFiles, `${r.iid} [${r.arm}]`).toEqual(r.fixtureFiles)
-      expect(r.extractedPatchLines).toBeGreaterThan(0)
-    }
-  })
-
-  it('pallets__flask-5014 SOLO: typed judge verdict == pinned ledger verdict (resolved)', () => {
-    const pinned = loadLedger().find((r) => r.iid === 'pallets__flask-5014')
-    expect(pinned?.solo_resolved).toBe(true) // sanity: the fixture side of the parity claim
-    const r = results.find((x) => x.iid === 'pallets__flask-5014')
-    expect(r?.verdict.attempts).toBeGreaterThan(0)
-    expect(r?.verdict.resolved).toBe(pinned?.solo_resolved)
-  })
-
-  it('pydata__xarray-4687 SUP: typed judge verdict == reconciled verdict (unresolved)', () => {
-    // The authoritative record for this arm is the personal re-judge
-    // (sup-final), which M1's reconciliation applies over the ledger.
-    const reconciled = reconcile(loadLedger(), loadRejudge()).valid.find(
-      (r) => r.iid === 'pydata__xarray-4687',
-    )
-    expect(reconciled?.sup.source).toBe('sup-final')
-    expect(reconciled?.sup.resolved).toBe(false)
-    const r = results.find((x) => x.iid === 'pydata__xarray-4687')
-    expect(r?.verdict.attempts).toBeGreaterThan(0)
-    expect(r?.verdict.resolved).toBe(reconciled?.sup.resolved)
-  })
-})
-
-describe.runIf(!RUN_PARITY)('dry-run parity (skipped)', () => {
-  it('is opt-in: set SWE_ARENA_PARITY=1 to run the docker-backed parity gate', () => {
-    expect(RUN_PARITY).toBe(false)
-  })
-})

package/src/swe-arena/premeasured-from-cells.mts

@@ -1,296 +0,0 @@
-/**
- * Premeasured-baseline artifact builder — reconstruct the lib's
- * `PremeasuredOptimizationBaseline` ({surfaceHash, campaign}) from a PRIOR
- * run's on-disk baseline campaign cells.
- *
- * Why this exists: the gen-3 run (r4-mrwc0awe) measured the full 6-instance ×
- * 2-rep baseline but never wrote the artifact — its bootstrap writer keyed on
- * the Pareto frontier's generation −1 entry, and the frontier the lib returned
- * held no such entry, so the measurement survives ONLY as per-cell
- * `cached-result.json` caches under `<gen3>/improve-run/baseline/`. Those
- * caches cannot be replayed into a NEW runDir: the lib's cache-hit path
- * requires every `costCallIds` receipt in the CURRENT run's ledger (tagged
- * with the current runDir), which a fresh outDir cannot satisfy. The
- * premeasured-artifact path has no such coupling — `validatedPremeasuredBaseline`
- * checks surface hash, seed, reps, and split digest, then uses the campaign
- * as-is — so rebuilding the artifact is the designed way to pin a prior run's
- * measured baseline.
- *
- * Everything identity-bearing is REAL, never fabricated:
- *   - cells: verbatim `cached-result.json` records (verdicts, spend, receipts);
- *   - surfaceHash: recomputed from the loops repo's base-ref tip (identical
- *     incumbent surface shape the lib builds: baseCommit == candidateCommit,
- *     empty patch) — verified equal to gen-3's recorded baseline hash;
- *   - splitDigest/scenarios: the lib's own `campaignSplitDigest` /
- *     `campaignScenarioIdentity` over the exact scenario payloads;
- *   - seed/manifestHash: carried from the cells, uniformity asserted;
- *   - run window: reconstructed from cache-file mtimes (endedAt = last cell
- *     write; startedAt = earliest write minus that cell's duration).
- *
- *   tsx src/swe-arena/premeasured-from-cells.mts <config.json> --from <priorBaselineDir>
- */
-
-import { createHash } from 'node:crypto'
-import { readdir, readFile, stat, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import process from 'node:process'
-import { pathToFileURL } from 'node:url'
-import {
-  assertCampaignSplitIdentity,
-  campaignScenarioIdentity,
-  campaignSplitDigest,
-  surfaceHash,
-  type CampaignCellResult,
-  type CampaignResult,
-  type CodeSurface,
-  type PremeasuredOptimizationBaseline,
-  type Scenario,
-} from '@tangle-network/agent-eval/campaign'
-import type { R4Artifact } from './cell-evidence.mts'
-import type { OuterLoopConfig } from './outer-loop.mts'
-import { runOk } from './proc.ts'
-
-export type FullCell = CampaignCellResult<R4Artifact> & { mtimeMs?: number }
-
-/** Read every `<dir>/<cell>/cached-result.json` as a FULL lib cell record. */
-export async function loadFullCampaignCells(campaignDir: string): Promise<FullCell[]> {
-  const entries = await readdir(campaignDir, { withFileTypes: true })
-  const cells: FullCell[] = []
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    const path = join(campaignDir, entry.name, 'cached-result.json')
-    const raw = await readFile(path, 'utf8').catch(() => null)
-    if (raw === null) continue
-    const cell = JSON.parse(raw) as FullCell
-    if (typeof cell.scenarioId !== 'string' || typeof cell.rep !== 'number') {
-      throw new Error(`premeasured-from-cells: ${path} is not a campaign cell`)
-    }
-    cell.mtimeMs = (await stat(path)).mtimeMs
-    cells.push(cell)
-  }
-  return cells
-}
-
-/** The incumbent surface hash the lib will compute for `baseRef`'s tip: an
- *  unchanged code surface (candidate == base, empty patch). Identity material
- *  is {baseCommit, baseTree, candidateTree, patch} — worktree/ref excluded. */
-export async function incumbentSurfaceHash(loopsRepo: string, baseRef: string): Promise<string> {
-  const baseCommit = (await runOk('git', ['-C', loopsRepo, 'rev-parse', `${baseRef}^{commit}`])).stdout.trim()
-  const tree = (await runOk('git', ['-C', loopsRepo, 'rev-parse', `${baseRef}^{tree}`])).stdout.trim()
-  const surface: CodeSurface = {
-    kind: 'code',
-    worktreeRef: loopsRepo,
-    baseRef,
-    baseCommit,
-    baseTree: tree,
-    candidateCommit: baseCommit,
-    candidateTree: tree,
-    patch: {
-      format: 'git-diff-binary',
-      sha256: `sha256:${createHash('sha256').update(Buffer.alloc(0)).digest('hex')}`,
-      byteLength: 0,
-    },
-  }
-  return surfaceHash(surface)
-}
-
-function meanStdCi(values: number[]): { mean: number; stdev: number; ci95: [number, number]; n: number } {
-  const n = values.length
-  const mean = n === 0 ? 0 : values.reduce((s, v) => s + v, 0) / n
-  const variance = n <= 1 ? 0 : values.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1)
-  const stdev = Math.sqrt(variance)
-  const half = n === 0 ? 0 : (1.96 * stdev) / Math.sqrt(n)
-  return { mean, stdev, ci95: [mean - half, mean + half], n }
-}
-
-/** Assemble the artifact from full cells. Pure over inputs; every check fails
- *  loud so a wrong artifact can never validate downstream by accident. */
-export function buildPremeasuredFromCells(input: {
-  cells: FullCell[]
-  instances: string[]
-  reps: number
-  surfaceHash: string
-  /** Provenance label recorded as the campaign's runDir (the SOURCE dir). */
-  sourceDir: string
-}): PremeasuredOptimizationBaseline<R4Artifact, Scenario> {
-  const { cells, instances, reps } = input
-  if (cells.length === 0) throw new Error('premeasured-from-cells: no cells')
-  for (const iid of instances) {
-    for (let rep = 0; rep < reps; rep++) {
-      const mine = cells.filter((c) => c.scenarioId === iid && c.rep === rep)
-      if (mine.length !== 1) {
-        throw new Error(`premeasured-from-cells: expected exactly 1 cell for ${iid} rep ${rep}, got ${mine.length}`)
-      }
-    }
-  }
-  const extras = cells.filter((c) => !instances.includes(c.scenarioId) || c.rep >= reps)
-  if (extras.length > 0) {
-    throw new Error(
-      `premeasured-from-cells: ${extras.length} cell(s) outside the ${instances.length}x${reps} design ` +
-        `(e.g. ${extras[0]!.scenarioId}#r${extras[0]!.rep})`,
-    )
-  }
-  // Per-cell seeds derive from the campaign base seed (run-campaign:
-  // `cellSeed = seed + groupIndex * reps + rep`), so a complete design carries
-  // the contiguous range [base, base + cells). The campaign-level seed the lib
-  // validates is the base.
-  const seeds = cells.map((c) => c.seed).sort((a, b) => a - b)
-  const baseSeed = seeds[0]!
-  for (let i = 0; i < seeds.length; i++) {
-    if (seeds[i] !== baseSeed + i) {
-      throw new Error(
-        `premeasured-from-cells: cell seeds are not the contiguous derived range from base ${baseSeed} ` +
-          `(got ${seeds.join(', ')})`,
-      )
-    }
-  }
-  const manifests = new Set(cells.map((c) => c.manifestHash ?? 'absent'))
-  if (manifests.size !== 1) {
-    throw new Error(`premeasured-from-cells: non-uniform manifestHash across cells (${[...manifests].join(', ')})`)
-  }
-  for (const cell of cells) {
-    if (cell.error !== undefined) throw new Error(`premeasured-from-cells: cell ${cell.cellId} carries an error`)
-    if (cell.artifact === null || cell.artifact.kind !== 'swe-arm') {
-      throw new Error(`premeasured-from-cells: cell ${cell.cellId} has no swe-arm artifact`)
-    }
-    if (cell.costProvenance.kind === 'uncaptured') {
-      throw new Error(`premeasured-from-cells: cell ${cell.cellId} has uncaptured cost`)
-    }
-    if (
-      cell.costProvenance.usd !== cell.costUsd
-    ) {
-      throw new Error(
-        `premeasured-from-cells: cell ${cell.cellId} cost provenance does not match costUsd`,
-      )
-    }
-  }
-
-  const scenarios: Scenario[] = instances.map((iid) => ({ id: iid, kind: 'swe-instance' }))
-  const splitDigest = campaignSplitDigest(scenarios, reps)
-  const identities = scenarios.map((s) => campaignScenarioIdentity(s))
-  assertCampaignSplitIdentity(identities, reps, splitDigest)
-
-  const sorted = [...cells].sort(
-    (a, b) => instances.indexOf(a.scenarioId) - instances.indexOf(b.scenarioId) || a.rep - b.rep,
-  )
-  const composites = (cell: FullCell): number[] => Object.values(cell.judgeScores).map((s) => s.composite)
-  const judgeNames = [...new Set(sorted.flatMap((c) => Object.keys(c.judgeScores)))]
-  const byJudge = Object.fromEntries(
-    judgeNames.map((name) => {
-      const { mean, stdev, ci95, n } = meanStdCi(
-        sorted.filter((c) => c.judgeScores[name]).map((c) => c.judgeScores[name]!.composite),
-      )
-      return [name, { mean, stdev, ci95, n }]
-    }),
-  )
-  const byScenario = Object.fromEntries(
-    instances.map((iid) => {
-      const { mean, ci95, n } = meanStdCi(sorted.filter((c) => c.scenarioId === iid).flatMap(composites))
-      return [iid, { meanComposite: mean, ci95, n }]
-    }),
-  )
-  const totalCostUsd = sorted.reduce((s, c) => s + c.costUsd, 0)
-  const costProvenance: CampaignCellResult<R4Artifact>['costProvenance'] = sorted.some(
-    (cell) => cell.costProvenance.kind === 'estimated',
-  )
-    ? { kind: 'estimated', usd: totalCostUsd }
-    : { kind: 'observed', usd: totalCostUsd }
-  const inputTokens = sorted.reduce((s, c) => s + c.tokenUsage.input, 0)
-  const outputTokens = sorted.reduce((s, c) => s + c.tokenUsage.output, 0)
-  const totalCalls = sorted.reduce((s, c) => s + (c.costCallIds?.length ?? 0), 0)
-  const models = [...new Set(sorted.map((c) => c.resolvedModel).filter((m): m is string => typeof m === 'string'))]
-
-  const mtimes = sorted.filter((c) => typeof c.mtimeMs === 'number')
-  const endedMs = mtimes.length > 0 ? Math.max(...mtimes.map((c) => c.mtimeMs!)) : 0
-  const startedMs = mtimes.length > 0 ? Math.min(...mtimes.map((c) => c.mtimeMs! - c.durationMs)) : 0
-
-  const campaign: CampaignResult<R4Artifact, Scenario> = {
-    manifestHash: sorted[0]!.manifestHash ?? '',
-    splitDigest,
-    seed: baseSeed,
-    reps,
-    startedAt: new Date(startedMs).toISOString(),
-    endedAt: new Date(endedMs).toISOString(),
-    durationMs: Math.max(0, endedMs - startedMs),
-    // Verbatim prior-run cells (marked cached — they were measured, and this
-    // artifact replays them without dispatch). The transient mtime rider is
-    // dropped from the persisted record.
-    cells: sorted.map(({ mtimeMs: _mtimeMs, ...cell }) => ({ ...cell, cached: true })),
-    aggregates: {
-      byJudge,
-      byScenario,
-      cost: {
-        totalCalls,
-        pendingCalls: 0,
-        unresolvedCalls: 0,
-        reservedCostUsd: 0,
-        inputTokens,
-        outputTokens,
-        cachedTokens: 0,
-        totalCostUsd,
-        costProvenance,
-        byChannel: [
-          {
-            channel: 'agent',
-            calls: totalCalls,
-            inputTokens,
-            outputTokens,
-            cachedTokens: 0,
-            costUsd: totalCostUsd,
-            unpricedCalls: 0,
-            unknownUsageCalls: 0,
-          },
-        ],
-        unpricedModels: [],
-        fullyPriced: true,
-        usageComplete: true,
-        accountingComplete: true,
-        incompleteReasons: [],
-      },
-      cellsExecuted: sorted.length,
-      cellsSkipped: 0,
-      cellsCached: sorted.length,
-      cellsFailed: 0,
-    },
-    runDir: input.sourceDir,
-    artifactsByPath: {},
-    scenarios: identities,
-  }
-  void models
-  return { surfaceHash: input.surfaceHash, campaign }
-}
-
-// ---------------------------------------------------------------------------
-// CLI.
-// ---------------------------------------------------------------------------
-
-const isMain = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href
-
-if (isMain) {
-  const argv = process.argv.slice(2)
-  const configPath = argv[0]
-  const fromIdx = argv.indexOf('--from')
-  const fromDir = fromIdx !== -1 ? argv[fromIdx + 1] : undefined
-  if (!configPath || configPath.startsWith('--') || !fromDir) {
-    console.error('usage: tsx src/swe-arena/premeasured-from-cells.mts <config.json> --from <priorBaselineCampaignDir>')
-    process.exit(2)
-  }
-  const config = JSON.parse(await readFile(configPath, 'utf8')) as OuterLoopConfig
-  const reps = config.repsPerInstance ?? 1
-  const cells = await loadFullCampaignCells(fromDir)
-  const hash = await incumbentSurfaceHash(config.loopsRepo, config.loopsBaseRef)
-  const artifact = buildPremeasuredFromCells({
-    cells,
-    instances: config.instances,
-    reps,
-    surfaceHash: hash,
-    sourceDir: fromDir,
-  })
-  await writeFile(config.premeasuredBaselinePath, JSON.stringify(artifact, null, 1))
-  const resolved = artifact.campaign.cells.map(
-    (c) => `${c.scenarioId}#r${c.rep}=${(c.artifact as R4Artifact).resolved}`,
-  )
-  console.log(`premeasured baseline artifact → ${config.premeasuredBaselinePath}`)
-  console.log(`surfaceHash=${hash} splitDigest=${artifact.campaign.splitDigest} seed=${artifact.campaign.seed} reps=${reps}`)
-  console.log(resolved.join('\n'))
-}

package/src/swe-arena/premeasured-from-cells.test.mts

@@ -1,201 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { campaignSplitDigest, assertCampaignSplitIdentity, type Scenario } from '@tangle-network/agent-eval/campaign'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { cellsFromCampaign, replicateRunsFromCells, resolvedInstanceCount } from './cell-evidence.mts'
-import type { R4Artifact } from './cell-evidence.mts'
-import {
-  buildPremeasuredFromCells,
-  incumbentSurfaceHash,
-  loadFullCampaignCells,
-  type FullCell,
-} from './premeasured-from-cells.mts'
-import { runOk } from './proc.ts'
-
-const artifact = (iid: string, resolved: boolean): R4Artifact => ({
-  kind: 'swe-arm',
-  iid,
-  commit: 'c0ffee',
-  resolved,
-  verifyPass: resolved,
-  patchLines: 3,
-  wallS: 100,
-  spentTokens: 10,
-  spentUsd: 0.01,
-  recoveredTokens: 20,
-  workerTokIn: 5,
-  workerTokOut: 5,
-  judgeAttempts: 1,
-  judgeWallS: 9,
-  runDir: '/runs/x',
-  patchPath: '/patches/x.patch',
-})
-
-// Per-cell seeds mirror run-campaign's derivation: base 42 + groupIndex*reps + rep.
-const derivedSeed = (iid: string, rep: number): number => 42 + (iid === 'inst-a' ? 0 : 2) + rep
-
-const cell = (iid: string, rep: number, resolved: boolean, over: Partial<FullCell> = {}): FullCell => ({
-  manifestHash: 'm1',
-  cellId: `${iid}:${rep}`,
-  scenarioId: iid,
-  rep,
-  artifact: artifact(iid, resolved),
-  judgeScores: {
-    'swe-arena-official-judge': {
-      composite: resolved ? 1 : 0,
-      dimensions: { resolved: resolved ? 1 : 0 },
-      notes: `official judge: ${iid} resolved=${resolved}`,
-    },
-  },
-  costUsd: 0.05,
-  costProvenance: { kind: 'observed', usd: 0.05 },
-  costCallIds: [`call-${iid}-${rep}`],
-  tokenUsage: { input: 100, output: 50 },
-  resolvedModel: 'zai-coding-plan/glm-5.2',
-  durationMs: 60_000,
-  seed: derivedSeed(iid, rep),
-  cached: false,
-  mtimeMs: 1_000_000 + rep * 1000,
-  ...over,
-})
-
-const INSTANCES = ['inst-a', 'inst-b']
-
-describe('buildPremeasuredFromCells', () => {
-  const cells = [cell('inst-a', 0, false), cell('inst-a', 1, true), cell('inst-b', 0, true), cell('inst-b', 1, true)]
-
-  it('assembles a campaign whose split identity passes the lib validation checks', () => {
-    const out = buildPremeasuredFromCells({
-      cells,
-      instances: INSTANCES,
-      reps: 2,
-      surfaceHash: 'abc123',
-      sourceDir: '/prior/baseline',
-    })
-    expect(out.surfaceHash).toBe('abc123')
-    const scenarios: Scenario[] = INSTANCES.map((id) => ({ id, kind: 'swe-instance' }))
-    // The exact checks validatedPremeasuredBaseline runs (minus surface):
-    expect(out.campaign.reps).toBe(2)
-    expect(out.campaign.seed).toBe(42)
-    expect(out.campaign.splitDigest).toBe(campaignSplitDigest(scenarios, 2))
-    expect(() => assertCampaignSplitIdentity(out.campaign.scenarios, 2, out.campaign.splitDigest)).not.toThrow()
-    // Cells replay verbatim into the harness scoring (AND rule: a=F, b=T → 1/2).
-    const evidence = cellsFromCampaign(out.campaign)
-    expect(resolvedInstanceCount(replicateRunsFromCells(evidence), INSTANCES, 2)).toBe(1)
-    expect(out.campaign.cells.every((c) => c.cached)).toBe(true)
-    expect(out.campaign.cells.every((c) => !('mtimeMs' in c))).toBe(true)
-    // Honest spend rollup from the real cells.
-    expect(out.campaign.aggregates.cost.totalCostUsd).toBeCloseTo(0.2)
-    expect(out.campaign.aggregates.cost.costProvenance).toEqual({
-      kind: 'observed',
-      usd: 0.2,
-    })
-    expect(out.campaign.aggregates.cost.inputTokens).toBe(400)
-    expect(out.campaign.runDir).toBe('/prior/baseline')
-    // Window reconstructed from mtimes: ends at the last cell write.
-    expect(out.campaign.endedAt).toBe(new Date(1_001_000).toISOString())
-  })
-
-  it('fails loud on a missing replicate, an extra cell, or a design mismatch', () => {
-    expect(() =>
-      buildPremeasuredFromCells({
-        cells: cells.slice(0, 3),
-        instances: INSTANCES,
-        reps: 2,
-        surfaceHash: 'x',
-        sourceDir: '/p',
-      }),
-    ).toThrow(/expected exactly 1 cell for inst-b rep 1/)
-    expect(() =>
-      buildPremeasuredFromCells({
-        cells: [...cells, cell('inst-c', 0, true)],
-        instances: INSTANCES,
-        reps: 2,
-        surfaceHash: 'x',
-        sourceDir: '/p',
-      }),
-    ).toThrow(/outside the 2x2 design/)
-  })
-
-  it('fails loud on broken seed derivation or manifest drift, an errored cell, or a missing artifact', () => {
-    const seedDrift = [cell('inst-a', 0, false, { seed: 7 }), cell('inst-a', 1, true), cell('inst-b', 0, true), cell('inst-b', 1, true)]
-    expect(() =>
-      buildPremeasuredFromCells({ cells: seedDrift, instances: INSTANCES, reps: 2, surfaceHash: 'x', sourceDir: '/p' }),
-    ).toThrow(/contiguous derived range/)
-    const manifestDrift = [cell('inst-a', 0, false, { manifestHash: 'OTHER' }), cell('inst-a', 1, true), cell('inst-b', 0, true), cell('inst-b', 1, true)]
-    expect(() =>
-      buildPremeasuredFromCells({ cells: manifestDrift, instances: INSTANCES, reps: 2, surfaceHash: 'x', sourceDir: '/p' }),
-    ).toThrow(/non-uniform manifestHash/)
-    const errored = [cell('inst-a', 0, false, { error: 'boom' }), cell('inst-a', 1, true), cell('inst-b', 0, true), cell('inst-b', 1, true)]
-    expect(() =>
-      buildPremeasuredFromCells({ cells: errored, instances: INSTANCES, reps: 2, surfaceHash: 'x', sourceDir: '/p' }),
-    ).toThrow(/carries an error/)
-    const uncapturedCost = [
-      cell('inst-a', 0, false, { costProvenance: { kind: 'uncaptured', usd: null } }),
-      cell('inst-a', 1, true),
-      cell('inst-b', 0, true),
-      cell('inst-b', 1, true),
-    ]
-    expect(() =>
-      buildPremeasuredFromCells({
-        cells: uncapturedCost,
-        instances: INSTANCES,
-        reps: 2,
-        surfaceHash: 'x',
-        sourceDir: '/p',
-      }),
-    ).toThrow(/has uncaptured cost/)
-  })
-})
-
-describe('loadFullCampaignCells + incumbentSurfaceHash (real fs/git)', () => {
-  let dir: string
-  let repo: string
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'premeasured-'))
-    repo = await mkdtemp(join(tmpdir(), 'premeasured-repo-'))
-  })
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true })
-    await rm(repo, { recursive: true, force: true })
-  })
-
-  it('round-trips full cells (costCallIds and manifest preserved) from disk', async () => {
-    const c = cell('inst-a', 0, true)
-    await mkdir(join(dir, 'inst-a_0'), { recursive: true })
-    const { mtimeMs: _m, ...persisted } = c
-    await writeFile(join(dir, 'inst-a_0', 'cached-result.json'), JSON.stringify(persisted))
-    const loaded = await loadFullCampaignCells(dir)
-    expect(loaded).toHaveLength(1)
-    expect(loaded[0]).toMatchObject({
-      scenarioId: 'inst-a',
-      rep: 0,
-      manifestHash: 'm1',
-      costCallIds: ['call-inst-a-0'],
-      seed: 42,
-    })
-    expect(typeof loaded[0]!.mtimeMs).toBe('number')
-  })
-
-  it('computes the same incumbent hash for the unchanged tip (baseCommit == candidateCommit, empty patch)', async () => {
-    await runOk('git', ['init', '-q', '-b', 'main', repo])
-    await runOk('git', ['-C', repo, 'config', 'core.hooksPath', '/dev/null'])
-    await runOk('git', ['-C', repo, 'config', 'user.email', 't@t.dev'])
-    await runOk('git', ['-C', repo, 'config', 'user.name', 'T'])
-    await writeFile(join(repo, 'a.txt'), 'x\n')
-    await runOk('git', ['-C', repo, 'add', '-A'])
-    await runOk('git', ['-C', repo, 'commit', '-q', '-m', 'init'])
-    const h1 = await incumbentSurfaceHash(repo, 'main')
-    const h2 = await incumbentSurfaceHash(repo, 'main')
-    expect(h1).toBe(h2)
-    expect(h1).toMatch(/^[0-9a-f]{16}$/)
-    // A moved tip changes the hash — the fail-loud property the artifact rides.
-    await writeFile(join(repo, 'a.txt'), 'y\n')
-    await runOk('git', ['-C', repo, 'add', '-A'])
-    await runOk('git', ['-C', repo, 'commit', '-q', '-m', 'move'])
-    expect(await incumbentSurfaceHash(repo, 'main')).not.toBe(h1)
-  })
-})