@tangle-network/agent-bench 0.3.7 → 0.3.8

package/src/swe-structural.mts

@@ -1,35 +1,58 @@
 /**
- * Two-session SWE-bench experiment with generation and official scoring split into separate modes.
+ * Stage 1 of the SWE-bench frontier push — the STRUCTURAL-SYSTEM mechanics pilot
+ * (contract: supervisor-lab/docs/results/PREREG-swe-frontier.md, Stage 1; execution design per the
+ * AMENDMENT + CLOSURE: image substrate everywhere, per-instance execution canary asserted at open).
  *
- * MODE=generate requires EXPERIMENT_ARM=independent-2|persistent-refine-2 and writes only Phase A.
- * The independent arm runs two fresh attempts. The persistent arm runs one attempt and one fresh
- * continuation with attempt one's cumulative patch pre-applied. Both use the same run-capable tools,
- * prompt, temperature, two worker sessions, and later-on-visible-tie selection rule. Per-row hashes
- * bind source, config, reproduction, prompt, tools, task, parent patch, and final patch.
+ * ARM=system, per instance:
+ *   1. canary — the Stage-0 execution canary on the image substrate (gold applied in-container,
+ *      `import <pkg>` must resolve into /testbed). Gold is used strictly script-side, never near a
+ *      model message (transport-level leak guard, below).
+ *   2. repro — the instance's Stage-0 valid+sound repro script is REUSED (REPRO_MANIFEST; source
+ *      recorded per row) and re-verified on THIS substrate with zero model calls: validity (nonzero
+ *      exit on the unpatched /testbed) + soundness (exit 0 under gold, in-container). A script that
+ *      fails re-verification degrades to repro=none — recorded, never silent. Instances with no
+ *      Stage-0 repro run repro=none and measure the no-signal path (selection = blind-first).
+ *   3. k=4 independent patch attempts — each the swe-emit-patch protocol verbatim (SWE_SEED_PROMPT,
+ *      list/read/edit tools on a fresh host clone, runAgentic refine budget=1, glm-5.2 temp 0.8;
+ *      the candidate is the workspace `git diff`, captured from inside score()).
+ *   4. selection — each candidate is scored in-image: `git apply` the candidate to the container's
+ *      /testbed (writable layer, --rm discards), run the repro. Argmax: repro-pass first, then
+ *      crash-lowest (fail < timeout < apply-fail < empty), first index breaks ties. With repro=none
+ *      the selection degrades to blind-first (first non-empty candidate).
+ *   5. ≤2 guarded repair rounds on the best — the repro failure output (+ the current diff, both
+ *      model-visible by construction) steers a fresh emit-patch attempt on a workspace with the
+ *      best diff pre-applied; the combined diff must STRICTLY improve the repro outcome to displace
+ *      (a repro-pass can never be displaced by a repro-fail — repair only runs while failing).
+ *   6. final diff locked → Phase B.
+ * ARM=solo: one emit-patch attempt (temp 0.7 — runShot's July-protocol default), same environment,
+ *   same 23 instances. The honest single-attempt reference.
  *
- * MODE=judge-only requires INDEPENDENT_PHASE_A, PERSISTENT_PHASE_A, and a distinct OUT. It validates
- * both complete Phase-A files and every paired fingerprint before the first serialized official score.
+ * Phase B (hidden judge): adapter.judge — the OFFICIAL swebench harness — runs serialized
+ * (max_workers 1) over the locked final diffs only, strictly AFTER every arm decision. Judge
+ * separation is asserted at the transport chokepoint: every outbound request's system/user messages
+ * (the strings WE author) are checked against gold-patch + test_patch content marks and refused on
+ * contact. Assistant/tool messages are exempt by construction (the model's own text and reads of
+ * the base tree — a model that independently authors the gold line is a success, not a leak).
  *
- * Generate env: ZAI_API_KEY, REPRO_MANIFEST, IDS, OUT, MODEL, ZAI_BASE, MAX_TOKENS, TEMPERATURE,
- * INNER_TURNS, CONC, REPRO_TIMEOUT, LLM_TIMEOUT_MS, SWE_RUN_TIMEOUT, SWE_RUN_OUTPUT_LIMIT,
- * PRICE_IN, PRICE_OUT. Judge env: INDEPENDENT_PHASE_A, PERSISTENT_PHASE_A, OUT.
+ *   cd ~/company/devops/secrets && dotenvx run -f agent-state.env -- bash -c \
+ *     'cd ~/code/agent-runtime-swe && ARM=system REPRO_MANIFEST=/path/manifest.json \
+ *      OUT=/path/swe-stage1-system.jsonl node_modules/.bin/tsx bench/src/swe-structural.mts'
+ *
+ * Env: ARM=system|solo (required), ZAI_API_KEY (required), ZAI_BASE, MODEL=glm-5.2,
+ *      MAX_TOKENS=12000, K=4, REPAIRS=2, TEMP=0.8 (system attempts+repairs), SOLO_TEMP=0.7,
+ *      INNER_TURNS=40, CONC=2, REPRO_TIMEOUT=120 (s), LLM_TIMEOUT_MS=480000, IDS=comma-list,
+ *      OUT=jsonl path, REPRO_MANIFEST=json path (system), SKIP_JUDGE=1 (Phase A only),
+ *      PRICE_IN/PRICE_OUT (USD per Mtok for the cost table; defaults are the assumed zai list rate).
+ *      Rows are incremental (OUT.phaseA then OUT) and both phases resume by instance id.
  */
 import { execFile } from 'node:child_process'
-import { appendFileSync, existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { join, relative } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { appendFileSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
 import { promisify } from 'node:util'
 import type { AgenticSurface, AgenticTask, ArtifactHandle, SurfaceScore } from '@tangle-network/agent-runtime/loops'
 import { refine, runAgentic } from '@tangle-network/agent-runtime/loops'
 import type { BenchTask } from './benchmarks/types'
-import {
-  createSweBenchEnvironment,
-  resolveImageForMetadata,
-  resolveSweBenchScorerVersion,
-  SWE_RUN_TOOL_CONFIG,
-  SWE_SEED_PROMPT_WITH_RUN,
-  type SweImageIdentity,
-} from './swe-bench-env'
+import { createSweBenchEnvironment, resolveImageForMetadata, SWE_SEED_PROMPT } from './swe-bench-env'
 import {
   APPLY_SENTINEL,
   assertNoHiddenLeak,
@@ -40,98 +63,30 @@ import {
   tail,
   zaiChatRaw,
 } from './swe-jail'
-import {
-  type ExperimentArm,
-  type ExperimentArmPreset,
-  assertExactCompletedWorkerSessions,
-  continuationDisposition,
-  continuationStateNotice,
-  preferLaterCandidate,
-  resolveExperimentArm,
-  resolveExperimentTemperature,
-  shouldAcceptContinuation,
-  shouldRunContinuation,
-} from './swe-structural-policy'
-import {
-  assertFingerprintsEqual,
-  createExecutionReceipt,
-  createFingerprints,
-  diffChanged,
-  diffFingerprint,
-  fingerprint,
-  runtimeImplementationFingerprint,
-  type ExecutionReceipt,
-  type Fingerprints,
-  type SharedExecutionReceipt,
-} from './swe-structural-provenance'
-import {
-  assertCompleteTaskSet,
-  assertDistinctArtifactPaths,
-  assertJudgeCompletionMatchesInput,
-  assertJudgeResumeFingerprints,
-  assertPairedExecutionFingerprint,
-  assertPairedFingerprints,
-  completeJudgeScore,
-} from './swe-structural-judge-policy'
 
 const exec = promisify(execFile)
-const TEMPERATURE = resolveExperimentTemperature(process.env)
-
-function sourceTreeReceipt(
-  rootUrl: URL,
-  label: string,
-  include: (path: string) => boolean,
-): Array<{ name: string; content: string }> {
-  const root = fileURLToPath(rootUrl)
-  const receipt: Array<{ name: string; content: string }> = []
-  const visit = (dir: string): void => {
-    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name))) {
-      const path = join(dir, entry.name)
-      if (entry.isDirectory()) visit(path)
-      else if (entry.isFile() && include(path)) {
-        receipt.push({ name: `${label}/${relative(root, path)}`, content: readFileSync(path, 'utf8') })
-      }
-    }
-  }
-  visit(root)
-  return receipt
-}
 
 // ---------- config ----------
 
