@@ -41,7 +41,10 @@ Before you finish a change, run `typecheck`, `lint`, `test`, and `build`. All fo
 
 - Run every heavy job through the guard: `bun run balance`, `bun run perf:check`, or `bun run heavy -- <command...>` for anything else heavy, such as an audit or a shots script. Never call `tools/balance/simulate.ts` or a heavy audit directly.
 - The guard aims at about 70% of the machine: a 1 minute load near 0.70 x cores (8.4 on 12, `HEAVY_TARGET_LOAD` to change it). A job starts only when the load, the jobs started in the last minute, and its own cost fit under that target.
-- **Timing** jobs (`perf:check` and the timing audits, `splash.ts`, and any command it does not know) run alone. **CPU** jobs (the balance bot, nightly, wave snapshots, determinism) run one at a time beside audits and size their `WORKERS` to the budget, up to 8. **Shared** jobs (the shots scripts, `taps.ts`, and the other screenshot and functional audits) run up to 4 at once, each costing about one core per browser context. Jobs queue fairly by arrival. `--timing`, `--cpu`, or `--shared` before the command overrides the class.
+- **Timing** jobs (`perf:check` and the timing audits, `splash.ts`, and any command it does not know) run alone. **CPU** jobs (the balance bot, nightly, wave snapshots, determinism) run one at a time beside audits and size their `WORKERS` to the budget, up to 8. **Shared** jobs (the shots scripts, `taps.ts`, and the other screenshot and functional audits) run up to 4 at once, each costing about one core per browser context. `--timing`, `--cpu`, or `--shared` before the command overrides the class.
+- **Long jobs yield.** The balance bot plays its runs in chunks of about 25 (a wave pass by snapshot slot), the nightly yields between its jobs, `splash.ts` between profiles, and `perf:check` between scenarios. At each boundary the guard hands over to any waiting job and queues again, so nobody waits long behind one batch. Results are the same as one unchunked run. A new long script should do the same with `yieldTurn` from `tools/heavy/turn.ts`.
+- **The queue goes round by worktree.** A worktree that just had a turn goes behind other worktrees' waiting jobs; otherwise jobs go by arrival. A Shared job may start ahead of a Timing or CPU job that only waits for a running CPU job (backfill).
+- **A solo turn is a 10 minute lease** (`HEAVY_LEASE_MINUTES`). A job past it keeps running, but the guard says so loudly and waiting jobs name it: split such a job so it yields.
 - `bun run test` sizes vitest's workers to what is left of the budget (at least 2) and counts itself, so test runs from several agents share the target. CI is unaffected.
 - The guard refuses a sixth balance batch per branch without `--allow-more` (`bun run heavy -- --reset-budget` starts the count again). How it works is in [`tools/heavy/README.md`](./tools/heavy/README.md).
 - Cap tuning at about three batches per change. Use 100 runs to sort ideas and 200 only to confirm the final numbers. Results within a few points of a target are fine: list misses as follow-ups instead of running more batches.
 
@@ -3,6 +3,7 @@ import { connect } from 'node:net'
 import { loadavg } from 'node:os'
 import { resolve } from 'node:path'
 
+import { yieldTurnAsync } from '../heavy/turn'
 import { launch, wait } from './lib'
 import { type FrameRow, calibrationMs, measureScenario } from './measure'
 
