oxmutate 1.0.3 → 1.2.0

package/README.md

@@ -45,7 +45,7 @@ oxc, not affiliated with the oxc project.
 
 | | Stryker 10 | oxmutate 1.0 |
 | :-- | :-- | :-- |
-| Mutant set | 17 mutator families | the same 17, the same mutants (720 of 720 on es-toolkit) |
+| Mutant set | 17 mutator families | the same 17, the same mutants (720 of 720 on es-toolkit), plus `NumericLiteral` (0 → 1, 1 → 0, n → n + 1): +6.6% mutants on burgee/paratext, 19 of them survivors Stryker cannot report. `--stryker-compat` gives Stryker's set exactly |
 | Verdicts | — | the same as Stryker's on 99.9% of mutants ([measured](#compatibility)) |
 | Instrumentation | Babel, file by file | Rust on oxc, every file in parallel: 720 mutants in 35 ms |
 | Test runs | a Vitest run per mutant | each covering test re-run per mutant inside a warm Vitest worker |
@@ -187,10 +187,10 @@ setting a value inside the worker that already has the tests loaded.
 | :-- | :-- |
 | The dry run must pass | A suite that fails with no mutant armed scores nothing (exit 3) |
 | Re-parse | Every instrumented file is parsed again before it runs; one that does not parse stops the run (exit 3) instead of scoring a broken file |
-| Canary | The unmutated test must still pass after mutants run in a context; if a mutant left a cache, a registry or a fixture behind, the context restarts and the suspect verdicts run again |
+| Canary | The unmutated test must still pass after mutants run in a context, with its `beforeEach`/`afterEach` hooks re-run around every run, file-level ones included; if a mutant left a cache, a registry or a fixture behind, the context restarts and the suspect verdicts run again. A kill that follows unchecked runs is checked at once and decided again from clean state, so no kill rests on another mutant's leftovers |
 | Survivor confirmation | A survivor is re-run with the mutant armed across its covering tests in one file, as Stryker arms it, so a mutant that only fails across tests is killed |
-| Watchdog | A synchronous runaway is stopped and its server replaced; the stop is re-run at 3x the budget before it is reported as a timeout |
-| Static mutants | Code that runs at import is re-run with the mutant armed from process start, against the files that load it |
+| Watchdog | A synchronous runaway is stopped and its server replaced; the stop is re-run at 3x the budget before it is reported as a timeout. A stop whose worker was idle inside a test body (its event loop still turning, by a heartbeat, and its server under 25% of a core) is a hang, not a slow test: it is a Timeout as it stands, the way Stryker scores it, with no 3x re-run |
+| Static mutants | Code that runs at import is decided in a live worker: the mutant is armed, the module registry reset and the test file collected again, against the files that load it. A file whose collection changes globals, `process.env` or a built-in prototype, or a mutant that leaves a trace, goes back to a fresh worker per mutant (`OXMUTATE_ISOLATE_STATIC=1` sends all of them there) |
 | Flaky tests | Tests that behave differently across two dry runs have their mutants re-run; a verdict that changes is reported `flaky` |
 | No orphans | Every Vitest server exits when its run does, killed or not |
 
@@ -249,11 +249,20 @@ Of the two disagreements left, one is a Stryker timeout on a loop that ends (its
 it; the covering tests pass). The other is a mutant Stryker scored as a runtime error, so it has
 no Stryker verdict to compare.
 