-type Mode = 'generate' | 'judge-only'
-const MODE_INPUT = process.env.MODE ?? 'generate'
-if (MODE_INPUT !== 'generate' && MODE_INPUT !== 'judge-only') {
-  throw new Error(`MODE must be generate|judge-only, got "${MODE_INPUT}"`)
-}
-const MODE: Mode = MODE_INPUT
-const OFFICIAL_SCORER_CACHE_LEVEL = 'instance' as const
-if (
-  MODE === 'judge-only' &&
-  process.env.SWEBENCH_CACHE_LEVEL !== undefined &&
-  process.env.SWEBENCH_CACHE_LEVEL !== OFFICIAL_SCORER_CACHE_LEVEL
-) {
-  throw new Error('MODE=judge-only requires SWEBENCH_CACHE_LEVEL=instance')
-}
-if (MODE === 'judge-only') process.env.SWEBENCH_CACHE_LEVEL = OFFICIAL_SCORER_CACHE_LEVEL
-for (const legacy of ['ARM', 'ARM_NAME', 'K', 'REPAIRS', 'FORCE_TWO_SESSIONS', 'SOLO_TEMP', 'SKIP_JUDGE']) {
-  if (process.env[legacy] !== undefined) {
-    throw new Error(`${legacy} is not supported; use typed EXPERIMENT_ARM plus MODE=generate|judge-only`)
-  }
-}
-const ARM_PRESET: ExperimentArmPreset | null = MODE === 'generate'
-  ? resolveExperimentArm(process.env.EXPERIMENT_ARM ?? '')
-  : null
+const ARM = process.env.ARM ?? ''
+if (ARM !== 'system' && ARM !== 'solo') throw new Error(`ARM must be system|solo, got "${ARM}"`)
 const ZAI_BASE = process.env.ZAI_BASE ?? 'https://api.z.ai/api/coding/paas/v4'
 const ZAI_KEY = process.env.ZAI_API_KEY ?? ''
-if (MODE === 'generate' && !ZAI_KEY) throw new Error('ZAI_API_KEY required for MODE=generate')
+if (!ZAI_KEY) throw new Error('ZAI_API_KEY required (run under dotenvx: agent-state.env)')
 const MODEL = process.env.MODEL ?? 'glm-5.2'
 // glm-5.2 is a reasoning model: hidden reasoning consumes max_tokens, so <8000 starves content.
 const MAX_TOKENS = Number(process.env.MAX_TOKENS ?? 12_000)
+const K = Number(process.env.K ?? 4)
+const REPAIRS = Number(process.env.REPAIRS ?? 2)
+const TEMP = Number(process.env.TEMP ?? 0.8)
+const SOLO_TEMP = Number(process.env.SOLO_TEMP ?? 0.7)
 const INNER_TURNS = Number(process.env.INNER_TURNS ?? 40)
 const CONC = Math.max(1, Math.min(4, Number(process.env.CONC ?? 2)))
 const REPRO_TIMEOUT_S = Number(process.env.REPRO_TIMEOUT ?? 120)
 const LLM_TIMEOUT_MS = Number(process.env.LLM_TIMEOUT_MS ?? 480_000)
+const OUT = process.env.OUT ?? `swe-stage1-${ARM}.jsonl`
+const PHASE_A_OUT = `${OUT}.phaseA`
+const SKIP_JUDGE = process.env.SKIP_JUDGE === '1'
 // Cost-table rates, USD per Mtok. ASSUMED (zai coding-plan tokens have no per-call list price);
 // override with PRICE_IN/PRICE_OUT. The summary labels them as assumed.
 const PRICE_IN = Number(process.env.PRICE_IN ?? 0.6)
@@ -144,137 +99,15 @@ interface ReproManifestEntry {
 }
 
 const MANIFEST: Record<string, ReproManifestEntry> = (() => {
-  if (MODE !== 'generate') return {}
+  if (ARM !== 'system') return {}
   const p = process.env.REPRO_MANIFEST
-  if (!p) throw new Error('REPRO_MANIFEST required for MODE=generate')
+  if (!p) throw new Error('REPRO_MANIFEST required for ARM=system (Stage-0 valid+sound repro scripts)')
   return JSON.parse(readFileSync(p, 'utf8')) as Record<string, ReproManifestEntry>
 })()
 
