perf(graph): work-conserving slot scheduler replaces barrier batching - #12

Problem

executeGraph scheduled ready nodes in barrier batches: readyNodes().slice(0, concurrency) followed by await Promise.all(batch). The slowest node of every batch gated the dispatch of the next batch. LLM subagent durations are wildly heterogeneous (a node with maxRetries=2 can legitimately run 3× a sibling's wall time), so:

• fast nodes finish and their slots sit idle while unrelated stragglers run out the clock;
• dependents of quick parents wait behind slow siblings they don't depend on.

Makespan degenerated into Σ per-batch maxima instead of tracking the concurrency-limited critical path. Worst case: level 1 = [5s node, 300s node], a node depending only on the 5s one still waits 300s.

Change

Replace the batch loop with a work-conserving scheduler:

• Up to concurrency nodes stay in flight; every completion immediately re-routes dynamic edges, settles skips, and refills the freed slot.
• All scheduling decisions flow through a single serialized pump() chain (completions enqueue onto it), so concurrent completions can never double-dispatch a node.
• New interleaving handled explicitly: under slot scheduling a rework/conditional route can target a node still executing (impossible under barriers). Those activations are deferred (deferredActivations) and applied when the target lands; the rework budget is re-checked at activation time so two failures deferring onto the same fixer cannot jointly overspend it.
• Phase ordering per pump pass is identical to the old loop (route evaluation → approval pause → skip propagation → dispatch), so approval pauses, rework loops, skip settlement, the execution budget rail, persistence points, and onNode ordering all behave exactly as before — all 8 existing graph-execution tests pass unmodified.

Benchmark

Same DAG under both schedulers (concurrency: 2): one 3s straggler independent of a 100ms → 1s → 1s chain.

−28% makespan on a 4-node graph; the gain grows with graph width and duration variance (real LLM graphs vary 10s–300s per node). Reproduce: fixture child that sleeps N ms via Atomics.wait, driven through the real spawnSubagent path with process.argv[1] pointed at it (same technique as the existing tests).

Regression test

New test pins the scheduling property, not a timing constant: a node depending only on a quick sibling must start while the straggler is still in flight (startedAt(after) + 800 < finishedAt(slow)), with the dependency edge still respected causally. The 800 ms margin keeps it robust on loaded CI runners.

Verification

• Full suite: 500/500 pass (npx tsx --test src/test/*.test.ts), tsc --noEmit clean
• All 8 pre-existing graph-execution tests pass unmodified (approval pauses, rework loops, skip propagation, resume, budget rail)