@@ -104,7 +105,11 @@ const measureAll = async (base: string) => {
   const browser = await launch()
   const calibration = await calibrationMs(browser)
   const rows: Array<FrameRow> = []
-  for (const name of SCENARIO_NAMES) {
+  for (const [index, name] of SCENARIO_NAMES.entries()) {
+    // NOTE: under the heavy guard, other jobs may go between scenarios.
+    if (index > 0) {
+      await yieldTurnAsync(`the ${SCENARIO_NAMES[index - 1]} scenario`, 1)
+    }
     for (const rate of RATES) {
       const trials: Array<FrameRow> = []
       for (let trial = 0; trial < TRIALS; trial++) {
 
@@ -9,9 +9,12 @@
 // tasks, and with PROFILE=1 the functions that took the most CPU time before
 // the splash hid, and with NETWORK=1 every request the page and its workers
 // made, with when it started and finished. ONLY=<profile> runs one profile.
+// Under the heavy guard it yields the guard's turn between profiles, so
+// other jobs go in between instead of waiting for all three.
 //   BASE=http://localhost:4173/ bun splash.ts
 import type { BrowserContext } from 'playwright-core'
 
+import { yieldTurnAsync } from '../heavy/turn'
 import { GAME, launch, wait } from './lib'
 
 const BASE = process.env.BASE ?? GAME
@@ -210,9 +213,13 @@ type Visit = Readonly<{
 }>
 
 const browser = await launch()
-for (const profile of PROFILES.filter(
+const chosen = PROFILES.filter(
   ({ name }) => ONLY === undefined || ONLY === name,
-)) {
+)
+for (const [index, profile] of chosen.entries()) {
+  if (index > 0) {
+    await yieldTurnAsync(`the ${chosen[index - 1]!.name} profile`, 1)
+  }
   const context = await browser.newContext({
     viewport: { width: 844, height: 390 },
     deviceScaleFactor: 2,
 
@@ -5,6 +5,8 @@
 // targets and the stored baseline, and writes
 // tools/balance/reports/<YYYY-MM-DD>.md. `--update-baseline` rewrites
 // tools/balance/baseline.json, which is also written when it is missing.
+// Each job yields the guard's turn between its chunks, and the suite
+// yields between jobs, so other agents' jobs go in between.
 // `--extend-baseline` adds only the metrics the baseline lacks. `--runs n`
 // and `--wave-runs n` shrink the jobs for a quick try.
 
@@ -18,6 +20,7 @@ import {
   FileSystem,
   Option,
   Path,
+  Ref,
   Runtime,
   Schema,
   String,
@@ -28,6 +31,7 @@ import { ChildProcess, ChildProcessSpawner } from 'effect/process'
 import * as NodeRuntime from '@effect/platform-node/NodeRuntime'
 import * as NodeServices from '@effect/platform-node/NodeServices'
 
+import { yieldTurn } from '../heavy/turn'
 import { balanceModel } from './model'
 import {
   Baseline,
@@ -86,6 +90,7 @@ const SummaryJson = Schema.fromJsonString(Summary)
 const runJob = (
   job: Job,
   outPath: string,
+  maybeWorkers: Option.Option<number>,
 ): Effect.Effect<
   Summary,
   JobFailed | BadSummary | PlatformError,
@@ -101,7 +106,10 @@ const runJob = (
           process.execPath,
           [SIMULATE, ...job.args, '--json', outPath],
           {
-            env: job.env,
+            env: Option.match(maybeWorkers, {
+              onNone: () => job.env,
+              onSome: workers => ({ ...job.env, WORKERS: `${workers}` }),
+            }),
             extendEnv: true,
             stdin: 'inherit',
             stdout: 'inherit',
@@ -212,8 +220,23 @@ const program = Effect.gen(function* () {
   const date = localDate(startedAt)
   const scratch = yield* fs.makeTempDirectoryScoped({ prefix: 'nightly-' })
   const jobs = nightlyJobs(invocation.sizes)
-  const summaries = yield* Effect.forEach(jobs, job =>
-    runJob(job, path.join(scratch, `${job.id}.json`)),
+  // NOTE: between jobs the suite yields the guard's turn, and runs the next
+  // job with the WORKERS the guard granted.
+  const grantedWorkers = yield* Ref.make(Option.none<number>())
+  const summaries = yield* Effect.forEach(jobs, (job, index) =>
+    Effect.gen(function* () {
+      if (index > 0) {
+        const maybeGranted = yield* yieldTurn(`the job before ${job.id}`)
+        if (Option.isSome(maybeGranted)) {
+          yield* Ref.set(grantedWorkers, maybeGranted)
+        }
+      }
+      return yield* runJob(
+        job,
+        path.join(scratch, `${job.id}.json`),
+        yield* Ref.get(grantedWorkers),
+      )
+    }),
   )
   const played = collect(jobs, summaries)
   const model = balanceModel()
 
@@ -11,7 +11,11 @@
 //   bun run balance -- --wave all --runs 100   (every campaign wave)
 // Flags: --runs n, --first-seed n, --wave n|all, --slots n (snapshot slots,
 // 10 by default), and --json path (also write the summary the nightly suite
-// reads). It drives the game's own init model and update with the bot in
+// reads). Under the guard it plays the runs in chunks of about 25 (by
+// slot groups for a wave pass) and yields the guard's turn between them, so
+// waiting jobs go in between; the report is the same as one unchunked
+// batch, since every run is seeded by its index. HEAVY_CHUNK_RUNS=n sets
+// the chunk, and 0 plays it whole. It drives the game's own init model and update with the bot in
 // tools/balance/bot.ts and prints survival per wave, run length, the money
 // curve, and which zombie kinds cost the bot the most hearts. Nothing here
 // ships with the game.
@@ -46,6 +50,8 @@ type NewKindLog = import('./bot').NewKindLog
 type BotOptions = import('./bot').BotOptions
 const { FINAL_WAVE } = await import('../../src/waves')
 const summary = await import('./summary')
+const turn = await import('../heavy/turn')
+const { nextChunk } = await import('../heavy/decision')
 
 // TUNE=path/to/tune.ts loads a module whose default export edits the
 // tables in place before the runs, so a balance idea can be tried without
@@ -106,6 +112,7 @@ const firstSeed = Number(flagValue('--first-seed') ?? positional[1] ?? 1)
 const slots = Number(flagValue('--slots') ?? 10)
 const seedAt = (index: number) => seedFrom(firstSeed, index)
 const WORKERS = Math.max(1, Number(process.env.WORKERS ?? 1))
+const IS_CHUNKED = turn.isUnderGuard()
 const started = performance.now()
 const STYLE = SWAPS_BACK ? 'SwapsBack' : 'Default'
 
@@ -125,9 +132,13 @@ const waveList = (flag: string): Array<number> => {
 // A worker plays one share of the work and writes its results as JSON, so
 // WORKERS=n gives the same report as one process, only sooner. A campaign
 // worker plays a slice of the seeds, from:to. A wave worker plays the
-// snapshot slots whose index modulo the worker count is its own, index:count.
+// snapshot slots whose index modulo the worker count is its own, index:count,
+// among the slots of its chunk, WORKER_SLOTS=from:to.
 if (process.env.WORKER_SLICE !== undefined) {
   const [from, to] = process.env.WORKER_SLICE.split(':').map(Number)
+  const [slotFrom, slotTo] = (process.env.WORKER_SLOTS ?? `0:${slots}`)
+    .split(':')
+    .map(Number)
   const output =
     WAVE_FLAG === undefined
       ? Array.from({ length: to! - from! }, (_, offset) =>
@@ -136,19 +147,28 @@ if (process.env.WORKER_SLICE !== undefined) {
       : playWavePass(
           { waves: waveList(WAVE_FLAG), runs, slots, firstSeed },
           OPTIONS,
-          slot => slot % to! === from!,
+          slot => slot >= slotFrom! && slot < slotTo! && slot % to! === from!,
         )
   writeFileSync(process.env.WORKER_OUT!, JSON.stringify(output))
   process.exit(0)
 }
 
 const SELF = fileURLToPath(import.meta.url)
 
-const runWorker = (slice: string, index: number): Promise<unknown> =>
+const runWorker = (
+  slice: string,
+  index: number,
+  slotRange?: string,
+): Promise<unknown> =>
   new Promise((resolve, reject) => {
     const out = `/tmp/simulate-${process.pid}-${index}.json`
     const child = spawn(process.execPath, [SELF, ...argv], {
-      env: { ...process.env, WORKER_SLICE: slice, WORKER_OUT: out },
+      env: {
+        ...process.env,
+        WORKER_SLICE: slice,
+        WORKER_OUT: out,
+        ...(slotRange === undefined ? {} : { WORKER_SLOTS: slotRange }),
+      },
       stdio: 'inherit',
     })
     child.on('error', reject)
@@ -159,35 +179,97 @@ const runWorker = (slice: string, index: number): Promise<unknown> =>
     )
   })
 
-const playAll = async (): Promise<Array<RunResult>> => {
-  if (WORKERS === 1) {
-    return Array.from({ length: runs }, (_, index) =>
-      runOnce(seedAt(index), OPTIONS),
+// NOTE: the guard may give a later chunk more or fewer workers.
+let workers = WORKERS
+
+const playRange = async (
+  first: number,
+  end: number,
+): Promise<Array<RunResult>> => {
+  if (workers === 1) {
+    return Array.from({ length: end - first }, (_, offset) =>
+      runOnce(seedAt(first + offset), OPTIONS),
     )
   }
-  const per = Math.ceil(runs / WORKERS)
-  const slices = Array.from({ length: WORKERS }, (_, index) => [
-    index * per,
-    Math.min(runs, (index + 1) * per),
+  const per = Math.ceil((end - first) / workers)
+  const slices = Array.from({ length: workers }, (_, index) => [
+    first + index * per,
+    Math.min(end, first + (index + 1) * per),
   ]).filter(([from, to]) => to! > from!)
   const outputs = await Promise.all(
     slices.map(([from, to], index) => runWorker(`${from}:${to}`, index)),
   )
   return outputs.flat() as Array<RunResult>
 }
 
-const playWaves = async (waves: Array<number>): Promise<Array<WaveRun>> => {
+// NOTE: plays the runs in chunks, in seed order, yielding the guard's turn
+// between chunks. Run i is always seed i, so the results do not depend on
+// where the chunks fall.
+const playAll = async (): Promise<Array<RunResult>> => {
+  const results: Array<RunResult> = []
+  for (let done = 0; done < runs;) {
+    if (done > 0) {
+      workers = await turn.yieldTurnAsync(`${done} of ${runs} runs`, workers)
+    }
+    const [from, to] = nextChunk(
+      done,
+      runs,
+      IS_CHUNKED ? turn.chunkRuns(workers) : 0,
+    )
+    results.push(...(await playRange(from, to)))
+    done = to
+  }
+  return results
+}
+
+const playSlots = async (
+  waves: Array<number>,
+  slotFrom: number,
+  slotTo: number,
+): Promise<Array<WaveRun>> => {
   const pass = { waves, runs, slots, firstSeed }
-  const workers = Math.min(WORKERS, slots)
-  if (workers === 1) return playWavePass(pass, OPTIONS)
+  const count = Math.min(workers, slotTo - slotFrom)
+  if (count === 1) {
+    return playWavePass(
+      pass,
+      OPTIONS,
+      slot => slot >= slotFrom && slot < slotTo,
+    )
+  }
   const outputs = await Promise.all(
-    Array.from({ length: workers }, (_, index) =>
-      runWorker(`${index}:${workers}`, index),
+    Array.from({ length: count }, (_, index) =>
+      runWorker(`${index}:${count}`, index, `${slotFrom}:${slotTo}`),
     ),
   )
   return outputs.flat() as Array<WaveRun>
 }
 
+// NOTE: a wave pass chunks by snapshot slot, one slot a worker, so each
+// slot's snapshots are found once. The runs are sorted by wave and run, so
+// the order never depends on the chunks or the workers.
+const playWaves = async (waves: Array<number>): Promise<Array<WaveRun>> => {
+  const waveRuns: Array<WaveRun> = []
+  for (let done = 0; done < slots;) {
+    if (done > 0) {
+      workers = await turn.yieldTurnAsync(
+        `${done} of ${slots} snapshot slots`,
+        workers,
+      )
+    }
+    const [from, to] = nextChunk(
+      done,
+      slots,
+      IS_CHUNKED && turn.chunkRuns(workers) > 0 ? workers : 0,
+    )
+    waveRuns.push(...(await playSlots(waves, from, to)))
+    done = to
+  }
+  return waveRuns.sort(
+    (first, second) =>
+      first.wave - second.wave || first.waveSeed - second.waveSeed,
+  )
+}
+
 const writeJson = (value: unknown) => {
   if (JSON_OUT !== undefined) {
     writeFileSync(JSON_OUT, `${JSON.stringify(value, null, 2)}\n`)