@tangle-network/agent-bench 0.3.8 → 0.4.1

package/src/swe-arena/implementation-ref.test.mts

@@ -0,0 +1,64 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  fileTreeImplementationRef,
+  pythonDistributionImplementationRef,
+} from './implementation-ref.ts'
+
+describe('implementation refs', () => {
+  const roots: string[] = []
+
+  afterEach(async () => {
+    await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+  })
+
+  it('is stable across creation order and changes with file content or symlink targets', async () => {
+    const first = await mkdtemp(join(tmpdir(), 'implementation-ref-a-'))
+    const second = await mkdtemp(join(tmpdir(), 'implementation-ref-b-'))
+    roots.push(first, second)
+    await mkdir(join(first, 'nested'))
+    await writeFile(join(first, 'nested', 'b.ts'), 'export const b = 2\n')
+    await writeFile(join(first, 'a.ts'), 'export const a = 1\n')
+    await symlink('a.ts', join(first, 'entry.ts'))
+    await writeFile(join(second, 'a.ts'), 'export const a = 1\n')
+    await symlink('a.ts', join(second, 'entry.ts'))
+    await mkdir(join(second, 'nested'))
+    await writeFile(join(second, 'nested', 'b.ts'), 'export const b = 2\n')
+
+    const initial = await fileTreeImplementationRef(first)
+    expect(await fileTreeImplementationRef(second)).toBe(initial)
+
+    await writeFile(join(second, 'nested', 'b.ts'), 'export const b = 3\n')
+    expect(await fileTreeImplementationRef(second)).not.toBe(initial)
+    await writeFile(join(second, 'nested', 'b.ts'), 'export const b = 2\n')
+    await rm(join(second, 'entry.ts'))
+    await symlink('nested/b.ts', join(second, 'entry.ts'))
+    expect(await fileTreeImplementationRef(second)).not.toBe(initial)
+  })
+
+  it('binds a Python distribution to its complete manifest', async () => {
+    const runPython = async (_script: string, args: string[]): Promise<string> =>
+      `import warning\n${JSON.stringify({
+        distribution: args[0],
+        version: '1.0.0',
+        python: '3.12.4',
+        files: [{ path: '__init__.py', sha256: 'a'.repeat(64) }],
+      })}`
+    const original = await pythonDistributionImplementationRef('swebench', runPython)
+    const changed = await pythonDistributionImplementationRef(
+      'swebench',
+      async (_script, args) =>
+        JSON.stringify({
+          distribution: args[0],
+          version: '1.0.1',
+          python: '3.12.4',
+          files: [{ path: '__init__.py', sha256: 'b'.repeat(64) }],
+        }),
+    )
+
+    expect(original).toMatch(/^sha256:[a-f0-9]{64}$/)
+    expect(changed).not.toBe(original)
+  })
+})

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

@@ -0,0 +1,62 @@
+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/outer-loop.mts

@@ -17,7 +17,7 @@
  *      `rawTraceDistiller` path-context so the coding agent also greps the raw
  *      traces itself (`rawTraceContext: true` names the mechanism; an explicit
  *      `analyzeGeneration` wins, so the distiller is composed in directly).
