From 754db76df276c8c5bad7e4a2f8d3435fd50bde6a Mon Sep 17 00:00:00 2001
From: liwei <269394628@qq.com>
Date: Mon, 27 Jul 2026 14:54:54 +0800
Subject: [PATCH] Add verified winners and baseline setup

---
 README.md                |  25 ++++-
 src/cli.js               |  12 +-
 src/config.js            |  13 +++
 src/process.js           |  23 +++-
 src/report.js            |   7 +-
 src/runner.js            | 234 +++++++++++++++++++++++++++++++++------
 test/config.test.js      |  22 ++++
 test/integration.test.js | 138 +++++++++++++++++++++++
 test/report.test.js      |   2 +-
 9 files changed, 431 insertions(+), 45 deletions(-)
 create mode 100644 test/config.test.js

diff --git a/README.md b/README.md
index cec09dd..c44129c 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,11 @@ Choosing a coding agent from anecdotes is hard. PatchLeague gives several agents
 - a self-contained offline HTML report;
 - a guarded, preview-first path for applying the winner.
 
-PatchLeague uses your existing CLI subscriptions and authentication. It does not proxy prompts through its own service and does not upload source code.
+PatchLeague uses your existing CLI subscriptions and authentication. PatchLeague
+itself does not proxy prompts through its own service or upload source code.
+However, the agent CLIs you configure may send prompts, repository context, or
+source code to their providers. Review each provider's data-handling policy
+before running it on private or sensitive repositories.
 
 ## Quick start
 
@@ -106,6 +110,7 @@ Run `patchleague init` in a Git repository to create `.patchleague/config.json`:
   "defaultAgents": ["codex", "claude"],
   "maxParallel": 2,
   "timeoutMs": 900000,
+  "setup": [],
   "checks": "auto",
   "agents": {}
 }
@@ -119,6 +124,7 @@ Built-in presets exist for `codex`, `claude`, `gemini`, and `opencode`. Override
   "defaultAgents": ["my-agent"],
   "maxParallel": 1,
   "timeoutMs": 600000,