-**Speed is not yet a published number.** On a shared laptop, paratext took 180.0 s under oxmutate
-and 427.4 s under Stryker, at 0.375 and 0.620 CPU-seconds a mutant; on controlroom oxmutate used
-less CPU (0.092 against 0.171 CPU-seconds a mutant) and was slower by the wall clock (107.2 s
-against 94.3 s). The laptop's load moved a run by more than the difference, so the wall-clock
-figures to publish will come from the `oxmutate-bench.yml` lane on a runner nothing else shares.
+**Speed, measured on a laptop, not yet a published number** (the published ones live at
+[burgee.interlace.tools/docs/benchmarks](https://burgee.interlace.tools/docs/benchmarks)). Medians of 3
+head-to-head runs (`bench/burgee-pair.mts`, concurrency 4, one tool after the other, load 6–19, 2026-10-30):
+
+| Subject | Stryker 10 | oxmutate | Wall | CPU | Tests a mutant |
+| :-- | --: | --: | --: | --: | --: |
+| burgee/paratext | 108.3 s | 19.0 s | 5.70x | 5.92x | 31.7 → 16.8 |
+| burgee/controlroom | 63.4 s | 45.6 s | 1.39x | 2.55x | 7.3 → 9.2 |
+| oxmutate itself (Stryker's mutant set) | 508 s | 334 s | 1.52x | — | — |
+
+The ceiling depends on the suite as much as the tool: controlroom's own `vitest run` takes ~8 s and
+every fresh worker imports React and Ink, so even zero overhead would make it ~6x. The figures to
+publish come from `bench/burgee-pair.mts`, run locally on a quiet machine: no mutation run happens
+in GitHub Actions (`D-20261101-no-mutation-in-gha`).
 
 ## Benchmarks
 

package/dist/checker.js

@@ -29,6 +29,7 @@ export function applyMutant(source, m) {
     const starts = [0];
     for (let i = source.indexOf('\n'); i !== -1; i = source.indexOf('\n', i + 1))
         starts.push(i + 1);
+    // Stryker disable next-line NumericLiteral: `starts` holds every line the checker reports, so the fallback never runs
     const at = (p) => (starts[p.line - 1] ?? 0) + p.column - 1;
     return source.slice(0, at(m.start)) + m.replacement + source.slice(at(m.end));
 }

package/dist/child.js

@@ -14,11 +14,14 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ExitCode } from 'burgee';
+import { BEAT_ENV, beatFile, CPU_SAMPLE_MS } from './heartbeat.js';
 import { resolveEsm } from './resolve.js';
-import { ACTIVE_MUTANT_ENV, argv, env, exit } from './runtime.js';
+import { ACTIVE_MUTANT_ENV, argv, env, exit, pid } from './runtime.js';
 import { instrumentedSources } from './vite-plugin.js';
 const config = JSON.parse(readFileSync(argv[2] ?? '', 'utf8'));
 env['NODE_ENV'] ??= 'test';
+// Before Vitest starts any worker, so each one inherits it (heartbeat.ts).
+env[BEAT_ENV] = beatFile(path.dirname(config.instrumentedMap), pid);
 const vitestNode = (await import(resolveEsm('vitest/node', config.root)));
 const runner = fileURLToPath(new URL('./runner.js', import.meta.url));
 const silent = { onInit() { }, onFinished() { } };
@@ -42,6 +45,7 @@ const vitest = await vitestNode.createVitest('test', {
     // spellings (top-level in Vitest 5, `experimental` in 4.x).
     fsModuleCache: false,
     experimental: { fsModuleCache: false },
+    ...(config.inlineDeps && { server: { deps: { inline: true } } }),
 }, 
 // A private Vite cache per run, so no cache outside this run can answer for a mutated file.
 { plugins: [instrumentedSources(config.instrumentedMap)], cacheDir: path.join(path.dirname(config.instrumentedMap), 'vite-cache') });
@@ -72,6 +76,11 @@ async function runIsolated(unit) {
     try {
         for (const item of unit.batch ?? []) {
             env[ACTIVE_MUTANT_ENV] = item.id;
+            // The runaway guard warm runs have: a loop the mutant causes stops at the limit, not the watchdog.
+            if (item.hitLimit)
+                env['OXMUTATE_HIT_LIMIT'] = String(item.hitLimit);
+            else
+                delete env['OXMUTATE_HIT_LIMIT'];
             if (item.tests)
                 env['OXMUTATE_ONLY_TESTS'] = JSON.stringify(item.tests);
             else
@@ -87,6 +96,7 @@ async function runIsolated(unit) {
         }
         delete env[ACTIVE_MUTANT_ENV];
         delete env['OXMUTATE_ONLY_TESTS'];
+        delete env['OXMUTATE_HIT_LIMIT'];
     }
     finally {
         vitest.config.bail = 0;
@@ -101,6 +111,14 @@ async function runUnit(unit) {
     env['OXMUTATE_PROGRESS'] = unit.progress;
     if (unit.plan)
         env['OXMUTATE_PLAN'] = unit.plan;
+    if (unit.staticIds)
+        env['OXMUTATE_STATIC'] = JSON.stringify(unit.staticIds);
+    else
+        delete env['OXMUTATE_STATIC'];
+    if (unit.hitLimits)
+        env['OXMUTATE_HIT_LIMITS'] = JSON.stringify(unit.hitLimits);
+    else
+        delete env['OXMUTATE_HIT_LIMITS'];
     delete env[ACTIVE_MUTANT_ENV];
     if (unit.mode === 'isolated')
         await runIsolated(unit);
@@ -127,5 +145,13 @@ process.on('message', (msg) => {
 // and a worker thread may still be looping in a mutant. Two such servers were found spinning at
 // 100% CPU 11 hours after their run ended, and slowed the next run 50x (2026-10-27).
 process.on('disconnect', () => exit(ExitCode.OK));
+// The server's CPU time, every thread (the test worker included), for the watchdog to tell an idle
+// stall from a loop (heartbeat.ts). This thread stays free while a worker loops, so the samples come.
+const sendCpu = () => {
+    const { user, system } = process.cpuUsage();
+    process.send?.({ type: 'cpu', at: Date.now(), us: user + system });
+};
+sendCpu();
+setInterval(sendCpu, CPU_SAMPLE_MS).unref();
 process.send?.({ type: 'ready' });
 //# sourceMappingURL=child.js.map

package/dist/coordinator.d.ts

@@ -36,10 +36,16 @@ export interface RunStats {
     instrumentMs: number;
     dryRunMs: number;
     mutationMs: number;
+    /** Static mutants decided in live workers (section 5b), between the warm and the isolated phases. */
+    staticMs: number;
+    /** Unarmed re-collections in that phase, the guard each live static verdict waits on (runner.ts). */
+    staticRecollections: number;
     isolatedMs: number;
     wallMs: number;
     testExecutions: number;
     watchdogKills: number;
+    /** Of `watchdogKills`, the stops whose worker was idle, waiting (heartbeat.ts). In an isolated run each is a Timeout as it stands. */
+    idleStalls: number;
     crashes: number;
     canaryFiles: number;
     /** Contexts restarted because a mutant left state behind (the per-execution canary fired). */

package/dist/coordinator.js

@@ -17,6 +17,7 @@ import { ambientRuntime, run as spawn } from 'bellpull';
 import { checkSurvivors } from './checker.js';
 import { runCommandMutants } from './command-runner.js';
 import { disables } from './config.js';
+import { rangeDisables } from './directives.js';
 import { globToRegExp, matchFiles } from './files.js';
 import { changedLines, parseMutateSpec, shardOf, touches, withinRange } from './lanes.js';
 import { native } from './native.js';
@@ -36,8 +37,16 @@ function readRecords(file) {
         .map((l) => JSON.parse(l));
 }
 const sha = (s) => createHash('sha256').update(s).digest('hex').slice(0, 16);
-/** Work units of at most this many (mutant, test) executions: small enough to steal. */
-const UNIT_PAIRS = 120;
+/**
+ * Work units of at most this many (mutant, test) executions: small enough to steal, large enough
+ * that each unit's fresh worker, which imports the test file's whole graph, is paid for few units.
+ * At 120, module loading was most of the CPU on burgee/controlroom (React/Ink in every worker); 400
+ * cut units 172 -> 93 and wall 44 -> 39 s (paratext 39 -> 35 s), and 1000 gained nothing more
+ * (2026-10-30). Smaller stays better for a pollution restart, which re-runs the rest of a unit.
+ */
+const UNIT_PAIRS = 400;
+/** How many times its isolated budget a busy stop gets on its re-run. */
+const RERUN_SLACK = 3;
 const MS_PER_MINUTE = 60_000;
 const PERCENT = 100;
 /** Every test that reaches a mutant: the score's, then a spec oracle's replay tests. */
@@ -55,8 +64,8 @@ export async function run(options) {
     const { root } = options;
     const work = mkdtempSync(path.join(tmpdir(), 'oxmutate-'));
     const stats = {
-        files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0,
-        watchdogKills: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
+        files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, staticMs: 0, staticRecollections: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0,
+        watchdogKills: 0, idleStalls: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
     };
     let unitSeq = 0;
     const fileFor = (kind, ext) => path.join(work, `${kind}-${String(unitSeq++)}.${ext}`);
@@ -87,8 +96,9 @@ export async function run(options) {
         const directiveErrors = [];
         for (const f of instrumented) {
             const { disables: offs, errors } = disables(sources[f.path] ?? '', f.path);
+            const ranged = rangeDisables(sources[f.path] ?? '', f.path);
             const ranges = rangesFor(f.path);
-            directiveErrors.push(...errors);
+            directiveErrors.push(...errors, ...ranged.errors);
             let any = false;
             for (const m of f.mutants) {
                 if (changed && !touches(changed, f.path, m.start.line, m.end.line))
@@ -98,13 +108,14 @@ export async function run(options) {
                 if (options.shard && shardOf(m.id, options.shard.count) !== options.shard.index)
                     continue;
                 const off = offs.find((d) => d.line === m.start.line && (d.mutators === 'all' || d.mutators.includes(m.mutatorName)));
+                const inRange = ranged.reasonFor(m.start.line, m.mutatorName);
                 const excluded = options.excludedMutations.includes(m.mutatorName);
                 mutants.push({
                     ...m,
                     file: f.path,
                     coveredBy: [],
-                    status: off || excluded || m.ignoredReason ? 'Ignored' : 'NoCoverage',
-                    statusReason: off?.reason ?? m.ignoredReason ?? (excluded ? `excluded mutator ${m.mutatorName}` : undefined),
+                    status: off || inRange !== undefined || excluded || m.ignoredReason ? 'Ignored' : 'NoCoverage',
+                    statusReason: off?.reason ?? inRange ?? m.ignoredReason ?? (excluded ? `excluded mutator ${m.mutatorName}` : undefined),
                 });
                 any = true;
             }
@@ -214,8 +225,10 @@ export async function run(options) {
         for (const [testId, perMutant] of Object.entries(dry.perTest)) {
             if (testId.startsWith(FILE_KEY)) {
                 const file = testId.slice(FILE_KEY.length);
-                for (const id of Object.keys(perMutant))
+                for (const [id, n] of Object.entries(perMutant)) {
                     (staticFiles.get(id) ?? staticFiles.set(id, new Set()).get(id))?.add(file);
+                    hits.set(id, (hits.get(id) ?? 0) + n);
+                }
                 continue;
             }
             for (const [id, n] of Object.entries(perMutant)) {
@@ -294,7 +307,9 @@ export async function run(options) {
         // false kills on burgee/paratext (an import-time registration the tests then read).
         const toRun = mutants.filter((m) => !m.reused && m.status !== 'Ignored' && !m.static && allCovering(m).length > 0);
         const byId = new Map(mutants.map((m) => [m.id, m]));
-        const hitLimits = Object.fromEntries(toRun.map((m) => [m.id, Math.max(1000, (hits.get(m.id) ?? 1) * 100)]));
+        /** The switch-taken count past which a run is a runaway: 100x what the dry run saw, at least 1000. */
+        const hitLimitOf = (id) => Math.max(1000, (hits.get(id) ?? 1) * 100);
+        const hitLimits = Object.fromEntries(toRun.map((m) => [m.id, hitLimitOf(m.id)]));
         const maxTestMs = (id) => { const m = byId.get(id); return Math.max(0, ...(m ? allCovering(m) : []).map((t) => testInfo.get(t)?.ms ?? 0)); };
         // The watchdog is for runaways, which loop in fast code; a slow test under a loaded machine is
         // not one. 3x the covering test's dry-run time, not Stryker's 1.5x: at 1.5x, subprocess-heavy
@@ -357,7 +372,8 @@ export async function run(options) {
         const records = [];
         const runaways = new Set();
         const crashedIds = new Set();
-        const pool = createPool({ root, vitestConfig: options.vitestConfig, workers: 1, instrumentedMap: mapFile, nodeArgs: options.testRunnerNodeArgs }, options.concurrency, work, 'mutant');
+        // Dependencies inlined here too, so the static phase (5b) reuses these servers instead of starting its own.
+        const pool = createPool({ root, vitestConfig: options.vitestConfig, workers: 1, instrumentedMap: mapFile, nodeArgs: options.testRunnerNodeArgs, inlineDeps: true }, options.concurrency, work, 'mutant');
         pools.push(pool);
         /** Mutants decided on one verdict track: the tests', or a spec oracle's replay tests'. */
         const killedSoFar = (spec) => new Set([...runaways, ...crashedIds, ...records.filter((r) => r.type === 'mutant' && r.status !== 'Survived' && Boolean(r.spec) === spec).map((r) => r.id ?? '')]);
@@ -410,7 +426,29 @@ export async function run(options) {
         // One round, every covering file at once. A two-round plan (cheapest file first, survivors
         // to the rest) cut executions 23% on burgee/paratext but took 2.9x longer: the second round
         // waits for the first to drain, and the expensive files then run as a tail (2026-10-27).
-        await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit);
+        // Kills are filtered out at dispatch, not when a unit is built: most units wait in the queue while
+        // others run, and a mutant another unit has killed (vouched for by its canary) needs no more of its
+        // covering tests. 1,022 of 6,550 warm executions on burgee/paratext ran after the mutant's kill
+        // (2026-10-30). Verdicts are unchanged: a Killed mutant needs no other pair (dispatch.qnt).
+        const beforeUnit = (unit) => {
+            const entry = planUnits.get(unit.results);
+            if (!entry)
+                return true;
+            const decided = { tests: killedSoFar(false), spec: killedSoFar(true) };
+            const left = {};
+            for (const [t, ids] of Object.entries(entry.plan)) {
+                const done = specOf.has(t) ? decided.spec : decided.tests;
+                const keep = ids.filter((id) => !done.has(id));
+                if (keep.length)
+                    left[t] = keep;
+            }
+            if (Object.keys(left).length === 0)
+                return false;
+            entry.plan = left;
+            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()] }));
+            return true;
+        };
+        await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit, beforeUnit);
         stats.mutationMs = performance.now() - m0;
         // ── 5. Verdicts from the warm run ─────────────────────────────────────────────────────────
         const byMutant = new Map();
@@ -449,9 +487,7 @@ export async function run(options) {
                 isolatedQueue.push(m); // unfinished: a crash left work undone
             }
         }
-        for (const m of mutants)
-            if (m.static && m.status !== 'Ignored' && !m.reused)
-                isolatedQueue.push(m);
+        const staticMutants = mutants.filter((m) => m.static && m.status !== 'Ignored' && !m.reused);
         // ── 6. Isolated re-runs: the switch armed before import, Vitest run normally ──────────────
         const allTestFiles = [...new Set(dry.tests.map((t) => t.file))];
         // A static mutant needs the files that load it (plus any whose tests reach it); only a hit
@@ -460,6 +496,21 @@ export async function run(options) {
         for (const t of dry.tests)
             fileCost.set(t.file, (fileCost.get(t.file) ?? 0) + t.ms);
         const byCost = (files) => [...files].sort((a, b) => (fileCost.get(a) ?? 0) - (fileCost.get(b) ?? 0));
+        // Test file -> source file -> how many of that source's mutants its tests reach. A static mutant
+        // rarely has covering tests of its own, so its loaders were tried cheapest first, and the cheapest
+        // seldom tests the module: on burgee/controlroom each tabs.ts static mutant ran 75 tests in two
+        // files where Stryker needed 37 (2026-10-30). The file that exercises the module goes first.
+        const affinity = new Map();
+        for (const mm of mutants) {
+            for (const t of mm.coveredBy) {
+                const f = testInfo.get(t)?.file;
+                if (!f)
+                    continue;
+                const bySource = affinity.get(f) ?? affinity.set(f, new Map()).get(f);
+                bySource.set(mm.file, (bySource.get(mm.file) ?? 0) + 1);
+            }
+        }
+        const byAffinity = (source, files) => byCost(files).sort((a, b) => (affinity.get(b)?.get(source) ?? 0) - (affinity.get(a)?.get(source) ?? 0));
         const filesFor = (m) => {
             const tests = m.coveredBy.map((t) => testInfo.get(t)?.file ?? '');
             if (!m.static)
@@ -471,27 +522,121 @@ export async function run(options) {
             // ran a file that only imports it first, and 288 of 349 isolated kills on burgee/paratext
             // came from a later file (2026-10-27).
             const covering = byCost([...new Set(tests)]);
-            return [...covering, ...byCost([...loaders].filter((f) => !covering.includes(f)))];
+            return [...covering, ...byAffinity(m.file, [...loaders].filter((f) => !covering.includes(f)))];
         };
         const isolatedBudget = (id) => {
             const m = byId.get(id);
             const fs = m ? filesFor(m) : allTestFiles;
-            const ms = dry.tests.filter((t) => fs.includes(t.file)).reduce((sum, t) => sum + t.ms, 0);
+            // A non-static mutant's isolated run executes only its covering tests (`tests` below), so they
+            // are its budget; every test of its files made a hang wait 30-40 s on oxmutate's own suite,
+            // where its covering tests take a fraction of that (2026-10-30). A static mutant runs them all.
+            const covering = new Set(m && !m.static ? m.coveredBy : []);
+            const ms = dry.tests.filter((t) => fs.includes(t.file) && (covering.size === 0 || covering.has(t.id))).reduce((sum, t) => sum + t.ms, 0);
             return 1500 + options.timeoutMS + options.timeoutFactor * ms * 2;
         };
         // A non-static mutant runs only its covering tests, armed across all of them in file order:
         // Stryker's semantics, so cross-test effects still show (a no-op reset() lets state pile up
         // for the next covering test). A static mutant runs every test of its files, because an
         // import-time change reaches tests that never execute the mutated line.
+        /**
+         * Static mutants decided in live workers, one unit per (test file, batch of its static mutants),
+         * on a pool that inlines dependencies. Returns the mutants this path could not decide.
+         */
+        const decideStaticLive = async (items) => {
+            if (items.length === 0)
+                return [];
+            const STATIC_BATCH = 25;
+            /** Units of up to STATIC_BATCH mutants per test file, for the files each mutant gets this round. */
+            const unitsFor = (filesOf) => {
+                const byFile = new Map();
+                for (const m of items)
+                    for (const f of filesOf(m))
+                        (byFile.get(f) ?? byFile.set(f, []).get(f))?.push(m.id);
+                return [...byFile].flatMap(([file, ids]) => Array.from({ length: Math.ceil(ids.length / STATIC_BATCH) }, (_, i) => ({
+                    mode: 'static', files: [file], results: fileFor('static', 'jsonl'), progress: fileFor('static', 'progress'), staticIds: ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH),
+                    hitLimits: Object.fromEntries(ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH).map((id) => [id, hitLimitOf(id)])),
+                })));
+            };
+            const killed = new Map();
+            /** Decided by the hit-count limit: a runaway, Timeout like a warm one. */
+            const timedOut = new Set();
+            const passed = new Map(); // mutant -> files that ran it clean
+            const back = new Set();
+            const ran = new Map();
+            const staticPool = pool;
+            const afterStatic = (unit, outcome) => {
+                const file = unit.files[0] ?? '';
+                const decided = new Set();
+                for (const r of readRecords(unit.results)) {
+                    if (r.type === 'recollection')
+                        stats.staticRecollections++;
+                    if (r.type === 'static-fallback')
+                        for (const id of r.ids ?? [])
+                            back.add(id);
+                    if (r.type !== 'isolated' || !r.id)
+                        continue;
+                    decided.add(r.id);
+                    ran.set(r.id, (ran.get(r.id) ?? 0) + (r.ran ?? 0));
+                    if (r.timeout)
+                        timedOut.add(r.id);
+                    if (r.killed || r.timeout)
+                        killed.set(r.id, { killedBy: [...(killed.get(r.id)?.killedBy ?? []), ...(r.failed ?? [])], ran: 0 });
+                    else
+                        (passed.get(r.id) ?? passed.set(r.id, new Set()).get(r.id))?.add(file);
+                }
+                // A stop or a crash leaves the rest of the batch undecided: the fresh-worker path decides it.
+                if (outcome.killedFor || outcome.crashed)
+                    for (const id of unit.staticIds ?? [])
+                        if (!decided.has(id))
+                            back.add(id);
+                return [];
+            };
+            const keepUndecided = (unit) => {
+                unit.staticIds = (unit.staticIds ?? []).filter((id) => !killed.has(id) && !back.has(id));
+                return unit.staticIds.length > 0;
+            };
+            // Two rounds: each mutant first in the file most likely to kill it (filesFor puts the files whose
+            // tests reach it first, cheapest first), then its other files only if it survived. In one round
+            // every loading file ran a mutant at once, and a kill in one did not spare the others: 41 tests a
+            // static kill on burgee/controlroom against Stryker's 33.6 (2026-10-30).
+            const open = (m) => !killed.has(m.id) && !back.has(m.id);
+            const rounds = [(m) => filesFor(m).slice(0, 1), (m) => (open(m) ? filesFor(m).slice(1) : [])];
+            // the mutant's run and the unarmed canary after it
+            for (const round of rounds)
+                await staticPool.drain(unitsFor(round), (_, id) => 2 * isolatedBudget(id), afterStatic, keepUndecided);
+            const undecided = [];
+            for (const m of items) {
+                const k = killed.get(m.id);
+                if (k) {
+                    m.status = timedOut.has(m.id) && !k.killedBy.length ? 'Timeout' : 'Killed';
+                    m.killedBy = [...new Set(k.killedBy)];
+                    m.testsCompleted = ran.get(m.id) ?? 0;
+                }
+                else if (!back.has(m.id) && filesFor(m).every((f) => passed.get(m.id)?.has(f))) {
+                    m.status = 'Survived';
+                    m.testsCompleted = ran.get(m.id) ?? 0;
+                }
+                else
+                    undecided.push(m);
+            }
+            return undecided;
+        };
         const runIsolated = async (items, slack = 1) => {
             const verdicts = new Map();
             if (items.length === 0)
                 return verdicts;
-            const chunk = Math.max(1, Math.ceil(items.length / (options.concurrency * 2)));
-            const mk = (batch) => ({ mode: 'isolated', files: [], results: fileFor('iso', 'jsonl'), progress: fileFor('iso', 'progress'), batch: batch.map((m) => ({ id: m.id, files: filesFor(m), tests: m.static ? undefined : m.coveredBy })) });
-            const units = [];
-            for (let i = 0; i < items.length; i += chunk)
-                units.push(mk(items.slice(i, i + chunk)));
+            const mk = (batch) => ({ mode: 'isolated', files: [], results: fileFor('iso', 'jsonl'), progress: fileFor('iso', 'progress'), batch: batch.map((m) => ({ id: m.id, files: filesFor(m), tests: m.static ? undefined : m.coveredBy, hitLimit: hitLimitOf(m.id) })) });
+            // Packed by estimated cost, heaviest first into the lightest bin, and the heaviest bins run
+            // first. Equal mutant counts left one unit at 8.4 s while the others finished in under 3 s on
+            // burgee/controlroom (2026-10-30): a mutant's cost is its files' dry-run time, not one.
+            const cost = (m) => isolatedBudget(m.id);
+            const bins = Array.from({ length: Math.min(items.length, options.concurrency * 2) }, () => ({ load: 0, batch: [] }));
+            for (const m of [...items].sort((x, y) => cost(y) - cost(x))) {
+                const bin = bins.reduce((lightest, b) => (b.load < lightest.load ? b : lightest));
+                bin.load += cost(m);
+                bin.batch.push(m);
+            }
+            const units = bins.sort((x, y) => y.load - x.load).map((b) => mk(b.batch));
             stats.isolatedRuns += items.length;
             await pool.drain(units, (_, id) => slack * isolatedBudget(id), (unit, outcome) => {
                 // Vitest reports per test file: a mutant is killed if any of its files failed.
@@ -500,13 +645,15 @@ export async function run(options) {
                         continue;
                     const prev = verdicts.get(rec.id);
                     const testsCompleted = (prev?.testsCompleted ?? 0) + (rec.ran ?? 0);
-                    if (rec.killed)
+                    if (rec.timeout)
+                        verdicts.set(rec.id, { status: 'Timeout', testsCompleted });
+                    else if (rec.killed)
                         verdicts.set(rec.id, { status: 'Killed', killedBy: [...(prev?.killedBy ?? []), ...(rec.failed ?? [])], testsCompleted });
                     else
                         verdicts.set(rec.id, { status: prev?.status ?? 'Survived', killedBy: prev?.killedBy, testsCompleted });
                 }
                 if (outcome.killedFor)
-                    verdicts.set(outcome.killedFor, { status: 'Timeout' });
+                    verdicts.set(outcome.killedFor, { status: 'Timeout', idle: outcome.stall === 'idle' });
                 if (outcome.crashed && outcome.crashedFor)
                     verdicts.set(outcome.crashedFor, { status: 'RuntimeError' });
                 if (!outcome.killedFor && !outcome.crashed)
@@ -520,14 +667,27 @@ export async function run(options) {
                     verdicts.set(m.id, { status: 'RuntimeError' });
             return verdicts;
         };
+        // ── 5b. Static mutants in live workers (.sdlc/intents/oxmutate/staticwarm.qnt) ─────────────
+        // A fresh worker per (static mutant, file) cost ~80 ms of start-up around tests that take a few
+        // ms: 29 of 35 s on burgee/paratext (2026-10-30). A live worker re-evaluates the project's modules
+        // per mutant instead; whatever it cannot vouch for comes back here for the fresh-worker path.
+        // OXMUTATE_ISOLATE_STATIC=1 sends every static mutant down the fresh-worker path, as before.
+        const s0 = performance.now();
+        const staticBack = env['OXMUTATE_ISOLATE_STATIC'] ? staticMutants : await decideStaticLive(staticMutants);
+        stats.staticMs = performance.now() - s0;
+        isolatedQueue.push(...staticBack);
         progress.phase(`isolated runs (static mutants and stragglers: ${String(isolatedQueue.length)})`);
         const i0 = performance.now();
         const first = await runIsolated(isolatedQueue);
         // A watchdog stop on a loaded machine is a slow test, not a runaway: 31 of them on one
         // burgee/paratext run while the load average sat at 40, all Survived for Stryker (2026-10-27).
         // Each stop gets one more run with 3x the budget; only one that is stopped again is a Timeout.
-        const stopped = isolatedQueue.filter((m) => first.get(m.id)?.status === 'Timeout');
-        const again = await runIsolated(stopped, 3);
+        // An idle stop is not re-run: its worker was waiting with its event loop turning and no CPU spent,
+        // on something the mutant never lets happen, which no budget cures; it is a Timeout as Stryker
+        // scores it. Re-run at 3x, 375 of them on caique's 10-31 run "finished" only because Vitest's 30 s
+        // test timeout failed the test (D-20261101-idle-stall-is-timeout, stall.qnt).
+        const stopped = isolatedQueue.filter((m) => first.get(m.id)?.status === 'Timeout' && !first.get(m.id)?.idle);
+        const again = await runIsolated(stopped, RERUN_SLACK);
         for (const m of stopped) {
             const v = again.get(m.id);
             if (v && v.status !== 'Timeout' && v.status !== 'RuntimeError') {
@@ -542,7 +702,7 @@ export async function run(options) {
                 m.killedBy = v.killedBy;
                 m.testsCompleted = v.testsCompleted;
                 if (v.status === 'Timeout')
-                    m.statusReason = 'stopped by the watchdog twice, the second time with 3x the budget';
+                    m.statusReason = v.idle ? 'its test waited past the budget with the worker idle: a hang, not a slow test' : 'stopped by the watchdog twice, the second time with 3x the budget';
             }
         }
         // ── 6b. Confirm survivors under whole-file semantics ──────────────────────────────────────
@@ -551,13 +711,16 @@ export async function run(options) {
         // survives warm and is killed when armed for the whole file, the way Stryker runs it (burgee/
         // paratext plugin.ts, 2026-10-27). Survivors are what a person acts on, so each one is
         // re-run once with the mutant armed across its covering files before it is reported.
-        const survivors = toRun.filter((m) => m.status === 'Survived');
+        // A survivor with one covering test is not re-run: confirmation runs only covering tests, so there
+        // is no later test for its leftover state to reach, and the warm run already armed that test
+        // through its hooks from clean state (.sdlc/intents/oxmutate/confirm.qnt).
+        const survivors = toRun.filter((m) => m.status === 'Survived' && new Set(m.coveredBy).size > 1);
         const confirmed = await runIsolated(survivors);
         // A timeout here is a watchdog stop like any other, and a loaded machine makes them: two
         // closeout survivors were reported killed this way while a docs build shared the machine
         // (2026-10-27). The same rule as section 6: one more run at 3x the budget before believing it.
-        const stoppedHere = survivors.filter((m) => confirmed.get(m.id)?.status === 'Timeout');
-        const recheck = await runIsolated(stoppedHere, 3);
+        const stoppedHere = survivors.filter((m) => confirmed.get(m.id)?.status === 'Timeout' && !confirmed.get(m.id)?.idle);
+        const recheck = await runIsolated(stoppedHere, RERUN_SLACK);
         for (const m of stoppedHere) {
             const v = recheck.get(m.id);
             if (v)
@@ -609,6 +772,7 @@ export async function run(options) {
         }
         stats.isolatedMs = performance.now() - i0;
         stats.watchdogKills = pool.stats.killed;
+        stats.idleStalls = pool.stats.idle;
         stats.crashes = pool.stats.crashed;
         // ── 8. Score, cache, result ───────────────────────────────────────────────────────────────
         if (options.incremental) {

package/dist/directives.js

@@ -0,0 +1,55 @@
+/**
+ * Stryker's range directives: a `disable` comment naming mutators (or `all`) and a reason turns them
+ * off from the next line on, until a `restore` comment naming them (either spelled with `Stryker` or
+ * `oxmutate`). The `next-line` form is config.ts's `disables`. Before this, oxmutate read only the
+ * `next-line` form and graded every mutant inside a range as if no directive were there: 116 such
+ * mutants in compat-oracle's `hosts.ts` alone (.sdlc/intents/oxmutate/sc8-profile.md).
+ *
+ * Read by line, as written. Stryker reads a directive only as the leading comment of the next AST
+ * node, so a `restore` that closes an object (`// Stryker restore all` above its `}`) is invisible to
+ * it, and its `disable` then runs to the end of the file. oxmutate does not reproduce that: the
+ * directive means what it says.
+ */
+const HEAD = /\/\/\s*(?:Stryker|oxmutate)\s+(disable|restore)\s+(\S.*)/i;
+/** `all`, or a comma list of mutator names. */
+const LIST = /^(?:all|\w+(?:\s*,\s*\w+)*)$/i;
+const covers = (r, mutator) => r.mutators === 'all' || r.mutators.includes(mutator);
+/** The range directives of a file. A `disable` without a reason is an error, as `next-line`'s is. */
+export function rangeDisables(source, file) {
+    const rules = [];
+    const errors = [];
+    source.split('\n').forEach((text, i) => {
+        const m = HEAD.exec(text);
+        if (!m)
+            return;
+        // `next-line` is not a list (the hyphen), so that form is left to config.ts here too.
+        const body = m[2];
+        const colon = body.indexOf(':');
+        const list = (colon === -1 ? body : body.slice(0, colon)).trim();
+        if (!LIST.test(list))
+            return;
+        const kind = m[1].toLowerCase();
+        const reason = colon === -1 ? '' : body.slice(colon + 1).trim();
+        if (kind === 'disable' && !reason) {
+            errors.push(`${file}:${String(i + 1)}: disable comment without a reason. fix: add ": <why these mutants cannot be killed>"`);
+            return;
+        }
+        const mutators = list.toLowerCase() === 'all' ? 'all' : list.split(',').map((s) => s.trim().toLowerCase());
+        rules.push({ line: i + 1, kind, mutators, reason });
+    });
+    return {
+        errors,
+        reasonFor(line, mutator) {
+            const name = mutator.toLowerCase();
+            // The latest directive before the line that names this mutator decides it.
+            for (let k = rules.length - 1; k >= 0; k--) {
+                const r = rules[k];
+                if (r.line >= line || !covers(r, name))
+                    continue;
+                return r.kind === 'disable' ? r.reason : undefined;
+            }
+            return undefined;
+        },
+    };
+}
+//# sourceMappingURL=directives.js.map