- *  (b) PROPOSE — `improvementDriver` + a change-space-constrained
+ *  (b) PROPOSE — Runtime's code candidate driver + a change-space-constrained
  *      `agenticGenerator` edit an isolated git worktree of loops. The DECLARED
  *      CHANGE-SPACE is enforced twice: in the generator's verifier (feedback →
  *      next shot) and fail-closed in the dispatch below (an out-of-space
@@ -72,6 +72,7 @@ import {
   type Verifier,
 } from '@tangle-network/agent-runtime'
 import { runLocalHarness } from '@tangle-network/agent-runtime/mcp'
+import { canonicalCandidateDigest } from '@tangle-network/agent-interface'
 import { makeFinding } from '@tangle-network/agent-eval'
 import {
   FsLabeledScenarioStore,
@@ -85,7 +86,12 @@ import {
   type Scenario,
 } from '@tangle-network/agent-eval/campaign'
 import type { CostLedgerHandle } from '@tangle-network/agent-eval'
+import { runVenvPython } from '../benchmarks/_harness.ts'
 import { createSweBenchAdapter } from '../benchmarks/swe-bench.ts'
+import {
+  fileTreeImplementationRef,
+  pythonDistributionImplementationRef,
+} from './implementation-ref.ts'
 import {
   baselineDriftWarnings,
   cellsFromCampaign,
@@ -152,7 +158,6 @@ import {
   type ScoreSplit,
   type ScoreSplitConfig,
 } from './score-split.mts'
-import { recordLineageGeneration, type LineageCandidateInput } from './lineage-record.mts'
 import {
   reportSupervisorRound,
   writeSupervisorRunReportSafe,
@@ -644,7 +649,7 @@ export interface OuterLoopConfig {
    *  When set, `populationSize` MUST equal `proposers.length` (one candidate
    *  slot per proposer — enforced at launch). Unset = the legacy
    *  single-author generator (`proposerHarness` + bare invocation).
-   *  GEN-6: a spec with `engine` set is a GEPA seat (gepa-seat.mts) — the
+   *  A spec with `engine` set is a GEPA seat (gepa-seat.mts); the
    *  agent-eval external-GEPA adapter optimizes ONE change-space file as a
    *  string against the pre-filter smoke cell; requires `prefilter.enabled`. */
   proposers?: ProposerSpec[]
@@ -685,10 +690,6 @@ export interface OuterLoopConfig {
    *  emit tangle.rollout.v1 lines live after each cell judges, with label-v2
    *  rewards. Default path: <outDir>/rollout-ledger.jsonl. */
   rolloutLedger?: { enabled: boolean; path?: string; opencodeDb?: string }
-  /** GEN-5 lineage DAG (lineage-record.mts): record every candidate as a
-   *  LineageNode at <outDir>/.evolve/lineage.jsonl and put the governor's
-   *  continuation decision in the round summary. */
-  lineage?: boolean
   /** GEN-5 evidence map: prior run outDirs whose arm-runs/judge/candidate
    *  evidence the authors may mine (rendered into the evidence index). */
   priorEvidenceDirs?: string[]
@@ -970,9 +971,6 @@ export function defaultGen4Config(
 //     never-fired mechanisms are quarantined even on an improved score.
 //  4. SETTLE-TIME ROLLOUT LEDGER — tangle.rollout.v1 lines live per cell,
 //     label v2 (contribution-aware workers, baseline-relative proposers).
-//  5. LINEAGE DAG — agent-eval Lineage at <outDir>/.evolve/lineage.jsonl +
-//     governor continuation decision in the round summary; staircase rows
-//     unchanged (observatory contract).
 // ---------------------------------------------------------------------------
 
 export function defaultGen5Config(
@@ -989,7 +987,6 @@ export function defaultGen5Config(
     briefing: AUTHOR_BRIEFING_VERSION,
     activationGate: true,
     rolloutLedger: { enabled: true },
-    lineage: true,
     priorEvidenceDirs: [join(hh, 'gen4'), join(hh, 'gen3')],
   }
 }
@@ -1537,11 +1534,24 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
   const smokeRunner: SmokeRunner | undefined =
     smokeIid === null
       ? undefined
-      : async ({ scratchPath, generation, proposer, costLedger }): Promise<SmokeVerdict> => {
+      : async ({
+          scratchPath,
+          generation,
+          proposer,
+          evaluationKey,
+          costLedger,
+        }): Promise<SmokeVerdict> => {
           const iid = smokeIid
+          if (!/^[a-zA-Z0-9_-]+$/.test(evaluationKey)) {
+            throw new Error(`outer-loop: invalid smoke evaluation key ${JSON.stringify(evaluationKey)}`)
+          }
           const requireResolved = config.prefilter?.requireResolved === true
           const entry = images[iid]!
-          const armOutDir = join(config.outDir, 'prefilter-smoke', `gen${generation}-${proposer.name}`)
+          const armOutDir = join(
+            config.outDir,
+            'prefilter-smoke',
+            `gen${generation}-${proposer.name}-${evaluationKey}`,
+          )
           const nm = join(scratchPath, 'node_modules')
           let linked = false
           const t0 = Date.now()
@@ -1600,7 +1610,7 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
               const paid = await costLedger.runPaidCall({
                 channel: 'agent',
                 phase: 'search.prefilter',
-                actor: `prefilter-smoke:${iid}:g${generation}:${proposer.name}`,
+                actor: `prefilter-smoke:${iid}:g${generation}:${proposer.name}:${evaluationKey}`,
                 model: config.arm.workerModel,
                 execute: runWork,
                 receipt: ({ armRes }) => {
@@ -1636,7 +1646,7 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
               resolved: outcome.resolved,
               patchLines: outcome.armRes.patch_lines,
               wallS,
-              // GEN-6: the GEPA seat's inner-score tiebreak.
+              // The GEPA seat's inner-score tiebreak.
               verifyPass: outcome.armRes.verify_pass,
             }
             await mkdir(armOutDir, { recursive: true })
@@ -1661,6 +1671,79 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
           }
         }
 
+  let runnerImplementationRef: string | undefined
+  let judgeImplementationRef: string | undefined
+  const hasGepaSeat = config.proposers?.some((proposer) => proposer.engine !== undefined) === true
+  if (hasGepaSeat && smokeIid !== null && smokeRunner !== undefined) {
+    const runtimeRoot = fileURLToPath(new URL('../../..', import.meta.url))
+    const benchRoot = fileURLToPath(new URL('../..', import.meta.url))
+    const sourceCommit = (
+      await runOk('git', ['-C', config.loopsRepo, 'rev-parse', 'HEAD'])
+    ).stdout.trim()
+    const entry = images[smokeIid]!
+    const verifyScript = await readFile(join(config.verifyDir, `${smokeIid}.sh`), 'utf8')
+    const implementationArtifacts = {
+      benchSource: await fileTreeImplementationRef(join(benchRoot, 'src')),
+      runtimeSource: await fileTreeImplementationRef(join(runtimeRoot, 'src')),
+      runtimeDist: await fileTreeImplementationRef(join(runtimeRoot, 'dist')),
+      packageFiles: canonicalCandidateDigest({
+        runtimePackage: await readFile(join(runtimeRoot, 'package.json'), 'utf8'),
+        benchPackage: await readFile(join(benchRoot, 'package.json'), 'utf8'),
+        lockfile: await readFile(join(runtimeRoot, 'pnpm-lock.yaml'), 'utf8'),
+      }),
+      swebench: await pythonDistributionImplementationRef(
+        'swebench',
+        (script, args) => runVenvPython(script, args),
+      ),
+    }
+    const runnerSourceRef = canonicalCandidateDigest({
+      benchSource: implementationArtifacts.benchSource,
+      runtimeSource: implementationArtifacts.runtimeSource,
+      runtimeDist: implementationArtifacts.runtimeDist,
+      packageFiles: implementationArtifacts.packageFiles,
+    })
+    const judgeSourceRef = canonicalCandidateDigest({
+      benchSource: implementationArtifacts.benchSource,
+      packageFiles: implementationArtifacts.packageFiles,
+      swebench: implementationArtifacts.swebench,
+    })
+    runnerImplementationRef = canonicalCandidateDigest({
+      implementation: 'swe-arena-smoke-runner',
+      sourceCommit,
+      sourceRef: runnerSourceRef,
+      smoke: {
+        iid: smokeIid,
+        image: entry.image,
+        baseCommit: entry.base_commit,
+        problemStatement: problemById.get(smokeIid)!,
+        verifyScript,
+        requireResolved: config.prefilter?.requireResolved === true,
+      },
+      arm: {
+        name: config.armName,
+        workerModel: config.arm.workerModel,
+        driverModel: config.arm.driverModel,
+        budget: config.arm.budget,
+        maxSandboxes: config.arm.maxSandboxes,
+        maxUsd: config.arm.maxUsd,
+        maxDepth: config.arm.maxDepth,
+        timeoutMs: config.arm.timeoutMs,
+        envKnobs: config.arm.envKnobs ?? null,
+      },
+      dispatchTimeoutMs: config.dispatchTimeoutMs,
+      capacityModel: config.capacityModel ?? null,
+      gateWaitCeilingMs: config.gateWaitCeilingMs ?? null,
+      excludes,
+    })
+    judgeImplementationRef = canonicalCandidateDigest({
+      implementation: 'serialized-swebench-judge',
+      sourceCommit,
+      sourceRef: judgeSourceRef,
+      timeoutMs: config.judgeTimeoutMs ?? JUDGE_TIMEOUT_FLOOR_MS,
+      cacheLevel: 'instance',
+    })
+  }
+
   // ── dispatch: one (surface × scenario) cell ──────────────────────────
   const agent = async (surface: MutableSurface, scenario: Scenario, ctx: DispatchContext): Promise<R4Artifact> => {
     const cs = asCodeSurface(surface)
@@ -2041,9 +2124,11 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
     config.proposers !== undefined
       ? fanOutLoopsGenerator(config, {
           ...(smokeRunner ? { smokeRunner } : {}),
+          ...(runnerImplementationRef ? { runnerImplementationRef } : {}),
+          ...(judgeImplementationRef ? { judgeImplementationRef } : {}),
           ...(paretoParents.length > 0 ? { parents: paretoParents } : {}),
           ...(briefingCtx !== undefined ? { briefing: briefingCtx } : {}),
-          // GEN-6: the GEPA seat's inner evaluator rides the SAME public-only
+          // The GEPA seat's inner evaluator uses the same public-only
           // smoke instance; the split guards the never-surfaced invariant at
           // the bridge boundary too.
           ...(smokeIid !== null ? { smokeInstanceId: smokeIid } : {}),
@@ -2056,10 +2141,9 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
   // ── the improve() call: the optimizer seat ───────────────────────────
   // Typed from improve()'s own parameter: the monorepo hoists two
   // agent-interface majors, so a nominal import can resolve to the wrong one.
-  const profile = { name: 'loops-pi-supervisor' } as Parameters<typeof improve>[0]
   signal?.throwIfAborted()
   log(`round ${config.round} runId=${runId}: improve(surface:'code') over ${config.loopsRepo}@${config.loopsBaseRef}`)
-  const result = await improve<Scenario, R4Artifact>(profile, [], {
+  const result = await improve<Scenario, R4Artifact>({
     surface: 'code',
     // analyzeGeneration wins over this flag; the composite above embeds
     // rawTraceDistiller directly so the raw-trace mechanism stays active.
@@ -2143,10 +2227,8 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
       }
     }
 
-    // Collected per-candidate facts for the gen-5 machinery (activation by
-    // surface hash for the winner brief, lineage nodes, proposer v2 rewards).
+    // Collected per-candidate facts for activation and proposer rewards.
     const activationBySurface = new Map<string, ActivationRecord>()
-    const lineageCandidates: LineageCandidateInput[] = []
     interface ProposerOutcomeFact {
       generation: number
       candidateIndex: number
@@ -2290,14 +2372,6 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
         })
 
         const label = cand.label ?? cs?.candidateCommit?.slice(0, 10) ?? cand.surfaceHash.slice(0, 10)
-        lineageCandidates.push({
-          label,
-          commit: cs?.candidateCommit ?? null,
-          resolvedCount: candResolved,
-          verdicts,
-          merge: config.proposers?.find((p) => p.name === cand.label)?.merge === true,
-          verdict,
-        })
         proposerFacts.push({
           generation: g,
           candidateIndex: candIndex,
@@ -2386,42 +2460,6 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
       }
     }
 
-    // GEN-5 lineage DAG: record baseline root + pareto parents + every
-    // evaluated candidate (multi-parent for the merge seat) at the
-    // .evolve-compatible store, and ask the governor for the continuation
-    // decision (recorded below — never acted on inside this run).
-    let lineageResult: Awaited<ReturnType<typeof recordLineageGeneration>> | null = null
-    if (config.lineage === true) {
-      try {
-        const baselineCommit =
-          baselineCells.find((c) => c.artifact !== null && c.artifact.kind === 'swe-arm')?.artifact?.commit ??
-          config.loopsBaseRef
-        lineageResult = await recordLineageGeneration({
-          outDir: config.outDir,
-          runId,
-          instances: config.instances,
-          baseline: {
-            commit: baselineCommit,
-            resolvedCount: measuredBaselineCount,
-            verdicts: instanceVerdictsFromCells(baselineCells, config.instances, reps),
-          },
-          paretoParents: (config.paretoParents ?? []).map((p) => ({
-            label: p.label,
-            commit: p.commit,
-            resolvedInstances: p.resolvedInstances,
-          })),
-          candidates: lineageCandidates,
-        })
-        log(
-          `lineage: ${lineageResult.appended.length} node(s) appended (total ${lineageResult.nodesTotal}) → ` +
-            `${lineageResult.path}; governor decision: ${JSON.stringify(lineageResult.governor)}` +
-            `${lineageResult.skipped.length > 0 ? `; skipped (no commit): ${lineageResult.skipped.join(', ')}` : ''}`,
-        )
-      } catch (cause) {
-        log(`lineage: recording FAILED: ${(cause as Error).message}`)
-      }
-    }
-
     const winnerSurface = result.raw.winner.surface
     const winnerCs =
       typeof winnerSurface === 'object' && winnerSurface !== null && winnerSurface.kind === 'code'
@@ -2547,17 +2585,6 @@ export async function runRound(config: OuterLoopConfig, signal?: AbortSignal): P
           : { version: AUTHOR_BRIEFING_VERSION, indexPath: briefingCtx.indexPath, textSource: briefingCtx.briefingSource },
       // GEN-5: settle-time rollout ledger location (tangle.rollout.v1, label v2).
       rolloutLedger: settleCapture === null ? null : { path: settleCapture.path, capture: 'settle-time', labels: 'v2' },
-      // GEN-5: lineage DAG + the governor's recorded continuation decision.
-      lineage:
-        lineageResult === null
-          ? null
-          : {
-              path: lineageResult.path,
-              nodesTotal: lineageResult.nodesTotal,
-              appended: lineageResult.appended.length,
-              skipped: lineageResult.skipped,
-              governor: lineageResult.governor,
-            },
       // Honest run-wide spend from the lib's CostLedger: per-channel rollups
       // (agent = arm cells, judge = official-judge calls, driver = proposer
       // shots), token totals, and accounting-completeness flags.

package/src/swe-arena/proposer-fanout.mts

@@ -64,9 +64,20 @@ import {
   parseActivationPredicate,
 } from './activation.mts'
 import { briefingPromptSection, type BriefingContext } from './briefing.mts'
-import { gepaSeatAuthor, isGepaSeat, validateGepaSeat, type GepaMethodFactory } from './gepa-seat.mts'
+import {
+  gepaSeatAuthor,
+  isGepaSeat,
+  validateGepaSeat,
+  type GepaMethodFactory,
+  type GepaSeatDeps,
+} from './gepa-seat.mts'
 import type { ScoreSplit } from './score-split.mts'
 import { run, runOk } from './proc.ts'
+import {
+  createDetachedWorktree,
+  pruneDetachedWorktrees,
+  removeDetachedWorktree,
+} from './scratch-worktree.ts'
 
 // ---------------------------------------------------------------------------
 // Config types.
@@ -78,7 +89,7 @@ export interface ProposerSpec {
   /** Path to an `AgentProfile` JSON. Absolute, or relative to this module's
    *  `profiles/` directory. Omitted = bare profile (legacy invocation). */
   profile?: string
-  /** Required for harness-authored seats. ABSENT on a GEN-6 engine seat
+  /** Required for harness-authored seats. Absent on an engine seat
    *  (`engine` set) — enforced both ways at generator construction. */
   harness?: 'claude' | 'codex' | 'opencode'
   /** GEN-4 pinned model id, threaded to the harness CLI as `-m <model>` via
@@ -98,21 +109,20 @@ export interface ProposerSpec {
   /** Which diagnosis findings this proposer sees. Protocol/steering and
    *  raw-trace-context findings always pass through. Default 'all'. */
   diagnosisSlice?: 'all' | 'mechanics' | 'prompts'
-  /** GEN-6 GEPA seat: this seat is an ENGINE invocation (agent-eval's
+  /** GEPA seat: this seat is an engine invocation (agent-eval's
    *  external-GEPA adapter), not a harness CLI. `gepa` = one bounded engine
-   *  run; `omni` = GEPA's published best-of-then-continue shape. Validation +
+   *  run; `omni` = GEPA's official Omni recipe. Validation +
    *  authoring live in gepa-seat.mts. */
   engine?: 'gepa' | 'omni'
-  /** GEN-6 GEPA seat: the ONE repo-relative change-space file GEPA optimizes
+  /** GEPA seat: the one repo-relative change-space file GEPA optimizes
    *  as a string; the rest of the loops repo stays at the incumbent commit. */
   surface?: string
-  /** GEN-6 GEPA seat: total inner-evaluation budget (each inner call is one
+  /** GEPA seat: total inner-evaluation budget (each inner call is one
    *  real smoke arm cell). Default 10. */
   maxMetricCalls?: number
-  /** GEN-6 GEPA seat: requested GEPA proposer spend cap in USD (the adapter
-   *  reports GEPA's own model/CLI spend without an agent-eval receipt). */
+  /** GEPA seat: hard cap for metered optimizer-model spend. */
   maxProposerCostUsd?: number
-  /** GEN-6 GEPA seat: python executable for the bridge. Default 'python3'. */
+  /** GEPA seat: Python executable for the bridge. Default 'python3'. */
   python?: string
 }
 
@@ -137,8 +147,8 @@ export interface SmokeVerdict {
   resolved: boolean | null
   patchLines: number
   wallS: number
-  /** Committed verify fixture passed (GEN-6: the GEPA seat's inner-score
-   *  tiebreak). Absent on errored smokes and pre-gen-6 records. */
+  /** Committed verify fixture passed, used as the GEPA seat's inner-score
+   *  tiebreak. Absent on errored smokes and older records. */
   verifyPass?: boolean
 }
 
@@ -146,6 +156,7 @@ export type SmokeRunner = (args: {
   scratchPath: string
   generation: number
   proposer: ProposerSpec
+  evaluationKey: string
   costLedger?: CostLedgerHandle
 }) => Promise<SmokeVerdict>
 
@@ -437,21 +448,6 @@ export function proposerShotHooks(opts: {
 // smoke runner link one in temporarily when they need it).
 // ---------------------------------------------------------------------------
 
-async function addAuthoringWorktree(loopsRepo: string, commit: string, dest: string): Promise<void> {
-  await run('git', ['-C', loopsRepo, 'worktree', 'remove', '--force', '--', dest])
-  await rm(dest, { recursive: true, force: true })
-  await run('git', ['-C', loopsRepo, 'worktree', 'prune'])
-  await runOk('git', ['-C', loopsRepo, 'worktree', 'add', '--detach', dest, commit])
-}
-
-async function removeAuthoringWorktree(loopsRepo: string, dest: string): Promise<void> {
-  const res = await run('git', ['-C', loopsRepo, 'worktree', 'remove', '--force', '--', dest])
-  if (res.code !== 0) {
-    await rm(dest, { recursive: true, force: true })
-    await run('git', ['-C', loopsRepo, 'worktree', 'prune'])
-  }
-}
-
 const sanitize = (s: string): string => s.replace(/[^a-zA-Z0-9_-]/g, '_')
 
 // ---------------------------------------------------------------------------
@@ -480,21 +476,26 @@ export type AuthorFn = (
 export interface FanOutDeps {
   author?: AuthorFn
   smokeRunner?: SmokeRunner
+  /** Immutable digest of the smoke runner plus every captured execution input. */
+  runnerImplementationRef?: string
+  /** Immutable digest of the official judge implementation and configuration. */
+  judgeImplementationRef?: string
   /** GEN-4: materialized Pareto parents seeded into every author's prompt (and
    *  the merge seat's explicit merge input). Empty/omitted = gen-3 behavior. */
   parents?: ParetoParentContext[]
   /** GEN-5: MAP+TOOLBOX briefing context threaded into every author prompt. */
   briefing?: BriefingContext
-  /** GEN-6: the resolved PUBLIC smoke instance — the GEPA seat's inner
+  /** The resolved public smoke instance used by the GEPA seat's inner
    *  evaluator target. Required (with `smokeRunner`) when a gepa seat is
    *  configured and no custom `author` is injected. */
   smokeInstanceId?: string
-  /** GEN-6: the gen-5 score split; private instance ids never reach the GEPA
+  /** The score split; private instance ids never reach the GEPA
    *  bridge (gepa-seat.mts asserts, fail-closed). Null/omitted = no split. */
   scoreSplit?: Pick<ScoreSplit, 'privateInstances'> | null
-  /** GEN-6 test seam: the adapter factory (default: checked dynamic import of
-   *  agent-eval's gepaOptimizationMethod, loud when the install predates it). */
+  /** GEPA method override for tests. Default: agent-eval's official GEPA method. */
   gepaMethodFactory?: GepaMethodFactory
+  /** Explicit GEPA optimizer model override, primarily for isolated tests. */
+  gepaOptimizer?: GepaSeatDeps['optimizer']
   log?: (msg: string) => void
 }
 
@@ -509,7 +510,7 @@ function defaultAuthor(config: OuterLoopConfig, deps: FanOutDeps): AuthorFn {
   // its own profile, lens prompt, and shot-receipt home.
   const inners = new Map<string, CandidateGenerator>()
   const ledgers = new Map<string, { ledger?: CostLedgerHandle; phase?: string }>()
-  // GEN-6: the GEPA seat authors through the agent-eval adapter, not a
+  // The GEPA seat authors through the agent-eval adapter, not a
   // harness CLI. Its inner evaluator is the SAME injected smoke runner the
   // pre-filter uses (presence enforced at generator construction).
   let gepaAuthor: AuthorFn | undefined
@@ -517,9 +518,12 @@ function defaultAuthor(config: OuterLoopConfig, deps: FanOutDeps): AuthorFn {
     if (isGepaSeat(proposer)) {
       gepaAuthor ??= gepaSeatAuthor(config, {
         smokeRunner: deps.smokeRunner!,
+        runnerImplementationRef: deps.runnerImplementationRef!,
+        judgeImplementationRef: deps.judgeImplementationRef!,
         smokeInstanceId: deps.smokeInstanceId!,
         scoreSplit: deps.scoreSplit ?? null,
         ...(deps.gepaMethodFactory ? { methodFactory: deps.gepaMethodFactory } : {}),
+        ...(deps.gepaOptimizer ? { optimizer: deps.gepaOptimizer } : {}),
         ...(deps.log ? { log: deps.log } : {}),
       })
       return gepaAuthor(proposer, args)
@@ -586,7 +590,7 @@ export function fanOutLoopsGenerator(config: OuterLoopConfig, deps: FanOutDeps =
         `only ${(deps.parents ?? []).length} pareto parent(s) materialized — a merge seat needs >=2`,
     )
   }
-  // GEN-6: engine seats are validated fail-closed at construction, and the
+  // Engine seats are validated at construction, and the
   // default author path requires the pre-filter smoke runner — it IS the GEPA
   // seat's inner evaluator (spec: score = smoke resolve + verify-pass
   // tiebreak). A custom injected `author` owns its own evaluator.
@@ -597,10 +601,19 @@ export function fanOutLoopsGenerator(config: OuterLoopConfig, deps: FanOutDeps =
       throw new Error(`fanOutLoopsGenerator: proposer ${seat.name} has neither a harness nor an engine`)
     }
   }
-  if (gepaSeats.length > 0 && deps.author === undefined && (deps.smokeRunner === undefined || deps.smokeInstanceId === undefined)) {
+  if (
+    gepaSeats.length > 0 &&
+    deps.author === undefined &&
+    (
+      deps.smokeRunner === undefined ||
+      deps.smokeInstanceId === undefined ||
+      deps.runnerImplementationRef === undefined ||
+      deps.judgeImplementationRef === undefined
+    )
+  ) {
     throw new Error(
       `fanOutLoopsGenerator: gepa seat(s) ${gepaSeats.map((p) => p.name).join(', ')} need the pre-filter smoke ` +
-        'cell as their inner evaluator — enable config.prefilter and provide smokeRunner + smokeInstanceId',
+        'cell plus immutable runner and judge references as their inner evaluator',
     )
   }
   const author = deps.author ?? defaultAuthor(config, deps)
@@ -616,11 +629,12 @@ export function fanOutLoopsGenerator(config: OuterLoopConfig, deps: FanOutDeps =
     const baseCommit = head.stdout.trim()
     const patchesDir = join(config.outDir, 'proposer-patches')
     await mkdir(patchesDir, { recursive: true })
+    await pruneDetachedWorktrees(config.loopsRepo)
     log(`fan-out gen ${generation}: ${proposers.length} proposer(s) authoring in parallel from ${baseCommit.slice(0, 10)}`)
     return Promise.all(
       proposers.map(async (proposer, index): Promise<AuthorOutcome> => {
         const scratch = join(config.outDir, 'proposer-wt', `gen${generation}-cand${index}-${sanitize(proposer.name)}`)
-        await addAuthoringWorktree(config.loopsRepo, baseCommit, scratch)
+        await createDetachedWorktree(config.loopsRepo, baseCommit, scratch)
         try {
           const authored = await author(proposer, {
             ...args,
@@ -697,6 +711,7 @@ export function fanOutLoopsGenerator(config: OuterLoopConfig, deps: FanOutDeps =
               scratchPath: scratch,
               generation,
               proposer,
+              evaluationKey: `candidate-${index}`,
               ...(args.costLedger ? { costLedger: args.costLedger } : {}),
             })
             if (!smoke.pass) {
@@ -719,7 +734,7 @@ export function fanOutLoopsGenerator(config: OuterLoopConfig, deps: FanOutDeps =
           }
           return { proposer, applied: true, summary: authored.summary, patch: diff, kill: null }
         } finally {
-          await removeAuthoringWorktree(config.loopsRepo, scratch)
+          await removeDetachedWorktree(config.loopsRepo, scratch)
         }
       }),
     )

package/src/swe-arena/proposer-fanout.test.mts

@@ -567,7 +567,6 @@ describe('defaultGen5Config', () => {
     expect(config.briefing).toBe('map-toolbox-v1')
     expect(config.activationGate).toBe(true)
     expect(config.rolloutLedger).toEqual({ enabled: true })
-    expect(config.lineage).toBe(true)
     expect(config.priorEvidenceDirs!.some((d) => d.includes('gen4'))).toBe(true)
   })