+  "setup": ["npm ci"],
   "checks": ["npm test"],
   "agents": {
     "my-agent": {
@@ -133,6 +139,11 @@ Built-in presets exist for `codex`, `claude`, `gemini`, and `opencode`. Override
 
 Agent prompts can be passed through stdin or through an argument containing `{prompt}`. Adapter arguments may also use `{worktree}` and `{task_file}`.
 
+Use `setup` for commands that prepare each detached worktree before an agent
+runs, such as `npm ci` or `uv sync --frozen`. Setup commands must be
+non-interactive and should not change tracked files. They can be overridden with
+repeatable `--setup` flags or disabled with `--no-setup`.
+
 ## Verification and scoring
 
 When `--check` is omitted, PatchLeague looks for conventional project commands:
@@ -145,6 +156,11 @@ When `--check` is omitted, PatchLeague looks for conventional project commands:
 | `pyproject.toml` / `pytest.ini` | `python -m pytest` |
 | `Makefile` | `make test` |
 
+Before agents start, PatchLeague runs the configured checks once against the
+base commit in a separate worktree. The saved baseline result distinguishes
+pre-existing failures from failures introduced by a candidate. Setup commands
+run before both the baseline checks and every agent.
+
 The default score is deliberately simple and inspectable:
 
 | Component | Weight |
@@ -154,7 +170,10 @@ The default score is deliberately simple and inspectable:
 | Focused patch size | 15 |
 | Static risk signals | 5 |
 
-No checks means only partial validation credit. An empty patch or failed agent receives a zero score. Scores help sort candidates; they do not replace reviewing the diff.
+No checks means only partial validation credit. An empty patch or failed agent
+receives a zero score. A patch can be selected as the winner only when the agent
+completed successfully and every configured check passed. Scores help sort
+candidates; they do not replace reviewing the diff.
 
 ## Safe patch application
 
@@ -221,7 +240,7 @@ Run artifacts live under `.patchleague/runs/<run-id>/`. Temporary worktrees are
 - Parse provider-native token and cost telemetry.
 - Container and OS-level sandbox backends.
 - GitHub Issue and pull-request URLs as task sources.
-- Baseline checks and flaky-test detection.
+- Flaky-test detection and retry policies.
 - Replayable agent/tool event timelines.
 - CI mode and shareable redacted reports.
 
diff --git a/src/cli.js b/src/cli.js
index 389e221..4d5422c 100644
--- a/src/cli.js
+++ b/src/cli.js
@@ -51,6 +51,8 @@ Setup and discovery:
 Competition:
   run <task-file>              Run agents in isolated Git worktrees
     --agents <a,b>             Agents to run (default: config defaultAgents)
+    --setup <command>          Worktree setup command; repeatable
+    --no-setup                 Disable configured setup commands
     --check <command>          Verification command; repeatable
     --no-checks                Disable auto-detected checks
     --timeout <seconds>        Per-agent timeout
@@ -117,6 +119,7 @@ function humanRun(run, reportPath) {
       `Repository: ${run.repository.path}`,
       `Commit:     ${run.repository.commit}`,
       `Agents:     ${run.agents.join(", ")}`,
+      `Setup:      ${run.setup.length ? run.setup.join(" | ") : "(none)"}`,
       `Checks:     ${run.checks.length ? run.checks.join(" | ") : "(none)"}`,
       `Parallel:   ${run.max_parallel}`,
       `Timeout:    ${Math.round(run.timeout_ms / 1000)}s`
@@ -137,9 +140,12 @@ function humanRun(run, reportPath) {
     " #  AGENT           SCORE   CHECKS    LINES  STATUS",
     ...rows,
     "",
+    run.baseline
+      ? `Baseline: ${run.baseline.status}`
+      : "Baseline: skipped",
     run.winner
       ? `Winner: ${run.winner.agent} (${run.winner.score}/100)`
-      : "Winner: none — no valid patch was produced.",
+      : "Winner: none — no patch passed every configured check.",
     reportPath ? `Report: ${reportPath}` : ""
   ]
     .filter((line, index, all) => line !== "" || all[index - 1] !== "")
@@ -261,6 +267,8 @@ async function agentsCommand(args) {
 
 async function runCommand(args, reporter) {
   const agentList = parseCommaList(takeValue(args, "--agents"));
+  const explicitSetup = takeValue(args, "--setup", { multiple: true });
+  const noSetup = takeBoolean(args, "--no-setup");
   const explicitChecks = takeValue(args, "--check", { multiple: true });
   const noChecks = takeBoolean(args, "--no-checks");
   const allowDirty = takeBoolean(args, "--allow-dirty");
@@ -288,6 +296,8 @@ async function runCommand(args, reporter) {
     configPath: loaded.path,
     task,
     agents: agentList,
+    explicitSetup,
+    noSetup,
     explicitChecks,
     noChecks,
     timeoutMs: timeoutSeconds ? timeoutSeconds * 1000 : undefined,
diff --git a/src/config.js b/src/config.js
index c5dc3e4..69cb424 100644
--- a/src/config.js
+++ b/src/config.js
@@ -10,6 +10,7 @@ export const DEFAULT_CONFIG = Object.freeze({
   defaultAgents: ["codex", "claude"],
   maxParallel: 2,
   timeoutMs: 15 * 60 * 1000,
+  setup: [],
   checks: "auto",
   agents: {
     codex: {
@@ -70,6 +71,7 @@ export function sampleConfig() {
     defaultAgents: ["codex", "claude"],
     maxParallel: 2,
     timeoutMs: 900000,
+    setup: [],
     checks: "auto",
     agents: {}
   };
@@ -126,6 +128,17 @@ export function validateConfig(config, source = "configuration") {
       `${source}.timeoutMs must be an integer of at least 1000`
     );
   }
+  if (
+    !Array.isArray(config.setup) ||
+    config.setup.some(
+      (command) => typeof command !== "string" || command.trim().length === 0
+    )
+  ) {
+    throw new PatchLeagueError(
+      "INVALID_CONFIG",
+      `${source}.setup must be an array of non-empty command strings`
+    );
+  }
   return config;
 }
 
diff --git a/src/process.js b/src/process.js
index 437a9e6..0564942 100644
--- a/src/process.js
+++ b/src/process.js
@@ -23,12 +23,24 @@ function terminateProcessTree(child) {
       }
     );
     killer.on("error", () => child.kill());
-    return;
+    return undefined;
   }
 
-  child.kill("SIGTERM");
-  const forceTimer = setTimeout(() => child.kill("SIGKILL"), 3000);
+  const signalGroup = (signal) => {
+    try {
+      process.kill(-child.pid, signal);
+    } catch {
+      try {
+        child.kill(signal);
+      } catch {
+        // The process may have exited between the timeout and the signal.
+      }
+    }
+  };
+  signalGroup("SIGTERM");
+  const forceTimer = setTimeout(() => signalGroup("SIGKILL"), 3000);
   forceTimer.unref();
+  return forceTimer;
 }
 
 export function runProcess(
@@ -52,6 +64,7 @@ export function runProcess(
     let truncated = false;
     let timedOut = false;
     let settled = false;
+    let forceTimer;
 
     const needsWindowsCommandShell =
       process.platform === "win32" &&
@@ -64,6 +77,7 @@ export function runProcess(
       cwd,
       env: env ? { ...process.env, ...env } : process.env,
       shell: shell || needsWindowsCommandShell,
+      detached: process.platform !== "win32",
       windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -92,7 +106,7 @@ export function runProcess(
       timeoutMs > 0
         ? setTimeout(() => {
             timedOut = true;
-            terminateProcessTree(child);
+            forceTimer = terminateProcessTree(child);
           }, timeoutMs)
         : undefined;
 
@@ -100,6 +114,7 @@ export function runProcess(
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
       resolve({
         command,
         args,
diff --git a/src/report.js b/src/report.js
index 221791f..4884e46 100644
--- a/src/report.js
+++ b/src/report.js
@@ -37,6 +37,8 @@ export async function generateReport(repoPath, run) {
     task: run.task,
     repository: run.repository,
     winner: run.winner,
+    baseline: run.baseline,
+    setup: run.setup,
     checks: run.checks,
     results
   };
@@ -142,7 +144,7 @@ export function reportHtml(model) {
     <section class="winner" id="winner"></section>
     <section class="grid" id="cards"></section>
     <section class="detail" id="detail"></section>
-    <footer>Generated locally by PatchLeague. No source code or agent logs were uploaded.</footer>
+    <footer>Generated locally by PatchLeague. Configured agent providers may receive repository context.</footer>
   </main>
   <script id="run-data" type="application/json">${safeJson(model)}</script>
   <script>
@@ -153,7 +155,8 @@ export function reportHtml(model) {
     document.getElementById("title").textContent = run.task.title;
     document.getElementById("meta").textContent =
       run.repository.branch + " · " + run.repository.commit.slice(0, 10) + " · " +
-      new Date(run.created_at).toLocaleString();
+      new Date(run.created_at).toLocaleString() +
+      (run.baseline ? " · baseline " + run.baseline.status : "");
     const winner = run.results.find((result) => result.agent === run.winner?.agent);
     document.getElementById("winner").innerHTML = winner
       ? '<div><small>Winning patch</small><strong>' + esc(winner.agent) +
diff --git a/src/runner.js b/src/runner.js
index 3f3348b..eaaf984 100644
--- a/src/runner.js
+++ b/src/runner.js
@@ -102,11 +102,111 @@ async function mapLimit(items, limit, mapper) {
   return results;
 }
 
+async function runStoredCommands({
+  owner,
+  phase,
+  outputDirectory,
+  repoPath,
+  runDir,
+  commands,
+  timeoutMs,
+  onProgress
+}) {
+  if (commands.length === 0) return [];
+
+  const directory = path.join(runDir, outputDirectory);
+  await mkdir(directory, { recursive: true });
+  const commandResults = await runChecks(repoPath, commands, {
+    timeoutMs: Math.min(timeoutMs, 10 * 60 * 1000),
+    onProgress(command) {
+      onProgress?.(owner, phase, `${owner}: ${command}`);
+    }
+  });
+  const stored = [];
+  for (const [index, commandResult] of commandResults.entries()) {
+    const prefix = `${safeName(owner)}.${phase}-${index + 1}`;
+    const stdoutPath = path.join(directory, `${prefix}.stdout.log`);
+    const stderrPath = path.join(directory, `${prefix}.stderr.log`);
+    await Promise.all([
+      writeFile(stdoutPath, commandResult.stdout, "utf8"),
+      writeFile(stderrPath, commandResult.stderr, "utf8")
+    ]);
+    stored.push({
+      command: commandResult.command,
+      passed: commandResult.passed,
+      exit_code: commandResult.exit_code,
+      duration_ms: commandResult.duration_ms,
+      timed_out: commandResult.timed_out,
+      truncated: commandResult.truncated,
+      spawn_error: commandResult.spawn_error,
+      stdout_path: path.relative(runDir, stdoutPath),
+      stderr_path: path.relative(runDir, stderrPath)
+    });
+  }
+  return stored;
+}
+
+async function runBaseline({
+  worktreePath,
+  runDir,
+  setup,
+  checks,
+  timeoutMs,
+  onProgress
+}) {
+  onProgress?.("baseline", "baseline", "running baseline verification");
+  const setupResults = await runStoredCommands({
+    owner: "baseline",
+    phase: "setup",
+    outputDirectory: "baseline",
+    repoPath: worktreePath,
+    runDir,
+    commands: setup,
+    timeoutMs,
+    onProgress
+  });
+  if (setupResults.some((result) => !result.passed)) {
+    return {
+      status: "setup_failed",
+      setup: setupResults,
+      checks: []
+    };
+  }
+  const setupRepository = await repositoryInfo(worktreePath);
+  if (setupRepository.dirty) {
+    return {
+      status: "setup_failed",
+      error:
+        "Setup commands changed tracked or unignored files: " +
+        setupRepository.status.join(", "),
+      setup: setupResults,
+      checks: []
+    };
+  }
+
+  const checkResults = await runStoredCommands({
+    owner: "baseline",
+    phase: "check",
+    outputDirectory: "baseline",
+    repoPath: worktreePath,
+    runDir,
+    commands: checks,
+    timeoutMs,
+    onProgress
+  });
+  return {
+    status: checkResults.every((result) => result.passed) ? "passed" : "failed",
+    setup: setupResults,
+    checks: checkResults
+  };
+}
+
 async function runOneAgent({
   prepared,
   repoPath,
   run,
   runDir,
+  setup,
   checks,
   timeoutMs,
   keepWorktrees,
@@ -126,6 +226,7 @@ async function runOneAgent({
       invocation: adapter.command,
       process: failedProcess(`Command "${adapter.command}" was not found on PATH`),
       patch: emptyPatch(relativePatchPath),
+      setup: [],
       checks: [],
       risks: [],
       score: { total: 0, components: {}, checks_passed: 0, checks_total: 0 }
@@ -133,6 +234,48 @@ async function runOneAgent({
     return { ...result, score: scoreResult(result) };
   }
 
+  const setupResults = await runStoredCommands({
+    owner: name,
+    phase: "setup",
+    outputDirectory: "agents",
+    repoPath: worktreePath,
+    runDir,
+    commands: setup,
+    timeoutMs,
+    onProgress
+  });
+  if (setupResults.some((result) => !result.passed)) {
+    const result = {
+      agent: name,
+      status: "setup_failed",
+      invocation: adapter.command,
+      process: failedProcess("A setup command failed"),
+      patch: emptyPatch(relativePatchPath),
+      setup: setupResults,
+      checks: [],
+      risks: [],
+      worktree: keepWorktrees ? worktreePath : null
+    };
+    return { ...result, score: scoreResult(result) };
+  }
+  const setupRepository = await repositoryInfo(worktreePath);
+  if (setupRepository.dirty) {
+    const result = {
+      agent: name,
+      status: "setup_failed",
+      invocation: adapter.command,
+      process: failedProcess(
+        `Setup commands changed tracked or unignored files: ${setupRepository.status.join(", ")}`
+      ),
+      patch: emptyPatch(relativePatchPath),
+      setup: setupResults,
+      checks: [],
+      risks: [],
+      worktree: keepWorktrees ? worktreePath : null
+    };
+    return { ...result, score: scoreResult(result) };
+  }
+
   const prompt = buildPrompt(run.task);
   const invocation = buildAgentInvocation(adapter, {
     prompt,
@@ -162,39 +305,16 @@ async function runOneAgent({
   patch.path = relativePatchPath;
   const risks = detectRisks({ ...patch, text });
 
-  const checkResults = await runChecks(worktreePath, checks, {
-    timeoutMs: Math.min(timeoutMs, 10 * 60 * 1000),
-    onProgress(command) {
-      onProgress?.(name, "check", `${name}: ${command}`);
-    }
+  const storedChecks = await runStoredCommands({
+    owner: name,
+    phase: "check",
+    outputDirectory: "agents",
+    repoPath: worktreePath,
+    runDir,
+    commands: checks,
+    timeoutMs,
+    onProgress
   });
-  const storedChecks = [];
-  for (const [index, check] of checkResults.entries()) {
-    const checkPrefix = `${safeName(name)}.check-${index + 1}`;
-    const checkStdoutPath = path.join(
-      agentDirectory,
-      `${checkPrefix}.stdout.log`
-    );
-    const checkStderrPath = path.join(
-      agentDirectory,
-      `${checkPrefix}.stderr.log`
-    );
-    await Promise.all([
-      writeFile(checkStdoutPath, check.stdout, "utf8"),
-      writeFile(checkStderrPath, check.stderr, "utf8")
-    ]);
-    storedChecks.push({
-      command: check.command,
-      passed: check.passed,
-      exit_code: check.exit_code,
-      duration_ms: check.duration_ms,
-      timed_out: check.timed_out,
-      truncated: check.truncated,
-      spawn_error: check.spawn_error,
-      stdout_path: path.relative(runDir, checkStdoutPath),
-      stderr_path: path.relative(runDir, checkStderrPath)
-    });
-  }
 
   const result = {
     agent: name,
@@ -218,6 +338,7 @@ async function runOneAgent({
       stderr_path: path.relative(runDir, stderrPath)
     },
     patch,
+    setup: setupResults,
     checks: storedChecks,
     risks,
     worktree: keepWorktrees ? worktreePath : null
@@ -232,12 +353,19 @@ export async function planCompetition({
   config,
   task,
   agents,
+  explicitSetup,
+  noSetup = false,
   explicitChecks,
   noChecks = false,
   timeoutMs,
   maxParallel
 }) {
   const repository = await repositoryInfo(repoPath);
+  const setup = noSetup
+    ? []
+    : explicitSetup?.length
+      ? explicitSetup
+      : (config.setup ?? []);
   const checks = noChecks
     ? []
     : explicitChecks?.length
@@ -277,6 +405,7 @@ export async function planCompetition({
       bytes: Buffer.byteLength(task.content, "utf8")
     },
     agents: selectedAgents,
+    setup,
     checks,
     timeout_ms: timeoutMs ?? config.timeoutMs,
     max_parallel: maxParallel ?? config.maxParallel
@@ -289,6 +418,8 @@ export async function runCompetition({
   configPath,
   task,
   agents,
+  explicitSetup,
+  noSetup = false,
   explicitChecks,
   noChecks = false,
   timeoutMs,
@@ -303,6 +434,8 @@ export async function runCompetition({
     config,
     task,
     agents,
+    explicitSetup,
+    noSetup,
     explicitChecks,
     noChecks,
     timeoutMs,
@@ -352,20 +485,44 @@ export async function runCompetition({
       content: task.content
     },
     agents: plan.agents,
+    setup: plan.setup,
     checks: plan.checks,
     timeout_ms: plan.timeout_ms,
     max_parallel: plan.max_parallel,
     results: [],
+    baseline: null,
     winner: null
   };
   await saveRun(repoPath, run);
 
   const prepared = [];
   try {
+    if (plan.checks.length > 0) {
+      const baselinePath = path.join(worktreeRoot, "baseline", "worktree");
+      await createWorktree(repoPath, baselinePath, plan.repository.commit);
+      try {
+        run.baseline = await runBaseline({
+          worktreePath: baselinePath,
+          runDir,
+          setup: plan.setup,
+          checks: plan.checks,
+          timeoutMs: plan.timeout_ms,
+          onProgress
+        });
+        await saveRun(repoPath, run);
+      } finally {
+        await removeWorktree(repoPath, baselinePath);
+      }
+    }
+
     for (const name of plan.agents) {
       const adapter = getAdapter(config, name);
       const executable = await resolveExecutable(adapter.command);
-      const worktreePath = path.join(worktreeRoot, safeName(name));
+      const worktreePath = path.join(
+        worktreeRoot,
+        "agents",
+        safeName(name)
+      );
       if (executable) {
         onProgress?.(name, "prepare", `creating ${name} worktree`);
         await createWorktree(
@@ -386,6 +543,10 @@ export async function runCompetition({
     for (const item of prepared.filter((entry) => entry.created)) {
       await removeWorktree(repoPath, item.worktreePath);
     }
+    run.status = "failed";
+    run.completed_at = new Date().toISOString();
+    run.error = error instanceof Error ? error.message : String(error);
+    await saveRun(repoPath, run);
     throw error;
   }
 
@@ -400,6 +561,7 @@ export async function runCompetition({
             repoPath,
             run,
             runDir,
+            setup: plan.setup,
             checks: plan.checks,
             timeoutMs: plan.timeout_ms,
             keepWorktrees,
@@ -418,6 +580,7 @@ export async function runCompetition({
               error instanceof Error ? error.message : String(error)
             ),
             patch: emptyPatch(relativePatchPath),
+            setup: [],
             checks: [],
             risks: [],
             worktree: keepWorktrees ? item.worktreePath : null
@@ -434,7 +597,10 @@ export async function runCompetition({
 
     run.results = rankResults(results);
     const best = run.results.find(
-      (result) => result.score.total > 0 && !result.patch.empty
+      (result) =>
+        result.status === "verified" &&
+        result.score.total > 0 &&
+        !result.patch.empty
     );
     run.winner = best
       ? {
diff --git a/test/config.test.js b/test/config.test.js
new file mode 100644
index 0000000..06747d1
--- /dev/null
+++ b/test/config.test.js
@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { DEFAULT_CONFIG, sampleConfig, validateConfig } from "../src/config.js";
+
+test("default and generated configs include an empty setup stage", () => {
+  assert.deepEqual(DEFAULT_CONFIG.setup, []);
+  assert.deepEqual(sampleConfig().setup, []);
+  assert.equal(validateConfig(DEFAULT_CONFIG), DEFAULT_CONFIG);
+});
+
+test("setup commands must be a list of non-empty strings", () => {
+  const invalid = {
+    ...DEFAULT_CONFIG,
+    setup: ["npm ci", ""]
+  };
+  assert.throws(
+    () => validateConfig(invalid),
+    (error) =>
+      error.code === "INVALID_CONFIG" &&
+      /setup must be an array of non-empty command strings/.test(error.message)
+  );
+});
diff --git a/test/integration.test.js b/test/integration.test.js
index b383c84..8eca00f 100644
--- a/test/integration.test.js
+++ b/test/integration.test.js
@@ -76,6 +76,7 @@ test("two agents compete, checks select a winner, and its patch applies", async
   });
 
   assert.equal(run.status, "completed");
+  assert.equal(run.baseline.status, "failed");
   assert.equal(run.winner.agent, "good");
   assert.equal(run.results[0].agent, "good");
   assert.equal(run.results[0].checks[0].passed, true);
@@ -121,6 +122,143 @@ test("two agents compete, checks select a winner, and its patch applies", async
   );
 });
 
+test("a non-empty patch cannot win when its checks fail", async () => {
+  const repoPath = await createRepository();
+  const fakeAgent = path.join(fixtureDirectory, "fake-agent.js");
+  const config = {
+    version: 1,
+    defaultAgents: ["bad"],
+    maxParallel: 1,
+    timeoutMs: 30000,
+    checks: "auto",
+    agents: {
+      bad: {
+        command: process.execPath,
+        args: [fakeAgent, "bad"],
+        prompt: "stdin",
+        versionArgs: ["--version"]
+      }
+    }
+  };
+
+  const run = await runCompetition({
+    repoPath,
+    config,
+    configPath: "integration-test",
+    task: {
+      source: "test-task.md",
+      title: "Produce an invalid solution",
+      content: "# Produce an invalid solution\n\nWrite a solution that does not pass."
+    },
+    explicitChecks: [
+      `${JSON.stringify(process.execPath)} -e "process.exit(1)"`
+    ]
+  });
+
+  assert.equal(run.status, "completed");
+  assert.equal(run.results[0].status, "checks_failed");
+  assert.equal(run.results[0].patch.empty, false);
+  assert.ok(run.results[0].score.total > 0);
+  assert.equal(run.winner, null);
+});
+
+test("setup commands prepare baseline and agent worktrees", async () => {
+  const repoPath = await createRepository();
+  const fakeAgent = path.join(fixtureDirectory, "fake-agent.js");
+  const verify = path.join(fixtureDirectory, "verify-solution.js");
+  await writeFile(
+    path.join(repoPath, ".gitignore"),
+    ".patchleague/\n.setup-ready\n",
+    "utf8"
+  );
+  await git(repoPath, ["add", ".gitignore"]);
+  await git(repoPath, ["commit", "-m", "ignore setup marker"]);
+
+  const setupCommand =
+    `${JSON.stringify(process.execPath)} -e ` +
+    `"require('node:fs').writeFileSync('.setup-ready','yes')"`;
+  const config = {
+    version: 1,
+    defaultAgents: ["good"],
+    maxParallel: 1,
+    timeoutMs: 30000,
+    setup: [setupCommand],
+    checks: "auto",
+    agents: {
+      good: {
+        command: process.execPath,
+        args: [fakeAgent, "good"],
+        prompt: "stdin",
+        versionArgs: ["--version"]
+      }
+    }
+  };
+
+  const run = await runCompetition({
+    repoPath,
+    config,
+    configPath: "integration-test",
+    task: {
+      source: "test-task.md",
+      title: "Use a prepared worktree",
+      content: "# Use a prepared worktree\n\nWrite correct to solution.txt."
+    },
+    explicitChecks: [
+      `${JSON.stringify(process.execPath)} -e "process.exit(require('node:fs').existsSync('.setup-ready') ? 0 : 1)"`,
+      `node "${verify}"`
+    ]
+  });
+
+  assert.equal(run.baseline.status, "failed");
+  assert.equal(run.baseline.setup[0].passed, true);
+  assert.equal(run.results[0].setup[0].passed, true);
+  assert.equal(run.results[0].status, "verified");
+  assert.equal(run.winner.agent, "good");
+});
+
+test("setup commands cannot contaminate candidate patches", async () => {
+  const repoPath = await createRepository();
+  const fakeAgent = path.join(fixtureDirectory, "fake-agent.js");
+  const setupCommand =
+    `${JSON.stringify(process.execPath)} -e ` +
+    `"require('node:fs').writeFileSync('unexpected.txt','setup output')"`;
+  const config = {
+    version: 1,
+    defaultAgents: ["good"],
+    maxParallel: 1,
+    timeoutMs: 30000,
+    setup: [setupCommand],
+    checks: "auto",
+    agents: {
+      good: {
+        command: process.execPath,
+        args: [fakeAgent, "good"],
+        prompt: "stdin",
+        versionArgs: ["--version"]
+      }
+    }
+  };
+
+  const run = await runCompetition({
+    repoPath,
+    config,
+    configPath: "integration-test",
+    task: {
+      source: "test-task.md",
+      title: "Reject setup output",
+      content: "# Reject setup output\n\nDo not include setup artifacts."
+    },
+    explicitChecks: [`${JSON.stringify(process.execPath)} -e "process.exit(0)"`]
+  });
+
+  assert.equal(run.baseline.status, "setup_failed");
+  assert.match(run.baseline.error, /unexpected\.txt/);
+  assert.equal(run.results[0].status, "setup_failed");
+  assert.match(run.results[0].process.spawn_error, /unexpected\.txt/);
+  assert.equal(run.results[0].patch.empty, true);
+  assert.equal(run.winner, null);
+});
+
 test("dry run reports a dirty repository without starting agents", async () => {
   const repoPath = await createRepository();
   await writeFile(path.join(repoPath, "README.md"), "# Dirty fixture\n", "utf8");
diff --git a/test/report.test.js b/test/report.test.js
index f8b9993..aab3aa9 100644
--- a/test/report.test.js
+++ b/test/report.test.js
@@ -18,5 +18,5 @@ test("report is self-contained and escapes embedded script content", () => {
     html,
     /<script id="run-data" type="application\/json">.*<\/script><script>alert/
   );
-  assert.match(html, /No source code or agent logs were uploaded/);
+  assert.match(html, /Configured agent providers may receive repository context/);
 });