-interface CommonConfigReceipt {
-  schema: 'swe-structural-v2'
-  model: string
-  zaiBase: string
-  maxTokens: number
-  temperature: number
-  innerTurns: number
-  concurrency: number
-  reproTimeoutS: number
-  llmTimeoutMs: number
-  sweRunTimeoutS: number
-  sweRunOutputLimit: number
-  runTool: true
-  seedPrompt: 'SWE_SEED_PROMPT_WITH_RUN'
-  taskIds: string[]
-}
-
-interface ExperimentConfigReceipt extends CommonConfigReceipt {
-  arm: ExperimentArm
-  k: 1 | 2
-  repairs: 0 | 1
-  alwaysRunContinuation: boolean
-  persistent: boolean
-  workerSessions: 2
-}
-
-const SOURCE_RECEIPT = [
-  ['swe-structural.mts', new URL('./swe-structural.mts', import.meta.url)],
-  ['swe-structural-policy.ts', new URL('./swe-structural-policy.ts', import.meta.url)],
-  ['swe-structural-provenance.ts', new URL('./swe-structural-provenance.ts', import.meta.url)],
-  ['swe-structural-judge-policy.ts', new URL('./swe-structural-judge-policy.ts', import.meta.url)],
-  ['swe-bench-env.ts', new URL('./swe-bench-env.ts', import.meta.url)],
-  ['swe-jail.ts', new URL('./swe-jail.ts', import.meta.url)],
-  ['swe-temp.ts', new URL('./swe-temp.ts', import.meta.url)],
-  ['benchmarks/swe-bench.ts', new URL('./benchmarks/swe-bench.ts', import.meta.url)],
-  ['benchmarks/_harness.ts', new URL('./benchmarks/_harness.ts', import.meta.url)],
-  ['runtime/strategy.ts', new URL('../../src/runtime/strategy.ts', import.meta.url)],
-].map(([name, url]) => ({ name: String(name), content: readFileSync(url as URL, 'utf8') }))
-
-const RUNTIME_IMPLEMENTATION_FINGERPRINT = runtimeImplementationFingerprint({ runAgentic, refine })
-const RUNTIME_TREE_FINGERPRINT = fingerprint([
-  ...sourceTreeReceipt(new URL('../../src/', import.meta.url), 'agent-runtime/src', (path) => path.endsWith('.ts')),
-  ...sourceTreeReceipt(
-    new URL('../../node_modules/@tangle-network/agent-eval/dist/', import.meta.url),
-    'agent-eval/dist',
-    (path) => path.endsWith('.js'),
-  ),
-  {
-    name: 'agent-runtime/package.json',
-    content: readFileSync(new URL('../../package.json', import.meta.url), 'utf8'),
-  },
-  {
-    name: 'agent-runtime/pnpm-lock.yaml',
-    content: readFileSync(new URL('../../pnpm-lock.yaml', import.meta.url), 'utf8'),
-  },
-  {
-    name: 'agent-eval/package.json',
-    content: readFileSync(new URL('../../node_modules/@tangle-network/agent-eval/package.json', import.meta.url), 'utf8'),
-  },
-])
-
-function makeExperimentConfig(preset: ExperimentArmPreset, taskIds: string[]): ExperimentConfigReceipt {
-  return {
-    schema: 'swe-structural-v2',
-    arm: preset.arm,
-    k: preset.k,
-    repairs: preset.repairs,
-    alwaysRunContinuation: preset.alwaysRunContinuation,
-    persistent: preset.persistent,
-    workerSessions: preset.workerSessions,
-    model: MODEL,
-    zaiBase: ZAI_BASE,
-    maxTokens: MAX_TOKENS,
-    temperature: TEMPERATURE,
-    innerTurns: INNER_TURNS,
-    concurrency: CONC,
-    reproTimeoutS: REPRO_TIMEOUT_S,
-    llmTimeoutMs: LLM_TIMEOUT_MS,
-    sweRunTimeoutS: SWE_RUN_TOOL_CONFIG.timeoutS,
-    sweRunOutputLimit: SWE_RUN_TOOL_CONFIG.outputLimit,
-    runTool: true,
-    seedPrompt: 'SWE_SEED_PROMPT_WITH_RUN',
-    taskIds: [...taskIds],
-  }
-}
-
-function commonConfig(config: ExperimentConfigReceipt): CommonConfigReceipt {
-  const {
-    arm: _arm,
-    k: _k,
-    repairs: _repairs,
-    alwaysRunContinuation: _alwaysRunContinuation,
-    persistent: _persistent,
-    workerSessions: _workerSessions,
-    ...common
-  } = config
-  return common
-}
-
-function reproReceipt(entry: ReproManifestEntry | undefined): ReproManifestEntry | null {
-  return entry ? { script: entry.script, source: entry.source, stage0Class: entry.stage0Class } : null
-}
-
-function expectedFingerprints(
-  bt: BenchTask,
-  config: ExperimentConfigReceipt,
-  tools: unknown,
-  repro: ReproManifestEntry | undefined,
-): Fingerprints {
-  return createFingerprints({
-    source: SOURCE_RECEIPT,
-    config,
-    commonConfig: commonConfig(config),
-    repro: reproReceipt(repro),
-    prompt: SWE_SEED_PROMPT_WITH_RUN,
-    tools,
-    task: { id: bt.id, prompt: bt.prompt, metadata: bt.metadata ?? null },
-  })
-}
-
 // ---------- transport: zai direct, patient ladder, leak guard at the chokepoint ----------
 
 interface Counter {
-  workerSessionsStarted: number
-  workerSessionsCompleted: number
   calls: number
   httpAttempts: number
   tokensIn: number
@@ -282,15 +115,7 @@ interface Counter {
   guardedMsgs: number
 }
 
-const newCounter = (): Counter => ({
-  workerSessionsStarted: 0,
-  workerSessionsCompleted: 0,
-  calls: 0,
-  httpAttempts: 0,
-  tokensIn: 0,
-  tokensOut: 0,
-  guardedMsgs: 0,
-})
+const newCounter = (): Counter => ({ calls: 0, httpAttempts: 0, tokensIn: 0, tokensOut: 0, guardedMsgs: 0 })
 
 /** Distinctive content marks for the leak guard: the first substantive ADDED line of the gold patch
  *  and of the hidden test patch. Never shown to any model; used only to refuse outbound messages. */
@@ -379,13 +204,12 @@ async function emitAttempt(
   }
   const task: AgenticTask = {
     id: bt.id,
-    systemPrompt: SWE_SEED_PROMPT_WITH_RUN,
+    systemPrompt: SWE_SEED_PROMPT,
     userPrompt: cfg.promptAppendix ? `${bt.prompt}\n\n${cfg.promptAppendix}` : bt.prompt,
     meta: { instanceId: bt.id },
   }
   let error: string | undefined
   try {
-    cfg.instanceCounter.workerSessionsStarted += 1
     const r = await runAgentic({
       surface: proxy,
       task,
@@ -399,8 +223,6 @@ async function emitAttempt(
       budget: 1,
       complete: makeTransport(cfg.marks, counter),
     })
-    if (counter.calls < 1) throw new Error('worker session completed without a successful model call')
-    cfg.instanceCounter.workerSessionsCompleted += 1
     cfg.instanceCounter.calls += counter.calls
     cfg.instanceCounter.httpAttempts += counter.httpAttempts
     cfg.instanceCounter.tokensIn += counter.tokensIn
@@ -433,17 +255,11 @@ async function emitAttempt(
   }
 }
 
-// Arm composition deliberately stays outside the built-in sample/refine strategies while each
-// worker session still runs through runAgentic(refine, budget=1). The built-ins cannot reproduce
-// this controlled comparison: sample exposes only aggregate scores and has no stable later-on-tie
-// patch receipt; refine may stop after shot one, adds an analyst call, and carries conversation
-// history. This layer supplies only the missing experiment policy: exactly two fresh worker
-// sessions, optional parent-patch state, shared visible selection, and exact per-session receipts.
-
 // ---------- in-image candidate scoring ----------
 
-/** Severity ordering for selection (lower is better): 0 repro-pass, 1 repro-fail, 2 timeout,
- *  3 apply-fail, 4 empty. Both experiment arms deterministically prefer session two on a tie. */
+/** Severity ordering for argmax (lower is better): 0 repro-pass, 1 repro-fail (clean nonzero exit),
+ *  2 repro-timeout, 3 candidate failed to apply, 4 empty candidate. "Crash-lowest" is realized as
+ *  this exit-class ordering; ties break on first index (deterministic). */
 interface CandScore {
   applyOk: boolean | null
   exit: number | null
@@ -471,7 +287,6 @@ async function scoreCandidate(imageTag: string, repro: string | null, diff: stri
 interface CandidateRow {
   idx: number
   diff: string
-  diffHash: string
   diffBytes: number
   completions: number
   calls: number
@@ -490,10 +305,7 @@ interface RepairRow {
   round: number
   baseFrom: string
   baseSeverity: number
-  parentDiffHash: string
   diff: string
-  finalDiffHash: string
-  changedFromParent: boolean
   diffBytes: number
   completions: number
   calls: number
@@ -507,46 +319,37 @@ interface RepairRow {
   accepted: boolean
 }
 
-interface PhaseARow {
+interface Row {
   instanceId: string
-  arm: ExperimentArm
-  config: ExperimentConfigReceipt
-  fingerprints: Fingerprints
+  arm: string
   repo: string
   model: string
   image: string | null
-  execution: ExecutionReceipt | null
-  executionFingerprint: string
   execMode: 'image'
   temperature: number
   innerTurns: number
   k: number
-  maxRepairs: number
   // canary + repro provenance (system arm)
   canaryExit: number | null
   canaryPass: boolean | null
   reproSource: string
-  reproStage0Class: string | null
   reproStatus: string
   reproScript: string | null
   reproPreExit: number | null
   reproGoldExit: number | null
-  reproOutcomeFingerprint: string
-  // candidates + selection + continuation receipts
+  // candidates + selection + repair receipts (system arm)
   candidates: CandidateRow[]
   selection: { mode: string; selectedIdx: number; movedOffFirst: boolean } | null
   repairs: RepairRow[]
   repairStop: string | null
   finalFrom: string
-  parentDiffHash: string | null
   finalDiff: string
-  finalDiffHash: string
-  changedFromParent: boolean | null
+  // hidden judge (Phase B; locked-after-decisions)
+  hiddenResolved: boolean | null
+  judgeDetail: string | null
+  judgeMs: number | null
+  judgeSkipped: string | null
   // cost + guard receipts
-  /** Number of fresh runAgentic worker invocations, including invocations that returned an error. */
-  workerSessionsStarted: number
-  /** Number of runAgentic invocations that returned successfully after at least one model call. */
-  workerSessions: number
   llmCalls: number
   httpAttempts: number
   tokensIn: number
@@ -560,32 +363,17 @@ interface PhaseARow {
 
 type Env = Awaited<ReturnType<typeof createSweBenchEnvironment>>
 
-interface PhaseAContext {
-  preset: ExperimentArmPreset
-  config: ExperimentConfigReceipt
-  tools: unknown
-  sharedExecution: SharedExecutionReceipt
-  expectedImageIdentities: Map<string, SweImageIdentity>
-}
-
-async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<PhaseARow> {
+async function phaseA(env: Env, bt: BenchTask): Promise<Row> {
   const t0 = Date.now()
   const md = bt.metadata as Record<string, string>
   const counter = newCounter()
-  const row: PhaseARow = {
-    instanceId: bt.id, arm: ctx.preset.arm, config: ctx.config,
-    fingerprints: expectedFingerprints(bt, ctx.config, ctx.tools, MANIFEST[bt.id]),
-    repo: md.repo, model: MODEL, image: null, execution: null, executionFingerprint: '', execMode: 'image',
-    temperature: TEMPERATURE, innerTurns: INNER_TURNS,
-    k: ctx.preset.k, maxRepairs: ctx.preset.repairs,
-    canaryExit: null, canaryPass: null, reproSource: 'none', reproStage0Class: null,
-    reproStatus: 'none', reproScript: null,
-    reproPreExit: null, reproGoldExit: null, reproOutcomeFingerprint: '',
-    candidates: [], selection: null, repairs: [],
-    repairStop: null, finalFrom: 'none', parentDiffHash: null, finalDiff: '',
-    finalDiffHash: diffFingerprint(''), changedFromParent: null,
-    workerSessionsStarted: 0, workerSessions: 0, llmCalls: 0, httpAttempts: 0,
-    tokensIn: 0, tokensOut: 0,
+  const row: Row = {
+    instanceId: bt.id, arm: ARM, repo: md.repo, model: MODEL, image: null, execMode: 'image',
+    temperature: ARM === 'system' ? TEMP : SOLO_TEMP, innerTurns: INNER_TURNS, k: ARM === 'system' ? K : 1,
+    canaryExit: null, canaryPass: null, reproSource: 'none', reproStatus: 'none', reproScript: null,
+    reproPreExit: null, reproGoldExit: null, candidates: [], selection: null, repairs: [],
+    repairStop: null, finalFrom: 'none', finalDiff: '', hiddenResolved: null, judgeDetail: null,
+    judgeMs: null, judgeSkipped: null, llmCalls: 0, httpAttempts: 0, tokensIn: 0, tokensOut: 0,
     guardedMsgs: 0, wallMs: 0,
   }
   const marks = leakMarks(md)
@@ -593,16 +381,25 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
     const img = await resolveImageForMetadata(bt.metadata ?? {})
     if (!img.ok) throw new Error(`image missing: ${img.reason}`)
     row.image = img.tag
-    row.execution = createExecutionReceipt(ctx.sharedExecution, img)
-    row.executionFingerprint = fingerprint(row.execution)
-    ctx.expectedImageIdentities.set(bt.id, img.identity)
+
+    if (ARM === 'solo') {
+      const a = await emitAttempt(env.environment, bt, { temperature: SOLO_TEMP, marks, instanceCounter: counter })
+      row.candidates.push({
+        idx: 0, diff: a.diff, diffBytes: a.diff.length, completions: a.completions, calls: a.calls,
+        tokensIn: a.tokensIn, tokensOut: a.tokensOut, wallMs: a.wallMs, attemptError: a.error ?? null,
+        applyOk: null, reproExit: null, reproTimedOut: false, severity: a.diff.trim() ? 1 : 4, reproOutTail: '',
+      })
+      row.finalDiff = a.diff
+      row.finalFrom = 'candidate:0'
+      return row
+    }
 
     // 1. EXECUTION CANARY (image substrate, gold in-container — script-side only, zero model calls).
     const pkg = IMPORT_NAME[md.repo]
     if (!pkg) throw new Error(`no IMPORT_NAME for ${md.repo} — canary not expressible`)
     const gold = String(md.patch ?? '')
     if (!gold.trim()) throw new Error('gold patch missing from metadata')
-    const c = await runPyInJail(img.identity.id, null, importCanaryScript(pkg), gold, { timeoutS: REPRO_TIMEOUT_S })
+    const c = await runPyInJail(img.tag, null, importCanaryScript(pkg), gold, { timeoutS: REPRO_TIMEOUT_S })
     if (c.infraError) throw new Error(c.infraError)
     row.canaryExit = c.code
     row.canaryPass = c.code === 0 && c.out.includes(APPLY_SENTINEL)
@@ -613,15 +410,14 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
     let repro: string | null = null
     if (manifest) {
       row.reproSource = manifest.source
-      row.reproStage0Class = manifest.stage0Class
       row.reproScript = manifest.script
-      const pre = await runPyInJail(img.identity.id, null, manifest.script, undefined, { timeoutS: REPRO_TIMEOUT_S })
+      const pre = await runPyInJail(img.tag, null, manifest.script, undefined, { timeoutS: REPRO_TIMEOUT_S })
       if (pre.infraError) throw new Error(pre.infraError)
       row.reproPreExit = pre.code
       if (pre.timedOut) row.reproStatus = 'degraded-timeout'
       else if (pre.code === 0) row.reproStatus = 'degraded-invalid'
       else {
-        const post = await runPyInJail(img.identity.id, null, manifest.script, gold, { timeoutS: REPRO_TIMEOUT_S })
+        const post = await runPyInJail(img.tag, null, manifest.script, gold, { timeoutS: REPRO_TIMEOUT_S })
         if (post.infraError) throw new Error(post.infraError)
         row.reproGoldExit = post.code
         if (post.code === 0 && post.out.includes(APPLY_SENTINEL)) {
@@ -635,12 +431,11 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
 
     // 3. k independent candidates (serial within the instance — CONC instances bound zai concurrency).
     const diffs: string[] = []
-    for (let i = 0; i < ctx.preset.k; i += 1) {
-      const a = await emitAttempt(env.environment, bt, { temperature: TEMPERATURE, marks, instanceCounter: counter })
+    for (let i = 0; i < K; i += 1) {
+      const a = await emitAttempt(env.environment, bt, { temperature: TEMP, marks, instanceCounter: counter })
       diffs.push(a.diff)
       row.candidates.push({
-        idx: i, diff: a.diff, diffHash: diffFingerprint(a.diff), diffBytes: a.diff.length,
-        completions: a.completions, calls: a.calls,
+        idx: i, diff: a.diff, diffBytes: a.diff.length, completions: a.completions, calls: a.calls,
         tokensIn: a.tokensIn, tokensOut: a.tokensOut, wallMs: a.wallMs, attemptError: a.error ?? null,
         applyOk: null, reproExit: null, reproTimedOut: false, severity: -1, reproOutTail: '',
       })
@@ -648,8 +443,8 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
 
     // 4. In-image scoring + argmax.
     const scores: CandScore[] = []
-    for (let i = 0; i < ctx.preset.k; i += 1) {
-      const s = await scoreCandidate(img.identity.id, repro, diffs[i] as string)
+    for (let i = 0; i < K; i += 1) {
+      const s = await scoreCandidate(img.tag, repro, diffs[i] as string)
       scores.push(s)
       const cand = row.candidates[i] as CandidateRow
       cand.applyOk = s.applyOk
@@ -658,96 +453,61 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
       cand.severity = s.severity
       cand.reproOutTail = s.out
     }
-    let selectedIdx = 0
-    for (let i = 1; i < ctx.preset.k; i += 1) {
-      if (preferLaterCandidate((scores[selectedIdx] as CandScore).severity, (scores[i] as CandScore).severity)) {
-        selectedIdx = i
+    let selectedIdx: number
+    let mode: string
+    if (repro) {
+      mode = 'repro-argmax'
+      selectedIdx = 0
+      for (let i = 1; i < K; i += 1) {
+        if ((scores[i] as CandScore).severity < (scores[selectedIdx] as CandScore).severity) selectedIdx = i
       }
+    } else {
+      mode = 'blind-first'
+      const firstNonEmpty = diffs.findIndex((d) => d.trim().length > 0)
+      selectedIdx = firstNonEmpty === -1 ? 0 : firstNonEmpty
     }
-    const mode = repro ? 'visible-severity-later-tie' : 'no-repro-later-tie'
-    row.selection = { mode, selectedIdx, movedOffFirst: selectedIdx !== 0 }
-
-    // 5. The persistent arm starts exactly one continuation from session one's cumulative patch.
-    // Both arms use the same later-on-visible-tie policy.
-    let best = {
-      diff: diffs[selectedIdx] as string,
-      score: scores[selectedIdx] as CandScore,
-      from: ctx.preset.persistent ? 'session:1' : `attempt:${selectedIdx + 1}`,
-    }
-    if (!ctx.preset.persistent) {
-      row.repairStop = 'independent-arm'
+    row.selection = { mode, selectedIdx, movedOffFirst: mode === 'repro-argmax' && selectedIdx !== 0 }
+
+    // 5. Guarded repair (repro-armed instances only — no signal, no repair).
+    let best = { diff: diffs[selectedIdx] as string, score: scores[selectedIdx] as CandScore, from: `candidate:${selectedIdx}` }
+    if (!repro) {
+      row.repairStop = 'no-signal'
+    } else if (best.score.severity === 0) {
+      row.repairStop = 'already-passing'
     } else {
-      for (let round = 1; shouldRunContinuation({ round, preset: ctx.preset }); round += 1) {
-        const parentDiff = best.diff
-        const parentDiffHash = diffFingerprint(parentDiff)
-        row.parentDiffHash = parentDiffHash
-        const reproductionEvidence = repro
-          ? `--- REPRODUCTION SCRIPT (written from the issue; exit 0 = fixed) ---\n${tail(repro, 6_000)}\n\n` +
-            `--- REPRODUCTION OUTPUT on the current state (exit ${best.score.exit ?? 'n/a'}) ---\n${best.score.out}\n\n`
-          : '--- EXTERNAL REPRODUCTION ---\nNo external reproduction is available. Use the run tool to construct local, issue-specific checks.\n\n'
-        const repairInstruction = best.score.severity === 0
-          ? 'The visible reproduction PASSES, but it is only a partial check. Re-read the full issue and audit ' +
-            'the current patch for missed cases or regressions. Keep the visible check passing while correcting ' +
-            'any incomplete source behavior you find with minimal edit_file changes. Do not modify tests.'
-          : 'The visible reproduction still fails (or no external reproduction is available). Diagnose why the ' +
-            'current state does not resolve the full issue, then correct the SOURCE with minimal edit_file changes ' +
-            '(you may revise or revert parts of the previous fix — it is already in the files). Do not modify tests.'
+      for (let round = 1; round <= REPAIRS && best.score.severity > 0; round += 1) {
         const appendix =
-          continuationStateNotice(best.diff) +
-          reproductionEvidence +
+          (best.diff.trim()
+            ? `--- PREVIOUS FIX (already applied to this checkout) ---\n${tail(best.diff, 8_000)}\n\n`
+            : '--- NO FIX APPLIED YET (every prior attempt produced no change) ---\n\n') +
+          `--- REPRODUCTION SCRIPT (written from the issue; exit 0 = fixed) ---\n${tail(repro, 6_000)}\n\n` +
+          `--- REPRODUCTION OUTPUT on the current state (exit ${best.score.exit ?? 'n/a'}) ---\n${best.score.out}\n\n` +
           '--- REPAIR INSTRUCTIONS ---\n' +
-          repairInstruction
+          'The reproduction above STILL FAILS. Diagnose why the current state does not resolve the issue, ' +
+          'then correct the SOURCE with minimal edit_file changes (you may revise or revert parts of the ' +
+          'previous fix — it is already in the files). Do not modify tests.'
         const a = await emitAttempt(env.environment, bt, {
-          temperature: TEMPERATURE, marks, instanceCounter: counter, preApply: best.diff, promptAppendix: appendix,
+          temperature: TEMP, marks, instanceCounter: counter, preApply: best.diff, promptAppendix: appendix,
         })
-        const ns = await scoreCandidate(img.identity.id, repro, a.diff)
-        const finalDiffHash = diffFingerprint(a.diff)
-        const changedFromParent = diffChanged(parentDiff, a.diff)
-        const accepted = shouldAcceptContinuation(best.score.severity, ns.severity)
-        const disposition = continuationDisposition(accepted, changedFromParent)
+        const ns = await scoreCandidate(img.tag, repro, a.diff)
+        const accepted = ns.severity < best.score.severity
         row.repairs.push({
-          round, baseFrom: best.from, baseSeverity: best.score.severity, parentDiffHash,
-          diff: a.diff, finalDiffHash, changedFromParent, diffBytes: a.diff.length,
+          round, baseFrom: best.from, baseSeverity: best.score.severity, diff: a.diff, diffBytes: a.diff.length,
           completions: a.completions, calls: a.calls, tokensIn: a.tokensIn, tokensOut: a.tokensOut,
           wallMs: a.wallMs, attemptError: a.error ?? null, applyOk: ns.applyOk, reproExit: ns.exit,
           severity: ns.severity, accepted,
         })
-        if (accepted) {
-          best = {
-            diff: a.diff,
-            score: ns,
-            from: disposition.finalFrom,
-          }
-          row.repairStop = disposition.stop
-        } else {
-          best.from = disposition.finalFrom
-          row.repairStop = disposition.stop
-        }
+        if (accepted) best = { diff: a.diff, score: ns, from: `repair:${round}` }
       }
+      row.repairStop = best.score.severity === 0 ? 'repaired-pass' : 'rounds-exhausted'
     }
     row.finalDiff = best.diff
-    row.finalDiffHash = diffFingerprint(best.diff)
     row.finalFrom = best.from
-    row.changedFromParent = row.parentDiffHash === null
-      ? null
-      : row.finalDiffHash !== row.parentDiffHash
     return row
   } catch (e) {
     row.error = e instanceof Error ? e.message.slice(0, 400) : String(e).slice(0, 400)
     return row
   } finally {
-    row.reproOutcomeFingerprint = fingerprint({
-      canaryExit: row.canaryExit,
-      canaryPass: row.canaryPass,
-      image: row.execution?.image ?? null,
-      reproGoldExit: row.reproGoldExit,
-      reproPreExit: row.reproPreExit,
-      reproSource: row.reproSource,
-      reproStage0Class: row.reproStage0Class,
-      reproStatus: row.reproStatus,
-    })
-    row.workerSessionsStarted = counter.workerSessionsStarted
-    row.workerSessions = counter.workerSessionsCompleted
     row.llmCalls = counter.calls
     row.httpAttempts = counter.httpAttempts
     row.tokensIn = counter.tokensIn
@@ -759,501 +519,149 @@ async function phaseA(env: Env, bt: BenchTask, ctx: PhaseAContext): Promise<Phas
 
 // ---------- driver ----------
 
-function loadPhaseRows(path: string, required = false): Map<string, PhaseARow> {
-  if (!existsSync(path)) {
-    if (required) throw new Error(`required Phase-A file does not exist: ${path}`)
-    return new Map()
-  }
-  const rows = new Map<string, PhaseARow>()
-  for (const [index, line] of readFileSync(path, 'utf8').split('\n').entries()) {
+function loadRows(path: string): Map<string, Row> {
+  const m = new Map<string, Row>()
+  if (!existsSync(path)) return m
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
     if (!line.trim()) continue
-    const row = JSON.parse(line) as PhaseARow
-    if (!row.instanceId) throw new Error(`${path}:${index + 1}: missing instanceId`)
-    if (rows.has(row.instanceId)) throw new Error(`${path}:${index + 1}: duplicate instanceId ${row.instanceId}`)
-    rows.set(row.instanceId, row)
+    const r = JSON.parse(line) as Row
+    m.set(r.instanceId, r)
   }
-  if (required && rows.size === 0) throw new Error(`required Phase-A file is empty: ${path}`)
-  return rows
+  return m
 }
 
-function manifestFromRow(row: PhaseARow): ReproManifestEntry | undefined {
-  if (row.reproScript === null) {
-    if (row.reproSource !== 'none' || row.reproStage0Class !== null) {
-      throw new Error(`${row.instanceId}: incomplete null-repro receipt`)
-    }
-    return undefined
-  }
-  if (row.reproSource === 'none' || row.reproStage0Class === null) {
-    throw new Error(`${row.instanceId}: incomplete repro receipt`)
-  }
-  return { script: row.reproScript, source: row.reproSource, stage0Class: row.reproStage0Class }
-}
-
-function assertPresetConfig(config: ExperimentConfigReceipt, arm: ExperimentArm, context: string): void {
-  const preset = resolveExperimentArm(arm)
-  if (
-    config.schema !== 'swe-structural-v2' ||
-    !config.model ||
-    !config.zaiBase ||
-    !Number.isFinite(config.maxTokens) ||
-    config.maxTokens <= 0 ||
-    !Number.isFinite(config.temperature) ||
-    !Number.isInteger(config.innerTurns) ||
-    config.innerTurns <= 0 ||
-    !Number.isInteger(config.concurrency) ||
-    config.concurrency < 1 ||
-    !Number.isFinite(config.reproTimeoutS) ||
-    config.reproTimeoutS <= 0 ||
-    !Number.isFinite(config.llmTimeoutMs) ||
-    config.llmTimeoutMs <= 0 ||
-    config.runTool !== true ||
-    config.seedPrompt !== 'SWE_SEED_PROMPT_WITH_RUN' ||
-    !Number.isFinite(config.sweRunTimeoutS) ||
-    config.sweRunTimeoutS <= 0 ||
-    !Number.isFinite(config.sweRunOutputLimit) ||
-    config.sweRunOutputLimit <= 0 ||
-    !Array.isArray(config.taskIds) ||
-    config.taskIds.length === 0
-  ) {
-    throw new Error(`${context}: unsupported config schema or worker surface`)
-  }
-  for (const key of ['arm', 'k', 'repairs', 'alwaysRunContinuation', 'persistent', 'workerSessions'] as const) {
-    if (config[key] !== preset[key]) {
-      throw new Error(`${context}: config ${key}=${String(config[key])}, expected ${String(preset[key])}`)
-    }
-  }
-}
-
-async function assertPhaseRow(
-  row: PhaseARow,
-  bt: BenchTask,
-  config: ExperimentConfigReceipt,
-  tools: unknown,
-  repro: ReproManifestEntry | undefined,
-  sharedExecution: SharedExecutionReceipt,
-  context: string,
-): Promise<void> {
-  if (row.instanceId !== bt.id) throw new Error(`${context}: instance mismatch ${row.instanceId} != ${bt.id}`)
-  if (row.arm !== config.arm) throw new Error(`${context}: arm mismatch ${row.arm} != ${config.arm}`)
-  if (!row.config) throw new Error(`${context}: missing config receipt`)
-  assertPresetConfig(row.config, row.arm, context)
-  if (fingerprint(row.config) !== fingerprint(config)) throw new Error(`${context}: config receipt mismatch`)
-  assertFingerprintsEqual(row.fingerprints, expectedFingerprints(bt, config, tools, repro), context)
-  if (
-    row.model !== config.model ||
-    row.temperature !== config.temperature ||
-    row.innerTurns !== config.innerTurns ||
-    row.k !== config.k ||
-    row.maxRepairs !== config.repairs
-  ) {
-    throw new Error(`${context}: row execution fields do not match config receipt`)
-  }
-  if (row.repo !== String((bt.metadata as Record<string, unknown> | undefined)?.repo ?? '')) {
-    throw new Error(`${context}: row repo does not match task metadata`)
-  }
-  if (row.error) throw new Error(`${context}: Phase A contains an error: ${row.error}`)
-  assertExactCompletedWorkerSessions({
-    started: row.workerSessionsStarted,
-    completed: row.workerSessions,
-    sessions: [...row.candidates, ...row.repairs],
-    context,
-  })
-  const currentImage = await resolveImageForMetadata(bt.metadata ?? {})
-  if (!currentImage.ok) throw new Error(`${context}: image unavailable during receipt validation: ${currentImage.reason}`)
-  const expectedExecution = createExecutionReceipt(sharedExecution, currentImage)
-  const actualExecution = row.execution
-  if (!actualExecution || fingerprint(actualExecution) !== fingerprint(expectedExecution)) {
-    throw new Error(`${context}: execution receipt mismatch`)
-  }
-  if (
-    row.config.sweRunTimeoutS !== actualExecution.runTool.timeoutS ||
-    row.config.sweRunOutputLimit !== actualExecution.runTool.outputLimit
-  ) {
-    throw new Error(`${context}: config and execution run-tool settings do not match`)
-  }
-  if (row.executionFingerprint !== fingerprint(expectedExecution)) {
-    throw new Error(`${context}: execution fingerprint mismatch`)
-  }
-  if (row.image !== expectedExecution.image.tag) throw new Error(`${context}: image tag receipt mismatch`)
-  if (row.finalDiffHash !== diffFingerprint(row.finalDiff)) throw new Error(`${context}: final diff hash mismatch`)
-  const expectedReproOutcome = fingerprint({
-    canaryExit: row.canaryExit,
-    canaryPass: row.canaryPass,
-    image: actualExecution.image,
-    reproGoldExit: row.reproGoldExit,
-    reproPreExit: row.reproPreExit,
-    reproSource: row.reproSource,
-    reproStage0Class: row.reproStage0Class,
-    reproStatus: row.reproStatus,
-  })
-  if (row.reproOutcomeFingerprint !== expectedReproOutcome) {
-    throw new Error(`${context}: reproduction outcome fingerprint mismatch`)
-  }
-  for (const candidate of row.candidates) {
-    if (candidate.diffHash !== diffFingerprint(candidate.diff)) {
-      throw new Error(`${context}: candidate ${candidate.idx} diff hash mismatch`)
-    }
-  }
-
-  const preset = resolveExperimentArm(row.arm)
-  if (row.candidates.length !== preset.k || row.repairs.length !== preset.repairs) {
-    throw new Error(
-      `${context}: arm shape mismatch (candidates=${row.candidates.length}, repairs=${row.repairs.length})`,
-    )
-  }
-  let selectedIdx = 0
-  for (let i = 1; i < row.candidates.length; i += 1) {
-    if (preferLaterCandidate(row.candidates[selectedIdx]!.severity, row.candidates[i]!.severity)) selectedIdx = i
-  }
-  const expectedMode = row.reproStatus === 'ok' ? 'visible-severity-later-tie' : 'no-repro-later-tie'
-  if (
-    row.selection?.selectedIdx !== selectedIdx ||
-    row.selection.mode !== expectedMode ||
-    row.selection.movedOffFirst !== (selectedIdx !== 0)
-  ) {
-    throw new Error(`${context}: selectedIdx violates later-on-visible-tie policy`)
-  }
-
-  if (!preset.persistent) {
-    if (row.parentDiffHash !== null || row.changedFromParent !== null) {
-      throw new Error(`${context}: independent arm must not claim a parent/refinement`)
-    }
-    if (row.repairStop !== 'independent-arm') throw new Error(`${context}: independent arm stop receipt mismatch`)
-    const selected = row.candidates[selectedIdx]!
-    if (row.finalDiff !== selected.diff || row.finalFrom !== `attempt:${selectedIdx + 1}`) {
-      throw new Error(`${context}: independent final patch does not match selected attempt`)
-    }
-    return
-  }
-
-  const continuation = row.repairs[0]!
-  const parent = row.candidates[0]!.diff
-  if (continuation.baseFrom !== 'session:1' || continuation.baseSeverity !== row.candidates[0]!.severity) {
-    throw new Error(`${context}: continuation parent receipt mismatch`)
-  }
-  if (continuation.parentDiffHash !== diffFingerprint(parent)) throw new Error(`${context}: parent diff hash mismatch`)
-  if (continuation.finalDiffHash !== diffFingerprint(continuation.diff)) throw new Error(`${context}: continuation diff hash mismatch`)
-  if (continuation.changedFromParent !== diffChanged(parent, continuation.diff)) {
-    throw new Error(`${context}: continuation changedFromParent mismatch`)
-  }
-  const shouldAccept = shouldAcceptContinuation(continuation.baseSeverity, continuation.severity)
-  if (continuation.accepted !== shouldAccept) throw new Error(`${context}: continuation violates shared tie policy`)
-  const expectedFinal = continuation.accepted ? continuation.diff : parent
-  const disposition = continuationDisposition(continuation.accepted, continuation.changedFromParent)
-  if (row.finalDiff !== expectedFinal || row.finalFrom !== disposition.finalFrom || row.repairStop !== disposition.stop) {
-    throw new Error(`${context}: persistent final patch/provenance mismatch`)
-  }
-  if (row.parentDiffHash !== continuation.parentDiffHash) throw new Error(`${context}: row parent diff hash mismatch`)
-  if (row.changedFromParent !== (row.finalDiffHash !== row.parentDiffHash)) {
-    throw new Error(`${context}: row changedFromParent mismatch`)
-  }
-}
-
-async function assertOfficialScoreImagePinned(row: PhaseARow, bt: BenchTask, context: string): Promise<void> {
-  const expected = row.execution?.image
-  if (!expected) throw new Error(`${context}: missing immutable image receipt`)
-  const current = await resolveImageForMetadata(bt.metadata ?? {})
-  if (!current.ok) throw new Error(`${context}: image unavailable: ${current.reason}`)
-  if (
-    current.tag !== expected.tag ||
-    current.namespace !== expected.namespace ||
-    current.identity.id !== expected.id
-  ) {
-    throw new Error(
-      `${context}: official-score image changed ` +
-        `(${expected.namespace}:${expected.tag}@${expected.id} -> ` +
-        `${current.namespace}:${current.tag}@${current.identity.id})`,
-    )
-  }
-}
-
-async function loadTasksAndTools(ids: string[]): Promise<{
-  env: Env
-  taskById: Map<string, BenchTask>
-  tools: unknown
-  sharedExecution: SharedExecutionReceipt
-  expectedImageIdentities: Map<string, SweImageIdentity>
-}> {
-  const expectedImageIdentities = new Map<string, SweImageIdentity>()
-  const env = await createSweBenchEnvironment(ids.length, {
-    ids,
-    cloneCache: true,
-    enableRun: true,
-    expectedImageIdentities,
-    adapterOptions: { cacheLevel: OFFICIAL_SCORER_CACHE_LEVEL },
-  })
-  await env.adapter.preflight?.()
-  const scorerVersion = await resolveSweBenchScorerVersion()
-  const taskById = new Map((await env.adapter.loadTasks({ ids, split: 'test' })).map((task) => [task.id, task]))
-  const missing = ids.filter((id) => !taskById.has(id))
-  if (missing.length) throw new Error(`instances not found in SWE-bench_Verified: ${missing.join(', ')}`)
-  const first = taskById.get(ids[0]!)!
-  const fingerprintTask: AgenticTask = {
-    id: first.id,
-    systemPrompt: SWE_SEED_PROMPT_WITH_RUN,
-    userPrompt: first.prompt,
-    meta: { instanceId: first.id },
-  }
-  const fingerprintHandle: ArtifactHandle = { id: 'fingerprint-only', surface: 'swe-bench-verified' }
-  return {
-    env,
-    taskById,
-    tools: await env.environment.tools(fingerprintTask, fingerprintHandle),
-    sharedExecution: {
-      runTool: { ...SWE_RUN_TOOL_CONFIG },
-      runtimeImplementationFingerprint: RUNTIME_IMPLEMENTATION_FINGERPRINT,
-      runtimeTreeFingerprint: RUNTIME_TREE_FINGERPRINT,
-      officialScorer: {
-        package: 'swebench',
-        version: scorerVersion,
-        cacheLevel: OFFICIAL_SCORER_CACHE_LEVEL,
-        namespacePolicy: 'phase-a-image',
-      },
-    },
-    expectedImageIdentities,
-  }
-}
-
-async function generateMain(): Promise<void> {
-  const preset = ARM_PRESET as ExperimentArmPreset
+async function main(): Promise<void> {
   const ids = process.env.IDS
-    ? process.env.IDS.split(',').map((value) => value.trim()).filter(Boolean)
+    ? process.env.IDS.split(',').map((s) => s.trim()).filter(Boolean)
     : await cachedInstanceIds()
   if (!ids.length) throw new Error('no cached sweb.eval images found and no IDS given')
-  if (new Set(ids).size !== ids.length) throw new Error('IDS contains duplicates')
-  const out = process.env.OUT ?? `swe-stage1-${preset.arm}.phaseA.jsonl`
-  const config = makeExperimentConfig(preset, ids)
-  assertPresetConfig(config, preset.arm, 'generate config')
-  const { env, taskById, tools, sharedExecution, expectedImageIdentities } = await loadTasksAndTools(ids)
 
-  console.log(`═══ SWE-bench Phase A — ${preset.arm} ═══`)
+  console.log(`═══ SWE-bench Stage 1 — structural pilot, ARM=${ARM} ═══`)
   console.log(
-    `sessions=2 k=${preset.k} repairs=${preset.repairs} persistent=${preset.persistent ? 1 : 0} ` +
-      `model=${MODEL} maxTokens=${MAX_TOKENS} innerTurns=${INNER_TURNS} temperature=${TEMPERATURE} runTool=1 judge=DISABLED`,
+    `model=${MODEL} base=${ZAI_BASE} maxTokens=${MAX_TOKENS} innerTurns=${INNER_TURNS} ` +
+      (ARM === 'system' ? `k=${K} temp=${TEMP} repairs<=${REPAIRS} ` : `temp=${SOLO_TEMP} `) +
+      `conc=${CONC} reproTimeout=${REPRO_TIMEOUT_S}s exec=image judge=${SKIP_JUDGE ? 'SKIPPED' : 'phase-B serialized'}`,
   )
-  console.log(`instances=${ids.length} out=${out}`)
-
-  const done = loadPhaseRows(out)
-  for (const [id, row] of done) {
-    if (!ids.includes(id)) throw new Error(`${out}: resume row ${id} is outside current IDS`)
-    await assertPhaseRow(row, taskById.get(id)!, config, tools, MANIFEST[id], sharedExecution, `${out}:${id}`)
+  console.log(`instances (${ids.length}): ${ids.join(', ')}`)
+  if (ARM === 'system') {
+    const withRepro = ids.filter((id) => MANIFEST[id]).length
+    console.log(`repro manifest: ${withRepro}/${ids.length} instances with a Stage-0 valid+sound repro (rest run repro=none)`)
   }
-  const todo = ids.filter((id) => !done.has(id))
-  if (done.size) console.log(`resume accepted: ${done.size}/${ids.length} fingerprint-matched rows`)
+  console.log(`out=${OUT} (phase A receipts: ${PHASE_A_OUT})`)
 
+  const env = await createSweBenchEnvironment(ids.length, { ids, cloneCache: true })
+  await env.adapter.preflight?.()
+  const taskById = new Map((await env.adapter.loadTasks({ ids, split: 'test' })).map((t) => [t.id, t]))
+  const missing = ids.filter((id) => !taskById.has(id))
+  if (missing.length) throw new Error(`instances not found in SWE-bench_Verified: ${missing.join(', ')}`)
+
+  // ── Phase A (resumable): every arm decision, no judge anywhere ──
+  const done = loadRows(PHASE_A_OUT)
+  const todo = ids.filter((id) => !done.has(id))
+  if (done.size) console.log(`phase A resume: ${done.size} rows already present, ${todo.length} to run`)
   let next = 0
   const worker = async (): Promise<void> => {
     while (next < todo.length) {
-      const index = next++
-      const id = todo[index]!
-      const row = await phaseA(env, taskById.get(id)!, {
-        preset,
-        config,
-        tools,
-        sharedExecution,
-        expectedImageIdentities,
-      })
-      await assertPhaseRow(
-        row,
-        taskById.get(id)!,
-        config,
-        tools,
-        MANIFEST[id],
-        sharedExecution,
-        `${preset.arm}:${id}`,
-      )
+      const i = next++
+      const id = todo[i] as string
+      console.log(`[A ${i + 1}/${todo.length}] ${id} …`)
+      const row = await phaseA(env, taskById.get(id) as BenchTask)
       done.set(id, row)
-      appendFileSync(out, `${JSON.stringify(row)}\n`)
+      appendFileSync(PHASE_A_OUT, `${JSON.stringify(row)}\n`)
+      const sel = row.selection ? `${row.selection.mode}@${row.selection.selectedIdx}${row.selection.movedOffFirst ? ' MOVED' : ''}` : '-'
       console.log(
-        `[${index + 1}/${todo.length}] ${id} sessions=${row.workerSessions} ` +
-          `severity=[${row.candidates.map((candidate) => candidate.severity).join(',')}] ` +
-          `continuation=[${row.repairs.map((repair) => repair.severity).join(',')}] ` +
-          `final=${row.finalFrom} changed=${row.changedFromParent ?? 'n/a'} calls=${row.llmCalls}`,
+        `[A ${i + 1}/${todo.length}] ${id} → repro=${row.reproStatus} sel=${sel} ` +
+          `sev=[${row.candidates.map((c) => c.severity).join(',')}] repairs=${row.repairs.length}(${row.repairStop ?? '-'}) ` +
+          `final=${row.finalFrom} diff=${row.finalDiff.length}b calls=${row.llmCalls} tok=${row.tokensIn}/${row.tokensOut} ` +
+          `wall=${Math.round(row.wallMs / 1000)}s${row.error ? ` ERR=${row.error.slice(0, 120)}` : ''}`,
       )
     }
   }
   await Promise.all(Array.from({ length: CONC }, () => worker()))
 
-  const rows = ids.map((id) => done.get(id)!)
-  const totalSessions = rows.reduce((sum, row) => sum + row.workerSessions, 0)
-  const totalIn = rows.reduce((sum, row) => sum + row.tokensIn, 0)
-  const totalOut = rows.reduce((sum, row) => sum + row.tokensOut, 0)
-  const usd = (totalIn / 1e6) * PRICE_IN + (totalOut / 1e6) * PRICE_OUT
-  console.log(
-    `Phase A complete: rows=${rows.length}/${ids.length} sessions=${totalSessions}/${2 * ids.length} ` +
-      `tokens=${totalIn}/${totalOut} assumedCost=$${usd.toFixed(2)}; no official scores were called`,
-  )
-}
-
-interface JudgeRow {
-  schema: 'swe-structural-judge-v2'
-  instanceId: string
-  arm: ExperimentArm
-  pairFingerprint: string
-  phaseFileFingerprint: string
-  inputFingerprint: string
-  executionFingerprint: string
-  finalDiffHash: string
-  hiddenResolved: boolean
-  judgeDetail: string | null
-  judgeMs: number
-  judgeSkipped: 'empty-patch' | null
-}
-
-function loadJudgeRows(path: string): Map<string, JudgeRow> {
-  if (!existsSync(path)) return new Map()
-  const rows = new Map<string, JudgeRow>()
-  for (const [index, line] of readFileSync(path, 'utf8').split('\n').entries()) {
-    if (!line.trim()) continue
-    const row = JSON.parse(line) as JudgeRow
-    if (row.schema !== 'swe-structural-judge-v2') {
-      throw new Error(`${path}:${index + 1}: unsupported judge row schema`)
-    }
-    if (typeof row.hiddenResolved !== 'boolean') {
-      throw new Error(`${path}:${index + 1}: incomplete judge row must be removed and retried`)
-    }
-    if (row.judgeSkipped !== null && row.judgeSkipped !== 'empty-patch') {
-      throw new Error(`${path}:${index + 1}: unsupported judge skip receipt ${row.judgeSkipped}`)
+  // ── Phase B: hidden judge, serialized, strictly after every arm decision locked ──
+  console.log(`\nphase A complete — all arm decisions locked (${new Date().toISOString()}).`)
+  const judged = loadRows(OUT)
+  if (SKIP_JUDGE) {
+    console.log('SKIP_JUDGE=1 — phase B not run; rows remain in the phase-A file only.')
+  } else {
+    console.log('phase B: official swebench judge, serialized (max_workers 1)…')
+    for (const id of ids) {
+      if (judged.has(id)) continue
+      const row = done.get(id) as Row
+      const t0 = Date.now()
+      if (!row.finalDiff.trim()) {
+        row.hiddenResolved = false
+        row.judgeSkipped = row.error ? 'error-no-patch' : 'empty-patch'
+      } else {
+        try {
+          const s = await env.adapter.judge(taskById.get(id) as BenchTask, row.finalDiff)
+          row.hiddenResolved = s.resolved ?? false
+          row.judgeDetail = String(s.detail ?? '').slice(0, 1_000)
+        } catch (e) {
+          row.hiddenResolved = false
+          row.judgeSkipped = `judge-error: ${e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200)}`
+        }
+      }
+      row.judgeMs = Date.now() - t0
+      judged.set(id, row)
+      appendFileSync(OUT, `${JSON.stringify(row)}\n`)
+      console.log(`[B] ${id} → resolved=${row.hiddenResolved} (${Math.round((row.judgeMs ?? 0) / 1000)}s)${row.judgeSkipped ? ` [${row.judgeSkipped}]` : ''}`)
     }
-    resolveExperimentArm(row.arm)
-    const key = `${row.arm}:${row.instanceId}`
-    if (rows.has(key)) throw new Error(`${path}:${index + 1}: duplicate judge row ${key}`)
-    rows.set(key, row)
   }
-  return rows
-}
 
-function requirePath(name: string): string {
-  const value = process.env[name]?.trim()
-  if (!value) throw new Error(`${name} required for MODE=judge-only`)
-  return value
-}
-
-async function judgeOnlyMain(): Promise<void> {
-  const independentPath = requirePath('INDEPENDENT_PHASE_A')
-  const persistentPath = requirePath('PERSISTENT_PHASE_A')
-  const out = requirePath('OUT')
-  assertDistinctArtifactPaths({ INDEPENDENT_PHASE_A: independentPath, PERSISTENT_PHASE_A: persistentPath, OUT: out })
-  const independent = loadPhaseRows(independentPath, true)
-  const persistent = loadPhaseRows(persistentPath, true)
-  const independentConfig = [...independent.values()][0]!.config
-  const persistentConfig = [...persistent.values()][0]!.config
-  if (!independentConfig || !persistentConfig) throw new Error('Phase-A file is missing its config receipt')
-  assertPresetConfig(independentConfig, 'independent-2', independentPath)
-  assertPresetConfig(persistentConfig, 'persistent-refine-2', persistentPath)
-  if (fingerprint(commonConfig(independentConfig)) !== fingerprint(commonConfig(persistentConfig))) {
-    throw new Error('Phase-A files have different common configuration fingerprints')
-  }
-  const ids = independentConfig.taskIds
-  if (fingerprint(ids) !== fingerprint(persistentConfig.taskIds)) {
-    throw new Error('Phase-A files have different task-id fingerprints')
-  }
-  for (const [path, rows] of [[independentPath, independent], [persistentPath, persistent]] as const) {
-    assertCompleteTaskSet(rows.keys(), ids, path)
-  }
-
-  // No official judge call occurs before every row in both files passes these checks.
-  const { env, taskById, tools, sharedExecution } = await loadTasksAndTools(ids)
-  for (const id of ids) {
-    const left = independent.get(id)!
-    const right = persistent.get(id)!
-    await assertPhaseRow(
-      left,
-      taskById.get(id)!,
-      independentConfig,
-      tools,
-      manifestFromRow(left),
-      sharedExecution,
-      `${independentPath}:${id}`,
-    )
-    await assertPhaseRow(
-      right,
-      taskById.get(id)!,
-      persistentConfig,
-      tools,
-      manifestFromRow(right),
-      sharedExecution,
-      `${persistentPath}:${id}`,
+  // ── summary ──
+  const rows = [...(SKIP_JUDGE ? done : judged).values()].filter((r) => ids.includes(r.instanceId))
+  const n = rows.length
+  const resolved = rows.filter((r) => r.hiddenResolved === true).length
+  const errors = rows.filter((r) => r.error).length
+  const totIn = rows.reduce((s, r) => s + r.tokensIn, 0)
+  const totOut = rows.reduce((s, r) => s + r.tokensOut, 0)
+  const totCalls = rows.reduce((s, r) => s + r.llmCalls, 0)
+  const totHttp = rows.reduce((s, r) => s + r.httpAttempts, 0)
+  const totGuard = rows.reduce((s, r) => s + r.guardedMsgs, 0)
+  const walls = rows.map((r) => r.wallMs / 1000).sort((a, b) => a - b)
+  const q = (p: number): number => walls.length ? (walls[Math.min(walls.length - 1, Math.floor(p * (walls.length - 1)))] as number) : 0
+  const usd = (totIn / 1e6) * PRICE_IN + (totOut / 1e6) * PRICE_OUT
+
+  console.log(`\n══ per-instance (${ARM}) ══`)
+  console.log('instance | repro(src) | cand sev | sel | moved | repairs | stop | final | resolved | calls | tokIn/out | wall_s | err')
+  for (const r of [...rows].sort((a, b) => a.instanceId.localeCompare(b.instanceId))) {
+    const sel = r.selection ? `${r.selection.mode === 'repro-argmax' ? 'argmax' : 'blind'}@${r.selection.selectedIdx}` : '-'
+    console.log(
+      `${r.instanceId} | ${r.reproStatus}${r.reproSource !== 'none' ? `(${r.reproSource.replace('stage0-', '')})` : ''} | ` +
+        `[${r.candidates.map((c) => c.severity).join(',')}] | ${sel} | ${r.selection?.movedOffFirst ? 1 : 0} | ` +
+        `${r.repairs.length}${r.repairs.some((x) => x.accepted) ? '+acc' : ''} | ${r.repairStop ?? '-'} | ${r.finalFrom} | ` +
+        `${r.hiddenResolved === null ? '?' : r.hiddenResolved ? 1 : 0} | ${r.llmCalls} | ${r.tokensIn}/${r.tokensOut} | ` +
+        `${Math.round(r.wallMs / 1000)} | ${r.error ? r.error.slice(0, 60) : '-'}`,
     )
-    assertPairedFingerprints(left.fingerprints, right.fingerprints, id)
-    assertPairedExecutionFingerprint(left.executionFingerprint, right.executionFingerprint, id)
-    if (left.reproOutcomeFingerprint !== right.reproOutcomeFingerprint) {
-      throw new Error(`${id}: paired reproduction outcomes do not match`)
-    }
-  }
-
-  const phaseFileFingerprints: Record<ExperimentArm, string> = {
-    'independent-2': fingerprint({ bytes: readFileSync(independentPath, 'utf8') }),
-    'persistent-refine-2': fingerprint({ bytes: readFileSync(persistentPath, 'utf8') }),
-  }
-  const pairFingerprint = fingerprint({
-    commonConfig: independent.get(ids[0]!)!.fingerprints.commonConfig,
-    ids,
-    phaseFiles: phaseFileFingerprints,
-    prompt: independent.get(ids[0]!)!.fingerprints.prompt,
-    source: independent.get(ids[0]!)!.fingerprints.source,
-    tools: independent.get(ids[0]!)!.fingerprints.tools,
-    executions: ids.map((id) => independent.get(id)!.executionFingerprint),
-  })
-  const judged = loadJudgeRows(out)
-  const arms: Array<{ arm: ExperimentArm; path: string; rows: Map<string, PhaseARow> }> = [
-    { arm: 'independent-2', path: independentPath, rows: independent },
-    { arm: 'persistent-refine-2', path: persistentPath, rows: persistent },
-  ]
-  for (const existing of judged.values()) {
-    const input = arms.find(({ arm }) => arm === existing.arm)?.rows.get(existing.instanceId)
-    if (!input) throw new Error(`${out}: judge resume row has no paired Phase-A input`)
-    assertJudgeCompletionMatchesInput(existing, input.finalDiff, `${out}:${existing.arm}:${existing.instanceId}`)
-    assertJudgeResumeFingerprints(existing, {
-      pairFingerprint,
-      phaseFileFingerprint: phaseFileFingerprints[existing.arm],
-      inputFingerprint: input.fingerprints.composite,
-      executionFingerprint: input.executionFingerprint,
-      finalDiffHash: input.finalDiffHash,
-    }, `${out}:${existing.arm}:${existing.instanceId}`)
   }
 
-  console.log(`all ${2 * ids.length} Phase-A rows matched; official scoring starts now (serialized)`)
-  for (const id of ids) {
-    for (const { arm, rows } of arms) {
-      const key = `${arm}:${id}`
-      if (judged.has(key)) continue
-      const input = rows.get(id)!
-      const started = Date.now()
-      // Fail without appending: a transient official-scorer error must be retried on resume.
-      const { hiddenResolved, judgeDetail, judgeSkipped } = await completeJudgeScore(
-        input.finalDiff,
-        async () => {
-          const task = taskById.get(id)!
-          process.env.SWEBENCH_NAMESPACE = input.execution!.image.namespace
-          await assertOfficialScoreImagePinned(input, task, `${key}:before`)
-          const score = await env.adapter.judge(task, input.finalDiff)
-          await assertOfficialScoreImagePinned(input, task, `${key}:after`)
-          return score
-        },
-      )
-      const row: JudgeRow = {
-        schema: 'swe-structural-judge-v2',
-        instanceId: id,
-        arm,
-        pairFingerprint,
-        phaseFileFingerprint: phaseFileFingerprints[arm],
-        inputFingerprint: input.fingerprints.composite,
-        executionFingerprint: input.executionFingerprint,
-        finalDiffHash: input.finalDiffHash,
-        hiddenResolved,
-        judgeDetail,
-        judgeMs: Date.now() - started,
-        judgeSkipped,
-      }
-      judged.set(key, row)
-      appendFileSync(out, `${JSON.stringify(row)}\n`)
-      console.log(`[judge] ${key} resolved=${hiddenResolved} skipped=${judgeSkipped ?? '-'}`)
-    }
-  }
+  console.log(`\n══ summary (${ARM}) ══`)
+  console.log(`n=${n} resolved(hidden)=${resolved}/${n} errorRows=${errors}`)
+  if (ARM === 'system') {
+    const armed = rows.filter((r) => r.reproStatus === 'ok')
+    const blind = rows.filter((r) => r.selection?.mode === 'blind-first')
+    const moved = rows.filter((r) => r.selection?.movedOffFirst)
+    const scored = armed.flatMap((r) => r.candidates)
+    const passCands = scored.filter((c) => c.severity === 0)
+    const fired = rows.filter((r) => r.repairs.length > 0)
+    const accepted = rows.filter((r) => r.repairs.some((x) => x.accepted))
+    const failToPass = rows.filter((r) => r.repairStop === 'repaired-pass')
+    console.log(`repro: ok=${armed.length} degraded=${rows.filter((r) => r.reproStatus.startsWith('degraded')).length} none=${rows.filter((r) => r.reproStatus === 'none').length}`)
+    console.log(`selection: repro-argmax=${armed.length} blind-first=${blind.length} | argmax moved off idx0 on ${moved.length} instance(s)`)
+    console.log(`candidates (repro-armed): ${scored.length} scored, ${passCands.length} repro-pass (${scored.length ? ((100 * passCands.length) / scored.length).toFixed(1) : 0}%)`)
+    console.log(`repair: fired on ${fired.length} instance(s), accepted(improved) on ${accepted.length}, repro fail→pass on ${failToPass.length}`)
+    const stops = new Map<string, number>()
+    for (const r of rows) if (r.repairStop) stops.set(r.repairStop, (stops.get(r.repairStop) ?? 0) + 1)
+    console.log(`repair stops: ${[...stops.entries()].map(([k, v]) => `${k}=${v}`).join('  ')}`)
+  }
+  console.log(`leak guard: ${totGuard} system/user messages checked across ${totCalls} completions — 0 trips (a trip throws)`)
+  console.log(`cost: tokens in=${totIn} out=${totOut} | llmCalls=${totCalls} httpAttempts=${totHttp} | ` +
+      `$${usd.toFixed(2)} @ $${PRICE_IN}/M in + $${PRICE_OUT}/M out (ASSUMED rate — override PRICE_IN/PRICE_OUT)`)
+  console.log(`wall per instance: min/med/p90/max = ${Math.round(q(0))}/${Math.round(q(0.5))}/${Math.round(q(0.9))}/${Math.round(q(1))}s  sum=${Math.round(walls.reduce((a, b) => a + b, 0))}s`)
 }
 
-const main = MODE === 'generate' ? generateMain : judgeOnlyMain
 main().catch((e) => {
   console.error(e instanceof Error ? (e.stack ?? e.message) : String(e))
   process.exit(1)