@fairfox/polly 0.91.0 → 0.92.1

package/dist/tools/mutate/src/cli.js

@@ -1,8 +1,272 @@
 #!/usr/bin/env bun
 
+// tools/mutate/src/cli.ts
+import { resolve as resolve5 } from "node:path";
+
+// tools/test/src/coverage-policy/mutate-targets.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { Glob } from "bun";
+
+// src/shared/lib/guards.ts
+function isRecord(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+
+// tools/mutate/src/define.ts
+var MUTATION_CONFIG_FILE = "polly.mutate.ts";
+function defineMutation(config) {
+  return config;
+}
+var MUTATOR_NAMES = new Set([
+  "ArithmeticOperator",
+  "ArrayDeclaration",
+  "ArrowFunction",
+  "AssignmentOperator",
+  "BlockStatement",
+  "BooleanLiteral",
+  "ConditionalExpression",
+  "EqualityOperator",
+  "LogicalOperator",
+  "MethodExpression",
+  "ObjectLiteral",
+  "OptionalChaining",
+  "Regex",
+  "StringLiteral",
+  "UnaryOperator",
+  "UpdateOperator"
+]);
+function isMutatorName(value) {
+  return typeof value === "string" && MUTATOR_NAMES.has(value);
+}
+function strings(value, where) {
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+    throw new Error(`${where} must be an array of strings`);
+  }
+  return value;
+}
+function optionalNumber(value, where) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`${where} must be a number`);
+  return value;
+}
+function optionalString(value, where) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string")
+    throw new Error(`${where} must be a string`);
+  return value;
+}
+function isEngineMode(v) {
+  return v === "fast" || v === "matrix";
+}
+function isCoverageMode(v) {
+  return v === "dynamic" || v === "static";
+}
+function parseRun(raw, where) {
+  const mode = raw["mode"];
+  if (mode !== undefined && !isEngineMode(mode)) {
+    throw new Error(`${where}: mode must be "fast" or "matrix"`);
+  }
+  const concurrency = optionalNumber(raw["concurrency"], `${where}: concurrency`);
+  if (concurrency !== undefined && !(Number.isInteger(concurrency) && concurrency > 0)) {
+    throw new Error(`${where}: concurrency must be a positive integer`);
+  }
+  const coverage = raw["coverage"];
+  if (coverage !== undefined && !isCoverageMode(coverage)) {
+    throw new Error(`${where}: coverage must be "dynamic" or "static"`);
+  }
+  const common = { targets: strings(raw["targets"], `${where}: targets`) };
+  if (isEngineMode(mode))
+    common.mode = mode;
+  if (isCoverageMode(coverage))
+    common.coverage = coverage;
+  if (concurrency !== undefined)
+    common.concurrency = concurrency;
+  const timeout = raw["timeout"];
+  if (timeout !== undefined) {
+    if (!isRecord(timeout))
+      throw new Error(`${where}: timeout must be { factor, extraMs }`);
+    const factor = optionalNumber(timeout["factor"], `${where}: timeout.factor`) ?? 2;
+    const extraMs = optionalNumber(timeout["extraMs"], `${where}: timeout.extraMs`) ?? 3000;
+    common.timeout = { factor, extraMs };
+  }
+  return common;
+}
+function parseMutants(raw, where) {
+  const out = {};
+  const mutators = raw["mutators"];
+  if (mutators !== undefined) {
+    if (!isRecord(mutators))
+      throw new Error(`${where}: mutators must be { exclude }`);
+    const exclude = mutators["exclude"] === undefined ? [] : mutators["exclude"];
+    if (!Array.isArray(exclude) || !exclude.every(isMutatorName)) {
+      throw new Error(`${where}: mutators.exclude holds an unknown mutator name`);
+    }
+    out.mutators = { exclude };
+  }
+  const ignore = raw["ignoreVerifyCallsites"];
+  if (ignore !== undefined) {
+    if (typeof ignore !== "boolean")
+      throw new Error(`${where}: ignoreVerifyCallsites must be boolean`);
+    out.ignoreVerifyCallsites = ignore;
+  }
+  const typecheck = raw["typecheck"];
+  if (typecheck !== undefined) {
+    if (typeof typecheck !== "boolean")
+      throw new Error(`${where}: typecheck must be boolean`);
+    out.typecheck = typecheck;
+  }
+  return { ...out, ...parseContracts(raw, where) };
+}
+function isContractsMode(v) {
+  return v === "off" || v === "ensures" || v === "all";
+}
+function parseContracts(raw, where) {
+  const contracts = raw["contracts"];
+  if (contracts === undefined)
+    return {};
+  if (!isContractsMode(contracts)) {
+    throw new Error(`${where}: contracts must be "off", "ensures" or "all"`);
+  }
+  return { contracts };
+}
+function parseOutputs(raw, where) {
+  const out = {};
+  const thresholds = raw["thresholds"];
+  if (thresholds !== undefined) {
+    if (!isRecord(thresholds))
+      throw new Error(`${where}: thresholds must be { break }`);
+    const brk = optionalNumber(thresholds["break"], `${where}: thresholds.break`);
+    out.thresholds = brk === undefined ? {} : { break: brk };
+  }
+  const report = optionalString(raw["report"], `${where}: report`);
+  if (report !== undefined)
+    out.report = report;
+  const decisions = optionalString(raw["decisions"], `${where}: decisions`);
+  if (decisions !== undefined)
+    out.decisions = decisions;
+  return out;
+}
+function parseCommon(raw, where) {
+  return { ...parseRun(raw, where), ...parseMutants(raw, where), ...parseOutputs(raw, where) };
+}
+function parseMutationConfig(raw, where) {
+  if (!isRecord(raw))
+    throw new Error(`${where}: the default export must be a config object`);
+  const { targets, ...common } = parseCommon(raw, where);
+  const runner = raw["runner"];
+  if (isRecord(runner) && runner["kind"] === "command") {
+    const argv = strings(runner["argv"], `${where}: runner.argv`);
+    if (argv.length === 0)
+      throw new Error(`${where}: runner.argv is empty`);
+    return { targets, runner: { kind: "command", argv }, ...common };
+  }
+  if (runner !== undefined && !(isRecord(runner) && runner["kind"] === "bun-test")) {
+    throw new Error(`${where}: runner.kind must be "bun-test" or "command"`);
+  }
+  const tests = raw["tests"];
+  if (!isRecord(tests))
+    throw new Error(`${where}: tests.include is required`);
+  const include = strings(tests["include"], `${where}: tests.include`);
+  if (include.length === 0)
+    throw new Error(`${where}: tests.include is empty`);
+  const preload = tests["preload"] === undefined ? undefined : strings(tests["preload"], `${where}: tests.preload`);
+  return { targets, tests: preload ? { include, preload } : { include }, ...common };
+}
+async function loadMutationConfig(path) {
+  const mod = await import(path);
+  const raw = isRecord(mod) ? mod["default"] : undefined;
+  return parseMutationConfig(raw, path);
+}
+
+// tools/test/src/coverage-policy/mutate-targets.ts
+async function findStrykerConfigs(root) {
+  const found = [];
+  const single = join(root, "stryker.conf.json");
+  if (existsSync(single))
+    found.push(single);
+  const glob = new Glob("stryker/*.{json,conf.json}");
+  for await (const rel of glob.scan({ cwd: root, onlyFiles: true })) {
+    found.push(join(root, rel));
+  }
+  return found.sort();
+}
+async function findMutateConfigs(root) {
+  const out = [];
+  const polly = join(root, MUTATION_CONFIG_FILE);
+  if (existsSync(polly)) {
+    const config = await loadMutationConfig(polly);
+    out.push({
+      path: polly,
+      format: "polly",
+      targets: { field: "targets", patterns: config.targets },
+      tests: { field: "tests.include", patterns: config.tests?.include ?? [] }
+    });
+  }
+  for (const path of await findStrykerConfigs(root)) {
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    out.push({
+      path,
+      format: "stryker",
+      targets: { field: "mutate", patterns: config.mutate ?? [] },
+      tests: { field: "testFiles", patterns: config.testFiles ?? config.bun?.testFiles ?? [] }
+    });
+  }
+  return out;
+}
+function isGlob(pattern) {
+  return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+var LINE_RANGE = /:\d+(?::\d+)?-\d+(?::\d+)?$/;
+async function resolvesToFile(entry, cwd) {
+  if (entry.startsWith("!"))
+    return true;
+  const pattern = entry.replace(LINE_RANGE, "");
+  if (!isGlob(pattern))
+    return existsSync(resolve(cwd, pattern));
+  const glob = new Glob(pattern);
+  for await (const _ of glob.scan({ cwd, onlyFiles: true }))
+    return true;
+  return false;
+}
+async function checkField(configPath, field, patterns, cwd) {
+  const issues = [];
+  for (const pattern of patterns) {
+    if (!await resolvesToFile(pattern, cwd)) {
+      issues.push({ config: configPath, field, pattern });
+    }
+  }
+  return issues;
+}
+async function validateMutateTargets(root) {
+  const configs = await findMutateConfigs(root);
+  const issues = [];
+  for (const c of configs) {
+    const cwd = c.format === "polly" ? dirname(c.path) : root;
+    issues.push(...await checkField(c.path, c.targets.field, c.targets.patterns, cwd));
+    issues.push(...await checkField(c.path, c.tests.field, c.tests.patterns, cwd));
+  }
+  return { configs: configs.map((c) => c.path), issues };
+}
+
 // tools/mutate/src/args.ts
-var KNOWN_VERBS = new Set(["run", "report", "decisions", "verify", "init", "help"]);
-var VALUE_FLAGS = new Set(["--config", "--report", "--decisions", "--db"]);
+var KNOWN_VERBS = new Set(["run", "report", "decisions", "verify", "init", "migrate", "help"]);
+var VALUE_FLAGS = new Set([
+  "--config",
+  "--report",
+  "--decisions",
+  "--db",
+  "--engine",
+  "--mode",
+  "--coverage",
+  "--concurrency",
+  "--files",
+  "--since",
+  "--contracts"
+]);
 function parseMutateArgs(argv) {
   const positionals = [];
   const flags = new Map;
@@ -36,79 +300,198 @@ function parseMutateArgs(argv) {
     noReport: bools.has("--no-report"),
     run: bools.has("--run"),
     force: bools.has("--force"),
-    help
+    write: bools.has("--write"),
+    inTree: bools.has("--in-tree"),
+    noCache: bools.has("--no-cache"),
+    noTypecheck: bools.has("--no-typecheck"),
+    help,
+    engine: flags.get("--engine"),
+    mode: flags.get("--mode"),
+    coverage: flags.get("--coverage"),
+    concurrency: flags.get("--concurrency"),
+    files: flags.get("--files"),
+    since: flags.get("--since"),
+    contracts: flags.get("--contracts")
   };
 }
 
 // tools/mutate/src/config.ts
-import { resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname3, resolve as resolve2 } from "node:path";
 
-// tools/test/src/coverage-policy/mutate-targets.ts
-import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { Glob } from "bun";
-async function findStrykerConfigs(root) {
-  const found = [];
-  const single = join(root, "stryker.conf.json");
-  if (existsSync(single))
-    found.push(single);
-  const glob = new Glob("stryker/*.{json,conf.json}");
-  for await (const rel of glob.scan({ cwd: root, onlyFiles: true })) {
-    found.push(join(root, rel));
-  }
-  return found.sort();
+// tools/mutate/src/migrate.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, relative } from "node:path";
+var MAPPED = new Set([
+  "mutate",
+  "testRunner",
+  "bun",
+  "commandRunner",
+  "concurrency",
+  "timeoutFactor",
+  "timeoutMS",
+  "disableBail",
+  "mutator",
+  "thresholds",
+  "ignorers"
+]);
+var SILENT = new Set(["$schema", "_comment"]);
+var SHELL_SYNTAX = /[|&;<>()$`"'\\*?{}[\]~]/;
+function preloadArgs(nodeArgs) {
+  const out = [];
+  nodeArgs.forEach((arg, i) => {
+    const value = arg === "--preload" ? nodeArgs[i + 1] : arg.startsWith("--preload=") ? arg.slice(10) : undefined;
+    if (value)
+      out.push(value);
+  });
+  return out;
 }
-function isGlob(pattern) {
-  return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+function commandArgv(command) {
+  const trimmed = command.trim();
+  return SHELL_SYNTAX.test(trimmed) ? ["sh", "-c", trimmed] : trimmed.split(/\s+/);
 }
-async function resolvesToFile(pattern, cwd) {
-  if (pattern.startsWith("!"))
-    return true;
-  if (!isGlob(pattern))
-    return existsSync(resolve(cwd, pattern));
-  const glob = new Glob(pattern);
-  for await (const _ of glob.scan({ cwd, onlyFiles: true }))
-    return true;
-  return false;
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
 }
-async function checkField(configPath, field, patterns, cwd) {
-  const issues = [];
-  for (const pattern of patterns ?? []) {
-    if (!await resolvesToFile(pattern, cwd)) {
-      issues.push({ config: configPath, field, pattern });
-    }
+function timeoutOf(raw) {
+  const factor = raw["timeoutFactor"];
+  const ms = raw["timeoutMS"];
+  if (typeof factor !== "number" && typeof ms !== "number")
+    return;
+  return {
+    factor: typeof factor === "number" ? factor : 1.5,
+    extraMs: typeof ms === "number" ? ms : 5000
+  };
+}
+function testsOf(raw, where) {
+  const bun = isRecord(raw["bun"]) ? raw["bun"] : {};
+  const include = stringList(bun["testFiles"]);
+  if (include.length === 0)
+    throw new Error(`${where} has no bun.testFiles`);
+  const preload = preloadArgs(stringList(bun["nodeArgs"]));
+  return preload.length > 0 ? { include, preload } : { include };
+}
+function runnerOf(raw, where) {
+  const runnerName = raw["testRunner"];
+  if (runnerName === "command") {
+    const cmd = isRecord(raw["commandRunner"]) ? raw["commandRunner"]["command"] : undefined;
+    const argv = commandArgv(typeof cmd === "string" ? cmd : "npm test");
+    return { runner: { kind: "command", argv } };
   }
-  return issues;
+  if (runnerName === undefined || runnerName === "bun") {
+    return {
+      tests: testsOf(raw, where),
+      ...raw["disableBail"] === true ? { mode: "matrix" } : {}
+    };
+  }
+  throw new Error(`${where}: testRunner "${String(runnerName)}" has no polly counterpart (bun or command)`);
 }
-async function validateMutateTargets(root) {
-  const configs = await findStrykerConfigs(root);
-  const issues = [];
-  for (const configPath of configs) {
-    const config = JSON.parse(readFileSync(configPath, "utf8"));
-    const testFiles = config.testFiles ?? config.bun?.testFiles;
-    issues.push(...await checkField(configPath, "mutate", config.mutate, root));
-    issues.push(...await checkField(configPath, "testFiles", testFiles, root));
+function tuningOf(raw) {
+  const out = {};
+  if (typeof raw["concurrency"] === "number")
+    out["concurrency"] = raw["concurrency"];
+  const timeout = timeoutOf(raw);
+  if (timeout)
+    out["timeout"] = timeout;
+  const excluded = isRecord(raw["mutator"]) ? stringList(raw["mutator"]["excludedMutations"]) : [];
+  if (excluded.length > 0)
+    out["mutators"] = { exclude: excluded };
+  const brk = isRecord(raw["thresholds"]) ? raw["thresholds"]["break"] : undefined;
+  if (typeof brk === "number")
+    out["thresholds"] = { break: brk };
+  return out;
+}
+function strykerToMutation(raw, where) {
+  if (!isRecord(raw))
+    throw new Error(`${where} is not a JSON object`);
+  const draft = { targets: stringList(raw["mutate"]), ...runnerOf(raw, where), ...tuningOf(raw) };
+  const notes = [];
+  if (!stringList(raw["ignorers"]).includes("polly-verify")) {
+    notes.push("ignoreVerifyCallsites defaults to true: requires/ensures mutants are reported Ignored (polly#143)");
   }
-  return { configs, issues };
+  const dropped = Object.keys(raw).filter((k) => !MAPPED.has(k) && !SILENT.has(k));
+  if (dropped.length > 0)
+    notes.push(`dropped Stryker-only keys: ${dropped.join(", ")}`);
+  return { config: parseMutationConfig(draft, where), notes };
+}
+async function readStrykerConfig(path) {
+  return strykerToMutation(await Bun.file(path).json(), path);
+}
+function defineImportSpecifier(dir) {
+  try {
+    Bun.resolveSync("@fairfox/polly/mutate", dir);
+    return "@fairfox/polly/mutate";
+  } catch {
+    const local = join2(import.meta.dir, "define.ts");
+    if (!existsSync2(local))
+      return "@fairfox/polly/mutate";
+    const rel = relative(dir, local);
+    return rel.startsWith(".") ? rel : `./${rel}`;
+  }
+}
+var LINE_WIDTH = 100;
+function literal(value) {
+  return JSON.stringify(value, null, 2).replace(/^(\s*)"([A-Za-z_$][\w$]*)":/gm, "$1$2:").replace(/([^\s[{,])(?=\n\s*[}\]])/g, "$1,").replace(/^([ ]*)([\w$]+: )?\[\n((?:[ ]*(?:"[^"\n]*"|-?\d+(?:\.\d+)?|true|false),\n)+)([ ]*)\](,?)$/gm, (m, indent, key, items, _close, comma) => {
+    const inline = `${indent}${key ?? ""}[${items.trim().replace(/,$/, "").split(/,\n\s*/).join(", ")}]${comma}`;
+    return inline.length <= LINE_WIDTH ? inline : m;
+  });
+}
+function renderMutationConfig(config, specifier) {
+  return [
+    `import { defineMutation } from "${specifier}";`,
+    "",
+    `export default defineMutation(${literal(config)});`,
+    ""
+  ].join(`
+`);
+}
+async function migrateConfig(strykerPath, opts = {}) {
+  const { config, notes } = await readStrykerConfig(strykerPath);
+  const dir = dirname2(strykerPath);
+  const path = join2(dir, MUTATION_CONFIG_FILE);
+  const source = renderMutationConfig(config, defineImportSpecifier(dir));
+  const existed = existsSync2(path);
+  const written = Boolean(opts.write) && (!existed || Boolean(opts.force));
+  if (written)
+    await Bun.write(path, source);
+  return { path, source, notes, written, existed };
 }
 
 // tools/mutate/src/config.ts
 var DEFAULT_REPORT = "reports/mutation/mutation.json";
 var DEFAULT_DECISIONS = ".polly/test-debt/decisions.jsonl";
+async function loadAt(path) {
+  if (path.endsWith(".json")) {
+    const { config, notes } = await readStrykerConfig(path);
+    return { path, format: "stryker", config, notes };
+  }
+  return { path, format: "polly", config: await loadMutationConfig(path), notes: [] };
+}
 async function resolveMutateConfig(cwd, args) {
-  let strykerConfigPath = null;
-  if (args.config) {
-    strykerConfigPath = resolve2(cwd, args.config);
-  } else {
-    const found = await findStrykerConfigs(cwd);
-    strykerConfigPath = found[0] ?? null;
+  const explicit = args.config ? resolve2(cwd, args.config) : null;
+  const discoveredStryker = (await findStrykerConfigs(cwd))[0] ?? null;
+  const local = resolve2(cwd, MUTATION_CONFIG_FILE);
+  const mutationPath = explicit ?? (existsSync3(local) ? local : discoveredStryker);
+  let mutation = null;
+  let mutationError = null;
+  if (mutationPath?.endsWith(".json")) {
+    try {
+      mutation = await loadAt(mutationPath);
+    } catch (err) {
+      mutationError = err instanceof Error ? err.message : String(err);
+    }
+  } else if (mutationPath) {
+    mutation = await loadAt(mutationPath);
   }
+  const base = mutation ? dirname3(mutation.path) : cwd;
+  const fromConfig = (flag, key, fallback) => flag ? resolve2(cwd, flag) : resolve2(base, key ?? fallback);
   return {
     cwd,
-    strykerConfigPath,
-    reportPath: resolve2(cwd, args.report ?? DEFAULT_REPORT),
+    mutation,
+    mutationError,
+    reportPath: fromConfig(args.report, mutation?.config.report, DEFAULT_REPORT),
     dbPath: args.db ? resolve2(cwd, args.db) : ":memory:",
-    decisionsPath: resolve2(cwd, args.decisions ?? DEFAULT_DECISIONS)
+    decisionsPath: fromConfig(args.decisions, mutation?.config.decisions, DEFAULT_DECISIONS)
   };
 }
 
@@ -123,6 +506,10 @@ function buildDb(report, dbPath = ":memory:") {
   db.exec(`
 		DROP TABLE IF EXISTS kills;
 		DROP TABLE IF EXISTS covers;
+		DROP TABLE IF EXISTS contract_kills;
+		DROP TABLE IF EXISTS contract_sites;
+		DROP TABLE IF EXISTS contract_violations;
+		DROP TABLE IF EXISTS report_meta;
 		DROP TABLE IF EXISTS mutants;
 		DROP TABLE IF EXISTS tests;
 		CREATE TABLE tests (
@@ -136,8 +523,30 @@ function buildDb(report, dbPath = ":memory:") {
 			mutator TEXT NOT NULL,
 			file TEXT NOT NULL,
 			line INTEGER,
-			status TEXT NOT NULL
+			status TEXT NOT NULL,
+			contract_only INTEGER NOT NULL DEFAULT 0
+		);
+		-- requires/ensures sites and the mutants each one killed (bun engine, contracts on)
+		CREATE TABLE contract_sites (
+			id TEXT PRIMARY KEY,
+			file TEXT NOT NULL,
+			line INTEGER NOT NULL,
+			primitive TEXT NOT NULL,
+			message TEXT,
+			handler_from INTEGER,
+			handler_to INTEGER
+		);
+		CREATE TABLE contract_kills (
+			mutant_id TEXT NOT NULL REFERENCES mutants(id),
+			contract_id TEXT NOT NULL,
+			PRIMARY KEY (mutant_id, contract_id)
+		);
+		CREATE TABLE contract_violations (
+			target TEXT NOT NULL,
+			test TEXT NOT NULL,
+			contract_id TEXT
 		);
+		CREATE TABLE report_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
 		-- the kill matrix: (mutant, test) where test detects mutant
 		CREATE TABLE kills (
 			mutant_id TEXT NOT NULL REFERENCES mutants(id),
@@ -154,9 +563,13 @@ function buildDb(report, dbPath = ":memory:") {
 		CREATE INDEX idx_kills_mutant ON kills(mutant_id);
 	`);
   const insTest = db.prepare("INSERT OR IGNORE INTO tests (id, file, name, line) VALUES (?, ?, ?, ?)");
-  const insMut = db.prepare("INSERT INTO mutants (id, mutator, file, line, status) VALUES (?, ?, ?, ?, ?)");
+  const insMut = db.prepare("INSERT INTO mutants (id, mutator, file, line, status, contract_only) VALUES (?, ?, ?, ?, ?, ?)");
   const insKill = db.prepare("INSERT OR IGNORE INTO kills (mutant_id, test_id) VALUES (?, ?)");
   const insCover = db.prepare("INSERT OR IGNORE INTO covers (mutant_id, test_id) VALUES (?, ?)");
+  const insContractKill = db.prepare("INSERT OR IGNORE INTO contract_kills (mutant_id, contract_id) VALUES (?, ?)");
+  const insSite = db.prepare("INSERT OR IGNORE INTO contract_sites (id, file, line, primitive, message, handler_from, handler_to) VALUES (?, ?, ?, ?, ?, ?, ?)");
+  const insViolation = db.prepare("INSERT INTO contract_violations (target, test, contract_id) VALUES (?, ?, ?)");
+  const insMeta = db.prepare("INSERT INTO report_meta (key, value) VALUES (?, ?)");
   const ingest = db.transaction(() => {
     for (const [file, tf] of Object.entries(report.testFiles ?? {})) {
       for (const t of tf.tests) {
@@ -165,215 +578,2607 @@ function buildDb(report, dbPath = ":memory:") {
     }
     for (const [file, f] of Object.entries(report.files)) {
       for (const m of f.mutants) {
-        insMut.run(m.id, m.mutatorName, file, m.location.start.line, m.status);
+        insMut.run(m.id, m.mutatorName, file, m.location.start.line, m.status, m.contractOnly ? 1 : 0);
         for (const tid of m.killedBy ?? [])
           insKill.run(m.id, tid);
         for (const tid of m.coveredBy ?? [])
           insCover.run(m.id, tid);
+        for (const cid of m.killedByContract ?? [])
+          insContractKill.run(m.id, cid);
       }
     }
+    const contracts = report.contracts;
+    if (contracts) {
+      insMeta.run("contracts_mode", contracts.mode);
+      insMeta.run("runner", contracts.runner);
+      for (const s of contracts.sites) {
+        insSite.run(s.id, s.file, s.line, s.primitive, s.message ?? null, s.handler?.from ?? null, s.handler?.to ?? null);
+      }
+      for (const v of contracts.violations) {
+        if (v.contracts.length === 0)
+          insViolation.run(v.target, v.test, null);
+        for (const cid of v.contracts)
+          insViolation.run(v.target, v.test, cid);
+      }
+    }
+  });
+  ingest();
+  return db;
+}
+function queryAll(db, sql) {
+  return db.query(sql).all();
+}
+function queryGet(db, sql) {
+  return db.query(sql).get();
+}
+async function loadMutationReport(path) {
+  return await Bun.file(path).json();
+}
+if (false) {}
+
+// tools/mutate/src/decisions.ts
+var DEFAULT_LOG = ".polly/test-debt/decisions.jsonl";
+var VERDICTS = ["keep", "prune", "rewrite", "investigate"];
+function normalizeSource(src) {
+  return src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1").replace(/\s+/g, " ").trim();
+}
+async function fileHash(file) {
+  const f = Bun.file(file);
+  if (!await f.exists())
+    return null;
+  return createHash("sha256").update(normalizeSource(await f.text())).digest("hex").slice(0, 16);
+}
+function fileSignals(db) {
+  const rows = queryAll(db, `
+			WITH file_kill AS (SELECT DISTINCT t.file file, k.mutant_id mid FROM kills k JOIN tests t ON t.id=k.test_id),
+			     owner AS (SELECT mid, count(DISTINCT file) nf FROM file_kill GROUP BY mid)
+			SELECT fk.file file, count(DISTINCT fk.mid) kills,
+			       sum(CASE WHEN o.nf=1 THEN 1 ELSE 0 END) unique_kills
+			FROM file_kill fk JOIN owner o ON o.mid=fk.mid GROUP BY fk.file`);
+  const m = new Map;
+  for (const r of rows)
+    m.set(r.file, {
+      kills: r.kills,
+      uniqueKills: r.unique_kills,
+      subsumed: r.kills > 0 && r.unique_kills === 0
+    });
+  return m;
+}
+async function loadDecisions(logPath) {
+  const m = new Map;
+  const f = Bun.file(logPath);
+  if (!await f.exists())
+    return m;
+  for (const line of (await f.text()).split(`
+`)) {
+    const t = line.trim();
+    if (!t)
+      continue;
+    const d = JSON.parse(t);
+    m.set(d.file, d);
+  }
+  return m;
+}
+function staleReason(d, currentHash, current) {
+  if (!current)
+    return "file no longer kills any mutant (renamed/deleted/refactored?)";
+  if (d.hash !== currentHash)
+    return "test file changed since the decision";
+  if (d.signal.subsumed !== current.subsumed)
+    return `subsumption flipped (${d.signal.subsumed} → ${current.subsumed})`;
+  if (d.signal.uniqueKills > 0 !== current.uniqueKills > 0)
+    return `unique-kill status changed (${d.signal.uniqueKills} → ${current.uniqueKills})`;
+  return null;
+}
+async function status(db, logPath = DEFAULT_LOG) {
+  const signals = fileSignals(db);
+  const decisions = await loadDecisions(logPath);
+  const needsReview = [];
+  const stale = [];
+  const settled = [];
+  for (const [file, sig] of [...signals].sort((a, b) => b[1].kills - a[1].kills)) {
+    const d = decisions.get(file);
+    if (!d) {
+      if (sig.subsumed)
+        needsReview.push(`  ${file}  (${sig.kills} kills, 0 unique)`);
+      continue;
+    }
+    const reason = staleReason(d, await fileHash(file), sig);
+    if (reason)
+      stale.push(`  ${file}  [${d.verdict}] — ${reason}`);
+    else
+      settled.push(`  ${file}  [${d.verdict}] ${d.rationale ? `— ${d.rationale}` : ""}`);
+  }
+  for (const [file, d] of decisions) {
+    if (!signals.has(file))
+      stale.push(`  ${file}  [${d.verdict}] — file no longer in matrix`);
+  }
+  const out = [];
+  out.push(`NEEDS REVIEW  (subsumed files with no decision — ${needsReview.length})`);
+  out.push(needsReview.length ? needsReview.join(`
+`) : "  none");
+  out.push(`
+STALE  (decision's basis drifted — re-review — ${stale.length})`);
+  out.push(stale.length ? stale.join(`
+`) : "  none");
+  out.push(`
+SETTLED  (fresh decisions, suppressed from action list — ${settled.length})`);
+  out.push(settled.length ? settled.join(`
+`) : "  none");
+  return out.join(`
+`);
+}
+async function decide(file, verdict, rationale, db, logPath = DEFAULT_LOG) {
+  if (!VERDICTS.includes(verdict)) {
+    console.log(`✗ verdict must be one of: ${VERDICTS.join(", ")}`);
+    process.exit(1);
+  }
+  const sig = fileSignals(db).get(file);
+  if (!sig) {
+    console.log(`✗ ${file} is not a test file that kills any mutant in the current matrix`);
+    process.exit(1);
+  }
+  const decided = new Date().toISOString().slice(0, 10);
+  const record = {
+    file,
+    verdict,
+    rationale,
+    signal: sig,
+    hash: await fileHash(file),
+    decided
+  };
+  await Bun.write(logPath, (await Bun.file(logPath).exists() ? await Bun.file(logPath).text() : "") + JSON.stringify(record) + `
+`);
+  console.log(`✓ recorded: ${file} [${verdict}]${rationale ? ` — ${rationale}` : ""}`);
+}
+if (false) {}
+
+// tools/mutate/src/init.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join3 } from "node:path";
+function detectMutate(projectDir) {
+  if (existsSync4(join3(projectDir, "src"))) {
+    return ["src/**/*.ts", "!src/**/*.test.ts", "!src/**/*.d.ts"];
+  }
+  return ["**/*.ts", "!**/*.test.ts", "!**/*.d.ts", "!dist/**", `!${MUTATION_CONFIG_FILE}`];
+}
+function detectTestGlob(projectDir) {
+  for (const d of ["tests", "test"]) {
+    if (existsSync4(join3(projectDir, d)))
+      return `${d}/**/*.test.ts`;
+  }
+  return "**/*.test.ts";
+}
+async function initConfig(projectDir, opts = {}) {
+  const configPath = join3(projectDir, MUTATION_CONFIG_FILE);
+  const warnings = [];
+  const specifier = defineImportSpecifier(projectDir);
+  if (specifier === "@fairfox/polly/mutate") {
+    try {
+      Bun.resolveSync(specifier, projectDir);
+    } catch {
+      warnings.push("@fairfox/polly does not resolve here — install it, or the config cannot load");
+    }
+  }
+  const mutate = detectMutate(projectDir);
+  const testGlob = detectTestGlob(projectDir);
+  if (!existsSync4(join3(projectDir, "src"))) {
+    warnings.push("no src/ directory — adjust `targets` to point at your source");
+  }
+  if (!existsSync4(join3(projectDir, "tests")) && !existsSync4(join3(projectDir, "test"))) {
+    warnings.push(`no tests/ directory — using "${testGlob}"; adjust tests.include if needed`);
+  }
+  if (existsSync4(configPath) && !opts.force) {
+    return { configPath, created: false, specifier, mutate, testGlob, warnings };
+  }
+  const config = { targets: mutate, tests: { include: [testGlob] } };
+  await Bun.write(configPath, renderMutationConfig(config, specifier));
+  return { configPath, created: true, specifier, mutate, testGlob, warnings };
+}
+
+// tools/mutate/src/run.ts
+import { relative as relative7 } from "node:path";
+
+// tools/mutate/src/engine/index.ts
+import { realpathSync as realpathSync4 } from "node:fs";
+import { join as join9, relative as relative6 } from "node:path";
+
+// tools/mutate/src/engine/baseline.ts
+import { relative as relative3 } from "node:path";
+
+// tools/mutate/src/engine/junit.ts
+import { realpathSync } from "node:fs";
+import { relative as relative2, resolve as resolve3 } from "node:path";
+var ENTITIES = {
+  "&quot;": '"',
+  "&apos;": "'",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&amp;": "&"
+};
+function decode(s) {
+  return s.replace(/&(?:quot|apos|lt|gt|amp|#(\d+)|#x([0-9a-f]+));/gi, (m, dec, hex) => {
+    if (dec)
+      return String.fromCodePoint(Number(dec));
+    if (hex)
+      return String.fromCodePoint(Number.parseInt(hex, 16));
+    return ENTITIES[m] ?? m;
+  });
+}
+function attr(attrs, key) {
+  const m = new RegExp(`\\b${key}="([^"]*)"`).exec(attrs);
+  return m?.[1] === undefined ? "" : decode(m[1]);
+}
+function caseStatus(body) {
+  if (/<(?:failure|error)\b/.test(body))
+    return "failed";
+  return /<skipped\b/.test(body) ? "skipped" : "passed";
+}
+var FAILURE = /<(?:failure|error)\b([^>]*?)(?:\/>|>([\s\S]*?)<\/(?:failure|error)>)/;
+function failureMessage(body) {
+  const m = FAILURE.exec(body);
+  if (!m)
+    return;
+  const parts = [attr(m[1] ?? "", "message"), decode(m[2] ?? "")].filter((s) => s.length > 0);
+  return parts.join(`
+`);
+}
+var TAG = /<testsuite\b([^>]*?)(\/?)>|<\/testsuite>|<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+function parseJunit(xml, cwd) {
+  const cases = [];
+  const suites = [];
+  for (const [whole, suiteAttrs, selfClosing, caseAttrs, body] of xml.matchAll(TAG)) {
+    if (whole.startsWith("</testsuite"))
+      suites.pop();
+    else if (suiteAttrs !== undefined && selfClosing !== "/")
+      suites.push(attr(suiteAttrs, "name"));
+    else if (caseAttrs !== undefined)
+      cases.push(caseFrom(suites, caseAttrs, body ?? "", cwd));
+  }
+  return cases;
+}
+function caseFrom(suites, caseAttrs, body, cwd) {
+  const path = [...suites.slice(1), attr(caseAttrs, "name")];
+  const status = caseStatus(body);
+  const message = status === "failed" ? failureMessage(body) : undefined;
+  return {
+    file: resolve3(cwd, attr(caseAttrs, "file")),
+    name: path.join(" > "),
+    filterName: path.join(" "),
+    line: Number(attr(caseAttrs, "line")) || 0,
+    status,
+    ...message === undefined ? {} : { failureMessage: message }
+  };
+}
+function testId(projectCwd, file, name, line) {
+  return `${relative2(projectCwd, file)}#${name}@${line}`;
+}
+var CONTRACT_MARKER = /\[polly-contract (requires|ensures) (.+?):(\d+)\]/g;
+function realOr(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function contractsIn(text, projectCwd) {
+  const ids = new Set;
+  for (const m of text.matchAll(CONTRACT_MARKER)) {
+    if (m[2] && m[3])
+      ids.add(`${relative2(projectCwd, realOr(m[2]))}:${m[3]}`);
+  }
+  return [...ids].sort();
+}
+function contractKills(cases, projectCwd) {
+  const out = [];
+  for (const c of cases) {
+    if (c.status !== "failed" || c.failureMessage === undefined)
+      continue;
+    const contracts = contractsIn(c.failureMessage, projectCwd);
+    if (contracts.length > 0) {
+      out.push({ test: testId(projectCwd, c.file, c.name, c.line), contracts });
+    }
+  }
+  return out;
+}
+var LOAD_FAILURE_NAME = "(file produced no results)";
+function loadFailureId(projectCwd, file) {
+  return testId(projectCwd, file, LOAD_FAILURE_NAME, 0);
+}
+function killers(cases, baselineFiles, projectCwd) {
+  const ids = cases.filter((c) => c.status === "failed").map((c) => testId(projectCwd, c.file, c.name, c.line));
+  const reported = new Set(cases.map((c) => c.file));
+  for (const f of [...baselineFiles].sort()) {
+    if (!reported.has(f))
+      ids.push(loadFailureId(projectCwd, f));
+  }
+  return ids;
+}
+
+// tools/mutate/src/engine/runner.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync5, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+function preloadPath() {
+  const candidates = [
+    `${import.meta.dir}/preload.js`,
+    `${import.meta.dir}/engine/preload.js`,
+    `${import.meta.dir}/preload.ts`
+  ];
+  const found = candidates.find((c) => existsSync5(c));
+  if (!found)
+    throw new Error(`polly mutate: cannot find the engine preload (looked in ${import.meta.dir})`);
+  return found;
+}
+function cleanEnv(extra) {
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== undefined && !k.startsWith("POLLY_MUTATE_") && k !== "POLLY_CONTRACTS")
+      env[k] = v;
+  }
+  return { ...env, ...extra };
+}
+async function readJunit(path) {
+  if (!path)
+    return;
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return;
+  const xml = await file.text();
+  rmSync(path, { force: true });
+  return xml;
+}
+function processArgv(runner, run, junitPath) {
+  const env = { ...run.env, POLLY_CONTRACTS: run.contracts ?? "off" };
+  if (runner.kind === "command") {
+    const inherited = process.env["BUN_OPTIONS"];
+    const preloads = run.preloads.map((p) => `--preload=${p}`).join(" ");
+    return {
+      argv: runner.argv,
+      env: { ...env, BUN_OPTIONS: inherited ? `${inherited} ${preloads}` : preloads }
+    };
+  }
+  return {
+    argv: [
+      "bun",
+      "test",
+      ...run.preloads.flatMap((p) => ["--preload", p]),
+      ...run.bail ? ["--bail"] : [],
+      ...run.namePattern ? ["-t", run.namePattern] : [],
+      ...junitPath ? ["--reporter=junit", `--reporter-outfile=${junitPath}`] : [],
+      ...run.files
+    ],
+    env
+  };
+}
+async function runBunTest(run, runner = { kind: "bun-test" }) {
+  const started = performance.now();
+  const junitPath = run.junit && runner.kind === "bun-test" ? join4(tmpdir(), `polly-mutate-junit-${randomUUID()}.xml`) : undefined;
+  const { argv, env } = processArgv(runner, run, junitPath);
+  const group = runner.kind === "command";
+  const proc = Bun.spawn(argv, {
+    cwd: run.cwd,
+    detached: group,
+    env: cleanEnv(env),
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: run.captureStderr ? "pipe" : "ignore"
+  });
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    if (group)
+      process.kill(-proc.pid, 9);
+    else
+      proc.kill(9);
+  }, run.timeoutMs);
+  const stderrText = run.captureStderr && proc.stderr ? new Response(proc.stderr).text() : undefined;
+  const exitCode = await proc.exited;
+  clearTimeout(timer);
+  const ms = performance.now() - started;
+  const junitXml = await readJunit(junitPath);
+  const outcome = { exitCode, timedOut, ms, ...junitXml ? { junitXml } : {} };
+  if (stderrText === undefined)
+    return outcome;
+  return { ...outcome, stderrTail: (await stderrText).slice(-2000) };
+}
+async function pool(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      const item = items[i];
+      if (item !== undefined)
+        results[i] = await fn(item, i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, worker));
+  return results;
+}
+
+// tools/mutate/src/engine/workdir.ts
+import { existsSync as existsSync6, mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join5 } from "node:path";
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function absolutePreload(spec, projectCwd) {
+  if (typeof spec !== "string")
+    return spec;
+  try {
+    return Bun.resolveSync(spec, projectCwd);
+  } catch {
+    return spec;
+  }
+}
+function absolutiseBunfig(config, projectCwd) {
+  const fix = (v) => Array.isArray(v) ? v.map((s) => absolutePreload(s, projectCwd)) : absolutePreload(v, projectCwd);
+  const out = { ...config };
+  if ("preload" in out)
+    out["preload"] = fix(out["preload"]);
+  const test = out["test"];
+  if (isRecord2(test) && "preload" in test)
+    out["test"] = { ...test, preload: fix(test["preload"]) };
+  return out;
+}
+var tomlKey = (k) => /^[A-Za-z0-9_-]+$/.test(k) ? k : JSON.stringify(k);
+function tomlValue(v) {
+  if (Array.isArray(v))
+    return `[${v.map(tomlValue).join(", ")}]`;
+  if (isRecord2(v)) {
+    return `{ ${Object.entries(v).map(([k, x]) => `${tomlKey(k)} = ${tomlValue(x)}`).join(", ")} }`;
+  }
+  if (typeof v === "string")
+    return JSON.stringify(v);
+  return String(v);
+}
+function renderToml(config, prefix = []) {
+  const lines = [];
+  const tables = [];
+  for (const [k, v] of Object.entries(config)) {
+    if (isRecord2(v))
+      tables.push([k, v]);
+    else
+      lines.push(`${tomlKey(k)} = ${tomlValue(v)}`);
+  }
+  const sections = tables.map(([k, v]) => {
+    const path = [...prefix, k];
+    return `[${path.map(tomlKey).join(".")}]
+${renderToml(v, path)}`;
+  });
+  return [lines.join(`
+`), ...sections].filter(Boolean).join(`
+
+`);
+}
+function createWorkdirs(projectCwd) {
+  const root = mkdtempSync(join5(tmpdir2(), "polly-mutate-"));
+  const files = {};
+  const tsconfig = join5(projectCwd, "tsconfig.json");
+  if (existsSync6(tsconfig))
+    files["tsconfig.json"] = JSON.stringify({ extends: tsconfig });
+  const bunfig = join5(projectCwd, "bunfig.toml");
+  if (existsSync6(bunfig)) {
+    const parsed = Bun.TOML.parse(readFileSync2(bunfig, "utf8"));
+    if (isRecord2(parsed))
+      files["bunfig.toml"] = renderToml(absolutiseBunfig(parsed, projectCwd));
+  }
+  return {
+    root,
+    create() {
+      mkdirSync(root, { recursive: true });
+      const dir = mkdtempSync(join5(root, "run-"));
+      for (const [name, text] of Object.entries(files))
+        writeFileSync(join5(dir, name), text);
+      return dir;
+    },
+    release: (dir) => rmSync2(dir, { recursive: true, force: true }),
+    remove: () => rmSync2(root, { recursive: true, force: true })
+  };
+}
+async function inCwd(workdirs, projectCwd, fn) {
+  if (!workdirs)
+    return fn(projectCwd);
+  const dir = workdirs.create();
+  try {
+    return await fn(dir);
+  } finally {
+    workdirs.release(dir);
+  }
+}
+
+// tools/mutate/src/engine/baseline.ts
+var BASELINE_ATTEMPTS = 3;
+var BASELINE_TIMEOUT_MS = 300000;
+function failed(reason, contractViolations) {
+  return {
+    ok: false,
+    ms: 0,
+    reason,
+    tests: [],
+    reportedFiles: new Set,
+    ...contractViolations ? { contractViolations } : {}
+  };
+}
+var COMMAND = "(command)";
+async function commandViolatesContract(cfg, cwd, preloads, files) {
+  const off = await runBunTest({
+    cwd,
+    files,
+    preloads,
+    contracts: "off",
+    bail: false,
+    timeoutMs: BASELINE_TIMEOUT_MS,
+    captureStderr: true
+  }, cfg.runner);
+  return off.exitCode === 0 && !off.timedOut;
+}
+function green(cfg, cwd, outcome) {
+  if (cfg.mode === "fast")
+    return { ok: true, ms: outcome.ms, tests: [], reportedFiles: new Set };
+  const cases = parseJunit(outcome.junitXml ?? "", cwd);
+  if (cases.length === 0) {
+    return failed("baseline passed but its junit report holds no test case (reporter broke?)");
+  }
+  return {
+    ok: true,
+    ms: outcome.ms,
+    tests: cases.map((c) => ({
+      id: testId(cfg.cwd, c.file, c.name, c.line),
+      file: c.file,
+      name: c.name,
+      line: c.line
+    })),
+    reportedFiles: new Set(cases.map((c) => c.file))
+  };
+}
+async function measureIn(cfg, cwd, preloads, files) {
+  let last = "";
+  for (let attempt = 1;attempt <= BASELINE_ATTEMPTS; attempt++) {
+    const outcome = await runBunTest({
+      cwd,
+      files,
+      preloads,
+      contracts: cfg.contracts,
+      bail: false,
+      timeoutMs: BASELINE_TIMEOUT_MS,
+      captureStderr: true,
+      junit: cfg.mode === "matrix" || cfg.contracts !== "off" && cfg.runner.kind === "bun-test"
+    }, cfg.runner);
+    if (outcome.exitCode === 0 && !outcome.timedOut)
+      return green(cfg, cwd, outcome);
+    last = outcome.timedOut ? `timed out after ${BASELINE_TIMEOUT_MS} ms` : `exit ${outcome.exitCode}`;
+    const failLine = outcome.stderrTail?.match(/\(fail\)[^\n]*/)?.[0];
+    if (failLine)
+      last += `: ${failLine}`;
+    if (cfg.contracts === "off" || outcome.timedOut)
+      continue;
+    const contract = await contractFailure(cfg, cwd, preloads, files, outcome.junitXml, last);
+    if (contract)
+      return contract;
+  }
+  return failed(`baseline red ${BASELINE_ATTEMPTS}× on the selected tests (${last})`);
+}
+async function contractFailure(cfg, cwd, preloads, files, junitXml, last) {
+  if (cfg.runner.kind === "command") {
+    if (!await commandViolatesContract(cfg, cwd, preloads, files))
+      return null;
+    return failed(`the command fails only with contracts on (POLLY_CONTRACTS=${cfg.contracts}): a scenario violates a contract`, [{ test: COMMAND, contracts: [] }]);
+  }
+  const cases = parseJunit(junitXml ?? "", cwd);
+  const violations = contractKills(cases, cfg.cwd);
+  if (violations.length === 0)
+    return null;
+  const red = cases.filter((c) => c.status === "failed").length;
+  return failed(violations.length === red ? `${violations.length} test(s) violate contracts` : `baseline red (${last}) and ${violations.length} of ${red} failing test(s) violate contracts`, violations);
+}
+async function measureBaseline(cfg, workdirs, preloads, target, log) {
+  const scratch = await inCwd(workdirs, cfg.cwd, (cwd) => measureIn(cfg, cwd, preloads, target.covering));
+  if (scratch.ok || !workdirs || scratch.contractViolations) {
+    return { ...scratch, inTree: !workdirs };
+  }
+  const inTree = await measureIn(cfg, cfg.cwd, preloads, target.covering);
+  if (inTree.ok) {
+    log(`${relative3(cfg.cwd, target.file)}: tests fail outside ${cfg.cwd} (${scratch.reason}); its mutants run in-tree`);
+  }
+  return { ...inTree, inTree: true };
+}
+
+// tools/mutate/src/engine/cache.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+var CACHE_VERSION = 2;
+function mutantSig(m) {
+  return `${m.mutatorName}:${m.start}:${m.end}:${m.replacement}`;
+}
+async function textOrEmpty(path) {
+  const file = Bun.file(path);
+  return await file.exists() ? file.text() : "";
+}
+async function cacheKey(input) {
+  const hash = new Bun.CryptoHasher("sha256");
+  hash.update(JSON.stringify({ v: CACHE_VERSION, bun: Bun.version, settings: input.settings }));
+  for (const m of input.mutants)
+    hash.update(`${mutantSig(m)}|${m.ignoredReason ?? ""}
+`);
+  for (const f of [...input.closure, ...input.projectFiles]) {
+    hash.update(`\x00${f}\x00`);
+    hash.update(await textOrEmpty(f));
+  }
+  return hash.digest("hex");
+}
+async function readCache(dir, key) {
+  const file = Bun.file(join6(dir, `${key}.json`));
+  if (!await file.exists())
+    return null;
+  try {
+    const entry = await file.json();
+    return Array.isArray(entry.results) ? entry : null;
+  } catch {
+    return null;
+  }
+}
+function writeEntry(dir, name, value) {
+  mkdirSync2(dir, { recursive: true });
+  const ignore = join6(dir, ".gitignore");
+  if (!existsSync7(ignore))
+    writeFileSync2(ignore, `*
+`);
+  writeFileSync2(join6(dir, name), `${JSON.stringify(value)}
+`);
+}
+function writeCache(dir, key, entry) {
+  writeEntry(dir, `${key}.json`, entry);
+}
+function writeCoverageCache(dir, key, coverage) {
+  writeEntry(dir, `coverage-${key}.json`, coverage);
+}
+async function readCoverageCache(dir, key) {
+  const file = Bun.file(join6(dir, `coverage-${key}.json`));
+  if (!await file.exists())
+    return null;
+  try {
+    const coverage = await file.json();
+    return Array.isArray(coverage.targets) ? coverage : null;
+  } catch {
+    return null;
+  }
+}
+function cachedResult(r) {
+  return {
+    sig: mutantSig(r.mutant),
+    status: r.status,
+    ...r.statusReason ? { statusReason: r.statusReason } : {},
+    ...r.durationMs === undefined ? {} : { durationMs: r.durationMs },
+    ...r.killedBy ? { killedBy: r.killedBy } : {},
+    ...r.coveredBy ? { coveredBy: r.coveredBy } : {},
+    ...r.killedByContract ? { killedByContract: r.killedByContract } : {},
+    ...r.contractOnly ? { contractOnly: true } : {}
+  };
+}
+
+// tools/mutate/src/engine/coverage.ts
+import { mkdtempSync as mkdtempSync2, realpathSync as realpathSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join7 } from "node:path";
+
+// tools/mutate/src/engine/probes.ts
+import { parseSync } from "oxc-parser";
+
+// tools/mutate/src/engine/ast.ts
+function isAstNode(value) {
+  return isRecord(value) && typeof value["type"] === "string" && typeof value["start"] === "number" && typeof value["end"] === "number";
+}
+function child(node, key) {
+  const value = node[key];
+  return isAstNode(value) ? value : undefined;
+}
+function children(node, key) {
+  const value = node[key];
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function stringField(node, key) {
+  const value = node[key];
+  return typeof value === "string" ? value : undefined;
+}
+function calleeName(call) {
+  const callee = child(call, "callee");
+  if (!callee)
+    return;
+  if (callee.type === "Identifier")
+    return stringField(callee, "name");
+  if (callee.type === "MemberExpression" && callee["computed"] !== true) {
+    const property = child(callee, "property");
+    if (property?.type === "Identifier")
+      return stringField(property, "name");
+  }
+  return;
+}
+
+// tools/mutate/src/engine/probes.ts
+var HIT = "globalThis.__pollyMutateHit?.";
+var PARSE_OPTIONS = { preserveParens: false };
+var LIST_PARENTS = new Set(["Program", "BlockStatement", "StaticBlock", "TSModuleBlock"]);
+var LONE_PARENTS = {
+  IfStatement: ["consequent", "alternate"],
+  ForStatement: ["body"],
+  ForInStatement: ["body"],
+  ForOfStatement: ["body"],
+  WhileStatement: ["body"],
+  DoWhileStatement: ["body"],
+  WithStatement: ["body"]
+};
+var ANONYMOUS = new Set(["FunctionExpression", "ArrowFunctionExpression", "ClassExpression"]);
+function isDirective(node) {
+  return node?.type === "ExpressionStatement" && typeof node["directive"] === "string";
+}
+function afterDirectives(statements, from) {
+  let at = from;
+  for (const s of statements) {
+    if (!isDirective(s))
+      break;
+    at = s.end;
+  }
+  return at;
+}
+function inList(parent, key) {
+  return LIST_PARENTS.has(parent.type) && key === "body" || parent.type === "SwitchCase" && key === "consequent";
+}
+function isLone(node, parent, key) {
+  return (LONE_PARENTS[parent.type]?.includes(key) ?? false) && node.type !== "BlockStatement" && !node.type.endsWith("Declaration");
+}
+function isWrappedValue(node, parent, key) {
+  const value = parent.type === "ArrowFunctionExpression" && key === "body" && parent["expression"] === true || (parent.type === "PropertyDefinition" || parent.type === "AccessorProperty") && key === "value" || parent.type === "AssignmentPattern" && key === "right";
+  const named = parent.type !== "ArrowFunctionExpression" && ANONYMOUS.has(node.type);
+  return value && !named;
+}
+function sitesOf(node, parent, key) {
+  const sites = [];
+  const span = { start: node.start, end: node.end };
+  if (node.type === "BlockStatement" || node.type === "StaticBlock") {
+    sites.push({
+      kind: "block",
+      ...span,
+      at: afterDirectives(children(node, "body"), node.start + 1)
+    });
+  }
+  if (!parent)
+    return sites;
+  if (inList(parent, key)) {
+    sites.push({ kind: "statement", ...span, at: isDirective(node) ? node.end : node.start });
+  } else if (isLone(node, parent, key)) {
+    sites.push({ kind: "lone", ...span, at: node.start });
+  } else if (isWrappedValue(node, parent, key)) {
+    sites.push({ kind: "expression", ...span, at: node.start });
+  }
+  return sites;
+}
+function collectSites(program) {
+  const sites = [];
+  const visit = (node, parent, key) => {
+    sites.push(...sitesOf(node, parent, key));
+    for (const [k, value] of Object.entries(node)) {
+      const list = Array.isArray(value) ? value : [value];
+      for (const c of list)
+        if (isAstNode(c))
+          visit(c, node, k);
+    }
+  };
+  for (const s of children(program, "body"))
+    visit(s, program, "body");
+  return sites;
+}
+function innermost(sites, start, end) {
+  let best = null;
+  for (const s of sites) {
+    if (s.start > start || s.end < end)
+      continue;
+    if (!best || s.end - s.start < best.end - best.start)
+      best = s;
+    else if (s.end - s.start === best.end - best.start && s.kind === "block")
+      best = s;
+  }
+  return best;
+}
+function edits(site, probe) {
+  const hit = `${HIT}(${probe})`;
+  const open = (text) => ({ at: site.at, text, order: [1, -site.end] });
+  const close = (text) => ({ at: site.end, text, order: [0, -site.start] });
+  switch (site.kind) {
+    case "statement":
+    case "block":
+      return [open(`;${hit};`)];
+    case "lone":
+      return [open(`{;${hit};`), close("}")];
+    case "expression":
+      return [open(`(${hit},`), close(")")];
+  }
+}
+function applyEdits(src, all) {
+  all.sort((a, b) => a.at - b.at || a.order[0] - b.order[0] || a.order[1] - b.order[1]);
+  let out = "";
+  let from = 0;
+  for (const e of all) {
+    out += src.slice(from, e.at) + e.text;
+    from = e.at;
+  }
+  return out + src.slice(from);
+}
+function instrument(file, src, mutants, firstProbe) {
+  const parsed = parseSync(file, src, PARSE_OPTIONS);
+  if (parsed.errors.length > 0 || !isAstNode(parsed.program))
+    return null;
+  const sites = collectSites(parsed.program);
+  const bySite = new Map;
+  for (const m of mutants) {
+    const site = innermost(sites, m.start, m.end);
+    if (!site)
+      return null;
+    bySite.set(site, [...bySite.get(site) ?? [], m.id]);
+  }
+  const probes = [];
+  const all = [];
+  for (const [site, ids] of bySite) {
+    all.push(...edits(site, firstProbe + probes.length));
+    probes.push(ids);
+  }
+  const code = applyEdits(src, all);
+  if (parseSync(file, code, PARSE_OPTIONS).errors.length > 0)
+    return null;
+  return { code, probes };
+}
+
+// tools/mutate/src/engine/coverage.ts
+var COVERAGE_VERSION = 1;
+var COVERAGE_TIMEOUT_MS = 600000;
+var MAX_PATTERN = 8000;
+var numbers = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "number") : [];
+function parseHits(raw) {
+  if (!isRecord(raw) || !Array.isArray(raw["files"]))
+    return null;
+  return {
+    served: numbers(raw["served"]),
+    outside: numbers(raw["outside"]),
+    files: raw["files"].filter(isRecord).map((f) => ({
+      load: numbers(f["load"]),
+      between: numbers(f["between"]),
+      tests: Array.isArray(f["tests"]) ? f["tests"].map(numbers) : [],
+      overlapped: f["overlapped"] === true
+    }))
+  };
+}
+function real(path) {
+  try {
+    return realpathSync2(path);
+  } catch {
+    return path;
+  }
+}
+function chunk(items, n) {
+  const count = Math.max(1, Math.min(n, items.length));
+  const size = Math.ceil(items.length / count);
+  const out = [];
+  for (let i = 0;i < items.length; i += size)
+    out.push(items.slice(i, i + size));
+  return out;
+}
+function newProbeHits() {
+  return { tests: new Set, files: new Set, loads: new Set, static: false };
+}
+
+class Attribution {
+  cwd;
+  probes = new Map;
+  served = new Set;
+  tests = {};
+  byFile = {};
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  at(probe) {
+    let hits = this.probes.get(probe);
+    if (!hits) {
+      hits = newProbeHits();
+      this.probes.set(probe, hits);
+    }
+    return hits;
+  }
+  record(c) {
+    const id = testId(this.cwd, c.file, c.name, c.line);
+    if (!this.tests[id]) {
+      this.tests[id] = { id, file: c.file, name: c.name, line: c.line, filterName: c.filterName };
+      const file = real(c.file);
+      this.byFile[file] = [...this.byFile[file] ?? [], id];
+    }
+    return id;
+  }
+  add(testFiles, hits, cases) {
+    for (const t of hits.served)
+      this.served.add(t);
+    for (const p of hits.outside)
+      this.at(p).static = true;
+    const ran = new Map;
+    for (const c of cases) {
+      if (c.status === "skipped")
+        continue;
+      const file = real(c.file);
+      ran.set(file, [...ran.get(file) ?? [], c]);
+    }
+    hits.files.forEach((f, i) => {
+      const file = testFiles[i];
+      if (!file)
+        return;
+      const fileCases = ran.get(file) ?? [];
+      const ids = fileCases.map((c) => this.record(c));
+      for (const p of f.load) {
+        const h = this.at(p);
+        h.static = true;
+        h.loads.add(file);
+      }
+      for (const p of f.between)
+        this.at(p).files.add(file);
+      const ordered = !f.overlapped && f.tests.length === ids.length;
+      f.tests.forEach((probes, k) => {
+        const id = ids[k];
+        for (const p of probes) {
+          if (ordered && id)
+            this.at(p).tests.add(id);
+          else
+            this.at(p).files.add(file);
+        }
+      });
+    });
+  }
+}
+async function planTargets(run) {
+  const plan = [];
+  const probes = [];
+  const failed = new Map;
+  for (const [target, t] of run.targets.entries()) {
+    const probed = instrument(t.file, await Bun.file(t.file).text(), t.mutants, probes.length);
+    if (!probed) {
+      failed.set(target, "its probed source does not parse");
+      continue;
+    }
+    plan.push({ file: t.file, code: probed.code });
+    for (const ids of probed.probes)
+      probes.push({ target, ids });
+  }
+  return { plan, probes, failed };
+}
+function sorted(set) {
+  return [...new Set(set)].sort();
+}
+function usersOf(t, attribution, mine) {
+  const users = new Set(t.covering);
+  for (const { probe } of mine) {
+    const h = attribution.probes.get(probe);
+    if (!h)
+      continue;
+    const testFiles = [...h.tests].flatMap((id) => {
+      const file = attribution.tests[id]?.file;
+      return file ? [real(file)] : [];
+    });
+    for (const f of [...testFiles, ...h.files, ...h.loads])
+      users.add(f);
+  }
+  return users;
+}
+function targetCoverage(run, target, attribution, probes) {
+  const t = run.targets[target];
+  if (!t)
+    return { kind: "static", reason: "missing target" };
+  const mine = probes.flatMap((p, probe) => p.target === target ? [{ probe, ids: p.ids }] : []);
+  if (!attribution.served.has(target) && t.covering.length > 0) {
+    return {
+      kind: "static",
+      reason: "a test imports it but the coverage pass never loaded it (a project preload may)"
+    };
+  }
+  const users = usersOf(t, attribution, mine);
+  const mutants = {};
+  for (const { probe, ids } of mine) {
+    const h = attribution.probes.get(probe) ?? newProbeHits();
+    const files = h.static ? [...users, ...h.files] : [...h.files];
+    const cov = { tests: sorted(h.tests), files: sorted(files) };
+    for (const id of ids)
+      mutants[id] = cov;
+  }
+  return { kind: "dynamic", mutants };
+}
+async function collectCoverage(run) {
+  const { plan, probes, failed } = await planTargets(run);
+  const dir = mkdtempSync2(join7(tmpdir3(), "polly-mutate-coverage-"));
+  try {
+    const planPath = join7(dir, "plan.json");
+    writeFileSync3(planPath, JSON.stringify({ targets: plan, tests: run.testFiles }));
+    const attribution = new Attribution(run.cwd);
+    const chunks = chunk(run.testFiles, run.concurrency);
+    const outcomes = await pool(chunks, run.concurrency, async (files, i) => {
+      const out = join7(dir, `hits-${i}.json`);
+      const attempt = (workdirs) => inCwd(workdirs, run.cwd, async (cwd) => {
+        rmSync3(out, { force: true });
+        const outcome = await runBunTest({
+          cwd,
+          files,
+          preloads: run.preloads,
+          env: { POLLY_MUTATE_COVERAGE: planPath, POLLY_MUTATE_COVERAGE_OUT: out },
+          contracts: run.contracts,
+          bail: false,
+          junit: true,
+          timeoutMs: COVERAGE_TIMEOUT_MS,
+          captureStderr: true
+        });
+        const file = Bun.file(out);
+        const hits = await file.exists() ? parseHits(await file.json()) : null;
+        return { outcome, hits, cwd };
+      });
+      const scratch = await attempt(run.workdirs);
+      if (scratch.outcome.exitCode === 0 || !run.workdirs)
+        return scratch;
+      run.log(`coverage pass: process ${i + 1}/${chunks.length} is red in a scratch cwd; rerun in-tree`);
+      return attempt(null);
+    });
+    for (const [i, { outcome, hits, cwd }] of outcomes.entries()) {
+      if (!hits) {
+        run.log(`coverage pass: process ${i + 1}/${chunks.length} wrote no data (${outcome.timedOut ? "timed out" : `exit ${outcome.exitCode}`}); every target keeps static selection`);
+        return null;
+      }
+      if (outcome.exitCode !== 0) {
+        const failLine = outcome.stderrTail?.match(/\(fail\)[^\n]*/)?.[0] ?? "";
+        run.log(`coverage pass: tests failed in process ${i + 1}/${chunks.length} (exit ${outcome.exitCode}) ${failLine}`.trim());
+      }
+      attribution.add(run.testFiles, hits, parseJunit(outcome.junitXml ?? "", cwd));
+    }
+    const targets = run.targets.map((_, i) => {
+      const reason = failed.get(i);
+      if (reason)
+        return { kind: "static", reason };
+      return targetCoverage(run, i, attribution, probes);
+    });
+    return { targets, tests: attribution.tests, byFile: attribution.byFile };
+  } finally {
+    rmSync3(dir, { recursive: true, force: true });
+  }
+}
+var escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function selectionFor(cov, coverage) {
+  const named = cov.tests.flatMap((id) => {
+    const t = coverage.tests[id];
+    return t ? [t] : [];
+  });
+  const files = sorted([...cov.files, ...named.map((t) => real(t.file))]);
+  const coveredBy = sorted([...cov.tests, ...cov.files.flatMap((f) => coverage.byFile[f] ?? [])]);
+  if (cov.files.length > 0 || named.length === 0)
+    return { files, coveredBy };
+  const pattern = `^(?:${sorted(named.map((t) => escapeRegex(t.filterName))).join("|")})$`;
+  return pattern.length > MAX_PATTERN ? { files, coveredBy } : { files, namePattern: pattern, coveredBy };
+}
+
+// tools/mutate/src/engine/generate.ts
+import { parseSync as parseSync2 } from "oxc-parser";
+
+// tools/mutate/src/engine/operators.ts
+import { mutate as mutateRegex } from "weapon-regex";
+var EQUALITY = {
+  "<": ["<=", ">="],
+  "<=": ["<", ">"],
+  ">": [">=", "<="],
+  ">=": [">", "<"],
+  "==": ["!="],
+  "!=": ["=="],
+  "===": ["!=="],
+  "!==": ["==="]
+};
+var ARITHMETIC = { "+": "-", "-": "+", "*": "/", "/": "*", "%": "*" };
+var LOGICAL = { "&&": "||", "||": "&&", "??": "&&" };
+var ASSIGNMENT = {
+  "+=": "-=",
+  "-=": "+=",
+  "*=": "/=",
+  "/=": "*=",
+  "%=": "*=",
+  "<<=": ">>=",
+  ">>=": "<<=",
+  "&=": "|=",
+  "|=": "&=",
+  "&&=": "||=",
+  "||=": "&&=",
+  "??=": "&&="
+};
+var STRING_SAFE_ASSIGNMENTS = new Set(["&&=", "||=", "??="]);
+var BOOLEAN_OPERATORS = new Set(["!=", "!==", "&&", "<", "<=", "==", "===", ">", ">=", "||"]);
+var LOOPS = new Set(["ForStatement", "WhileStatement", "DoWhileStatement"]);
+var EMPTY_STRING_REPLACEMENT = '"Stryker was here!"';
+var METHODS = (() => {
+  const forward = [
+    ["charAt", null],
+    ["endsWith", "startsWith"],
+    ["every", "some"],
+    ["filter", null],
+    ["reverse", null],
+    ["slice", null],
+    ["sort", null],
+    ["substr", null],
+    ["substring", null],
+    ["toLocaleLowerCase", "toLocaleUpperCase"],
+    ["toLowerCase", "toUpperCase"],
+    ["trim", null],
+    ["trimEnd", "trimStart"],
+    ["min", "max"],
+    ["setDate", "setTime"],
+    ["setFullYear", "setMonth"],
+    ["setHours", "setMinutes"],
+    ["setSeconds", "setMilliseconds"],
+    ["setUTCDate", "setTime"],
+    ["setUTCFullYear", "setUTCMonth"],
+    ["setUTCHours", "setUTCMinutes"],
+    ["setUTCSeconds", "setUTCMilliseconds"]
+  ];
+  const map = new Map(forward);
+  for (const [name, swap] of forward) {
+    if (swap && name !== "setUTCDate" && name !== "getUTCDate")
+      map.set(swap, name);
+  }
+  return map;
+})();
+function operatorOffset(src, op, left, right) {
+  const gap = src.slice(left.end, right.start);
+  const at = gap.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, (c) => " ".repeat(c.length)).indexOf(op);
+  return at === -1 ? -1 : left.end + at;
+}
+function isStringNode(node) {
+  if (!node)
+    return false;
+  return node.type === "Literal" && typeof node["value"] === "string" || node.type === "TemplateLiteral";
+}
+var text = (src, node) => src.slice(node.start, node.end);
+function binaryParts(node, src) {
+  const op = stringField(node, "operator");
+  const left = child(node, "left");
+  const right = child(node, "right");
+  if (!op || !left || !right)
+    return;
+  const at = operatorOffset(src, op, left, right);
+  return at === -1 ? undefined : { op, left, right, at };
+}
+var binary = (node, ctx) => {
+  if (node.type !== "BinaryExpression")
+    return;
+  const parts = binaryParts(node, ctx.src);
+  if (!parts)
+    return;
+  const { op, left, right, at } = parts;
+  const span = (rep, mutator) => ctx.emit(at, at + op.length, rep, mutator);
+  for (const rep of EQUALITY[op] ?? [])
+    span(rep, "EqualityOperator");
+  const arith = ARITHMETIC[op];
+  const leftProbe = left.type === "BinaryExpression" ? child(left, "right") : left;
+  if (arith && !isStringNode(right) && !isStringNode(leftProbe))
+    span(arith, "ArithmeticOperator");
+};
+var logical = (node, ctx) => {
+  if (node.type !== "LogicalExpression")
+    return;
+  const parts = binaryParts(node, ctx.src);
+  const rep = parts && LOGICAL[parts.op];
+  if (!parts || !rep)
+    return;
+  const { op, left, right, at } = parts;
+  if (op !== "??") {
+    ctx.emit(at, at + op.length, rep, "LogicalOperator");
+    return;
+  }
+  const operand = (n) => n.type === "LogicalExpression" ? `(${text(ctx.src, n)})` : text(ctx.src, n);
+  const slice = (from, to) => ctx.src.slice(from, to);
+  ctx.emit(node.start, node.end, `(${slice(node.start, left.start)}${operand(left)}${slice(left.end, at)}${rep}${slice(at + op.length, right.start)}${operand(right)}${slice(right.end, node.end)})`, "LogicalOperator");
+};
+var assignment = (node, ctx) => {
+  if (node.type !== "AssignmentExpression")
+    return;
+  const parts = binaryParts(node, ctx.src);
+  const rep = parts && ASSIGNMENT[parts.op];
+  if (!parts || !rep)
+    return;
+  if (isStringNode(parts.right) && !STRING_SAFE_ASSIGNMENTS.has(parts.op))
+    return;
+  ctx.emit(parts.at, parts.at + parts.op.length, rep, "AssignmentOperator");
+};
+var booleanLiteral = (node, ctx) => {
+  if (node.type === "Literal" && typeof node["value"] === "boolean") {
+    ctx.emit(node.start, node.end, String(!node["value"]), "BooleanLiteral");
+  }
+  if (node.type === "UnaryExpression" && node["operator"] === "!") {
+    ctx.emit(node.start, node.start + 1, "", "BooleanLiteral");
+  }
+};
+var UNARY = { "+": "-", "-": "+", "~": "" };
+var unary = (node, ctx) => {
+  if (node.type !== "UnaryExpression")
+    return;
+  const op = stringField(node, "operator");
+  const rep = op === undefined ? undefined : UNARY[op];
+  if (rep !== undefined)
+    ctx.emit(node.start, node.start + 1, rep, "UnaryOperator");
+};
+var update = (node, ctx) => {
+  if (node.type !== "UpdateExpression")
+    return;
+  const op = stringField(node, "operator");
+  const arg = child(node, "argument");
+  if (!op || !arg)
+    return;
+  const at = node["prefix"] === true ? node.start : arg.end;
+  const opAt = ctx.src.indexOf(op, at);
+  if (opAt === -1 || opAt >= node.end)
+    return;
+  ctx.emit(opAt, opAt + 2, op === "++" ? "--" : "++", "UpdateOperator");
+};
+function isStructuralString(node, ctx) {
+  const p = ctx.parent;
+  if (!p)
+    return false;
+  if (p.type.startsWith("Export") || p.type === "ImportExpression")
+    return true;
+  if (p.type === "JSXAttribute" || p.type === "ExpressionStatement")
+    return true;
+  if ((p.type === "Property" || p.type === "PropertyDefinition") && child(p, "key") === node) {
+    return true;
+  }
+  if (p.type !== "CallExpression")
+    return false;
+  const callee = child(p, "callee");
+  return callee?.type === "Identifier" && (callee["name"] === "require" || callee["name"] === "Symbol");
+}
+var stringLiteral = (node, ctx) => {
+  if (node.type === "TemplateLiteral") {
+    const quasis = children(node, "quasis");
+    const value = quasis[0]?.["value"];
+    const empty = quasis.length === 1 && isRecord(value) && value["raw"] === "";
+    ctx.emit(node.start, node.end, empty ? "`Stryker was here!`" : "``", "StringLiteral");
+    return;
+  }
+  if (node.type !== "Literal" || typeof node["value"] !== "string")
+    return;
+  if (isStructuralString(node, ctx))
+    return;
+  ctx.emit(node.start, node.end, node["value"] === "" ? EMPTY_STRING_REPLACEMENT : '""', "StringLiteral");
+};
+function isBooleanExpression(node) {
+  if (node.type !== "BinaryExpression" && node.type !== "LogicalExpression")
+    return false;
+  const op = stringField(node, "operator");
+  return op !== undefined && BOOLEAN_OPERATORS.has(op);
+}
+function conditionalTest(node, ctx) {
+  const p = ctx.parent;
+  const emit = (rep) => ctx.emit(node.start, node.end, rep, "ConditionalExpression");
+  if (p && ctx.key === "test" && LOOPS.has(p.type)) {
+    emit("false");
+    return true;
+  }
+  if (p?.type === "IfStatement" && ctx.key === "test") {
+    emit("true");
+    emit("false");
+    return true;
+  }
+  if (!isBooleanExpression(node))
+    return false;
+  const parentOp = p?.type === "LogicalExpression" ? stringField(p, "operator") : undefined;
+  if (parentOp !== "||")
+    emit("true");
+  if (parentOp !== "&&")
+    emit("false");
+  return true;
+}
+function forWithoutTest(node, ctx) {
+  const init = child(node, "init");
+  const open = ctx.src.indexOf("(", node.start);
+  const semi = open === -1 ? -1 : ctx.src.indexOf(";", init ? init.end : open);
+  if (semi !== -1)
+    ctx.emit(semi + 1, semi + 1, "false", "ConditionalExpression");
+}
+function emptySwitchCase(node, ctx) {
+  const body = children(node, "consequent");
+  const first = body[0];
+  const last = body[body.length - 1];
+  if (first && last)
+    ctx.emit(first.start, last.end, "", "ConditionalExpression");
+}
+var conditional = (node, ctx) => {
+  if (conditionalTest(node, ctx))
+    return;
+  if (node.type === "ForStatement" && !child(node, "test"))
+    forWithoutTest(node, ctx);
+  if (node.type === "SwitchCase")
+    emptySwitchCase(node, ctx);
+};
+function containsSuperCall(node) {
+  if (node.type === "CallExpression" && child(node, "callee")?.type === "Super")
+    return true;
+  for (const value of Object.values(node)) {
+    const list = Array.isArray(value) ? value : [value];
+    for (const c of list)
+      if (isAstNode(c) && containsSuperCall(c))
+        return true;
+  }
+  return false;
+}
+function isInvalidConstructorBody(ctx, block) {
+  const n = ctx.ancestors.length;
+  const fn = ctx.ancestors[n - 1];
+  const method = ctx.ancestors[n - 2];
+  const classBody = ctx.ancestors[n - 3];
+  if (!fn || method?.type !== "MethodDefinition" || method["kind"] !== "constructor")
+    return false;
+  const paramProps = children(fn, "params").some((param) => param.type === "TSParameterProperty");
+  const initialisedFields = classBody?.type === "ClassBody" && children(classBody, "body").some((m) => m.type === "PropertyDefinition" && child(m, "value") !== undefined && child(m, "key")?.type !== "PrivateIdentifier");
+  return (paramProps || initialisedFields) && containsSuperCall(block);
+}
+var block = (node, ctx) => {
+  if (node.type !== "BlockStatement" || children(node, "body").length === 0)
+    return;
+  if (isInvalidConstructorBody(ctx, node))
+    return;
+  ctx.emit(node.start, node.end, "{}", "BlockStatement");
+};
+var arrayDeclaration = (node, ctx) => {
+  if (node.type === "ArrayExpression") {
+    const empty = children(node, "elements").length === 0;
+    ctx.emit(node.start, node.end, empty ? '["Stryker was here"]' : "[]", "ArrayDeclaration");
+    return;
+  }
+  if (node.type !== "CallExpression" && node.type !== "NewExpression")
+    return;
+  const callee = child(node, "callee");
+  if (callee?.type !== "Identifier" || callee["name"] !== "Array")
+    return;
+  const args = children(node, "arguments").length === 0 ? "[]" : "";
+  const prefix = node.type === "NewExpression" ? "new " : "";
+  ctx.emit(node.start, node.end, `${prefix}Array(${args})`, "ArrayDeclaration");
+};
+var objectLiteral = (node, ctx) => {
+  if (node.type === "ObjectExpression" && children(node, "properties").length > 0) {
+    ctx.emit(node.start, node.end, "{}", "ObjectLiteral");
+  }
+};
+var arrowFunction = (node, ctx) => {
+  if (node.type !== "ArrowFunctionExpression")
+    return;
+  const body = child(node, "body");
+  if (!body || body.type === "BlockStatement" || node["expression"] === false)
+    return;
+  if (body.type === "Identifier" && body["name"] === "undefined")
+    return;
+  ctx.emit(node.start, node.end, "() => undefined", "ArrowFunction");
+};
+var optionalChaining = (node, ctx) => {
+  if (node["optional"] !== true)
+    return;
+  if (node.type === "MemberExpression") {
+    const object = child(node, "object");
+    if (!object)
+      return;
+    const q = ctx.src.indexOf("?.", object.end);
+    if (q === -1 || q >= node.end)
+      return;
+    ctx.emit(q, q + 2, node["computed"] === true ? "" : ".", "OptionalChaining");
+  }
+  if (node.type === "CallExpression") {
+    const callee = child(node, "callee");
+    if (!callee)
+      return;
+    const q = ctx.src.indexOf("?.", callee.end);
+    if (q === -1 || q >= node.end)
+      return;
+    ctx.emit(q, q + 2, "", "OptionalChaining");
+  }
+};
+var methodExpression = (node, ctx) => {
+  if (node.type !== "CallExpression")
+    return;
+  const callee = child(node, "callee");
+  if (callee?.type !== "MemberExpression" || callee["computed"] === true)
+    return;
+  const property = child(callee, "property");
+  const object = child(callee, "object");
+  if (property?.type !== "Identifier" || !object)
+    return;
+  const name = stringField(property, "name");
+  const swap = name === undefined ? undefined : METHODS.get(name);
+  if (swap === undefined)
+    return;
+  if (swap === null)
+    ctx.emit(node.start, node.end, text(ctx.src, object), "MethodExpression");
+  else
+    ctx.emit(property.start, property.end, swap, "MethodExpression");
+};
+function regexPatterns(pattern, flags) {
+  if (pattern.length === 0)
+    return [];
+  try {
+    return mutateRegex(pattern, flags, { mutationLevels: [1] }).map((m) => m.pattern);
+  } catch {
+    return [];
+  }
+}
+var regex = (node, ctx) => {
+  if (node.type !== "Literal")
+    return;
+  const literal = node["regex"];
+  if (isRecord(literal)) {
+    const pattern = literal["pattern"];
+    const flags = typeof literal["flags"] === "string" ? literal["flags"] : "";
+    if (typeof pattern !== "string")
+      return;
+    for (const p of regexPatterns(pattern, flags)) {
+      ctx.emit(node.start, node.end, `/${p}/${flags}`, "Regex");
+    }
+    return;
+  }
+  const p = ctx.parent;
+  if (typeof node["value"] !== "string" || p?.type !== "NewExpression")
+    return;
+  if (calleeName(p) !== "RegExp" || child(p, "callee")?.type !== "Identifier")
+    return;
+  const [first, second] = children(p, "arguments");
+  if (first !== node)
+    return;
+  const flags = second?.type === "Literal" ? stringField(second, "value") : undefined;
+  for (const pattern of regexPatterns(node["value"], flags)) {
+    ctx.emit(node.start, node.end, JSON.stringify(pattern), "Regex");
+  }
+};
+var OPERATORS = [
+  binary,
+  logical,
+  assignment,
+  booleanLiteral,
+  unary,
+  update,
+  stringLiteral,
+  regex,
+  conditional,
+  block,
+  arrayDeclaration,
+  objectLiteral,
+  arrowFunction,
+  optionalChaining,
+  methodExpression
+];
+
+// tools/mutate/src/engine/verify-callsites.ts
+var VERIFY_PRIMITIVES = new Set([
+  "requires",
+  "ensures",
+  "invariant",
+  "stateConstraint",
+  "forAllPeers",
+  "somePeer"
+]);
+function verifyCallsiteReason(name) {
+  return `Inside polly's ${name}(...) — a runtime no-op (compiled away in production, ` + `translated to a TLA+ assertion in verification). No test can observe or kill ` + `mutations here, so they are excluded from the score (polly#143).`;
+}
+
+// tools/mutate/src/engine/generate.ts
+var TS_RUNTIME_WRAPPERS = new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "TSTypeAssertion",
+  "TSParameterProperty",
+  "TSModuleBlock"
+]);
+var PARSE_OPTIONS2 = { preserveParens: false };
+var TYPE_KEYS = new Set(["typeAnnotation", "returnType", "typeParameters", "typeArguments"]);
+var SKIPPED_STATEMENTS = new Set(["ImportDeclaration", "ExportAllDeclaration", "Decorator"]);
+function isSkipped(node) {
+  if (SKIPPED_STATEMENTS.has(node.type))
+    return true;
+  if (node.type === "VariableDeclaration")
+    return node["declare"] === true;
+  if (node.type === "TSModuleDeclaration")
+    return node["declare"] === true;
+  return node.type.startsWith("TS") && !TS_RUNTIME_WRAPPERS.has(node.type);
+}
+function lineIndex(src) {
+  const starts = [0];
+  for (let i = 0;i < src.length; i++)
+    if (src.charCodeAt(i) === 10)
+      starts.push(i + 1);
+  return (offset) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if ((starts[mid] ?? 0) <= offset)
+        lo = mid;
+      else
+        hi = mid - 1;
+    }
+    return { line: lo + 1, column: offset - (starts[lo] ?? 0) + 1 };
+  };
+}
+function applyMutant(src, m) {
+  return src.slice(0, m.start) + m.replacement + src.slice(m.end);
+}
+function verifyReason(node) {
+  if (node.type !== "CallExpression")
+    return;
+  const name = calleeName(node);
+  return name && VERIFY_PRIMITIVES.has(name) ? verifyCallsiteReason(name) : undefined;
+}
+var FUNCTION_NODES = new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+function contractSite(file, node, ancestors, position) {
+  if (node.type !== "CallExpression")
+    return;
+  const name = calleeName(node);
+  if (name !== "requires" && name !== "ensures")
+    return;
+  const second = children(node, "arguments")[1];
+  const message = second?.type === "Literal" && typeof second["value"] === "string" ? second["value"] : undefined;
+  const handlerNode = [...ancestors].reverse().find((a) => a.type === "CallExpression" && calleeName(a) === "on") ?? [...ancestors].reverse().find((a) => FUNCTION_NODES.has(a.type));
+  const handler = handlerNode ? { from: position(handlerNode.start).line, to: position(handlerNode.end).line } : undefined;
+  return {
+    file,
+    line: position(node.start).line,
+    primitive: name,
+    ...message === undefined ? {} : { message },
+    ...handler ? { handler } : {}
+  };
+}
+function runtimeChildren(node) {
+  const out = [];
+  for (const [k, value] of Object.entries(node)) {
+    if (TYPE_KEYS.has(k))
+      continue;
+    const list = Array.isArray(value) ? value : [value];
+    for (const c of list)
+      if (isAstNode(c))
+        out.push([k, c]);
+  }
+  return out;
+}
+function generateMutants(file, src, opts = {}) {
+  const parsed = parseSync2(file, src, PARSE_OPTIONS2);
+  const first = parsed.errors[0];
+  if (first)
+    throw new Error(`${file}: cannot parse target: ${first.message}`);
+  const position = lineIndex(src);
+  const ignoreVerify = opts.ignoreVerifyCallsites ?? true;
+  const prefix = opts.idPrefix ?? "";
+  const seen = new Set;
+  const excluded = new Set(opts.exclude ?? []);
+  const all = [];
+  const contracts = [];
+  const ancestors = [];
+  const visit = (node, key, ignored) => {
+    if (isSkipped(node))
+      return;
+    const parent = ancestors[ancestors.length - 1];
+    const site = contractSite(file, node, ancestors, position);
+    if (site)
+      contracts.push(site);
+    const ignoredHere = ignored ?? (ignoreVerify ? verifyReason(node) : undefined);
+    const ctx = {
+      src,
+      parent,
+      key,
+      ancestors,
+      emit(start, end, replacement, mutatorName) {
+        if (excluded.has(mutatorName))
+          return;
+        const dedupe = `${start}:${end}:${replacement}`;
+        if (seen.has(dedupe))
+          return;
+        seen.add(dedupe);
+        all.push({
+          id: "",
+          file,
+          mutatorName,
+          start,
+          end,
+          replacement,
+          location: { start: position(start), end: position(end) },
+          ...ignoredHere ? { ignoredReason: ignoredHere } : {}
+        });
+      }
+    };
+    for (const op of OPERATORS)
+      op(node, ctx);
+    ancestors.push(node);
+    for (const [k, c] of runtimeChildren(node))
+      visit(c, k, ignoredHere);
+    ancestors.pop();
+  };
+  for (const statement of parsed.program.body) {
+    if (isAstNode(statement))
+      visit(statement, "body", undefined);
+  }
+  const inRange = opts.lines ? all.filter((m) => m.location.start.line >= (opts.lines?.from ?? 0) && m.location.start.line <= (opts.lines?.to ?? 0)) : all;
+  inRange.sort((a, b) => a.start - b.start || a.end - b.end);
+  inRange.forEach((m, i) => {
+    m.id = `${prefix}${i}`;
+  });
+  const mutants = [];
+  const compileErrors = [];
+  for (const m of inRange) {
+    if (parseSync2(file, applyMutant(src, m), PARSE_OPTIONS2).errors.length > 0)
+      compileErrors.push(m);
+    else
+      mutants.push(m);
+  }
+  return { mutants, compileErrors, contracts };
+}
+
+// tools/mutate/src/engine/graph.ts
+import { realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname4, extname } from "node:path";
+import { Glob as Glob2 } from "bun";
+var SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
+function loaderFor(file) {
+  const ext = extname(file);
+  if (ext === ".tsx")
+    return "tsx";
+  if (ext === ".jsx")
+    return "jsx";
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts")
+    return "ts";
+  return "js";
+}
+function real2(path) {
+  try {
+    return realpathSync3(path);
+  } catch {
+    return path;
+  }
+}
+async function findTestFiles(cwd, include) {
+  const found = new Set;
+  for (const pattern of include) {
+    for await (const f of new Glob2(pattern).scan({ cwd, absolute: true, onlyFiles: true })) {
+      if (!f.includes("/node_modules/"))
+        found.add(real2(f));
+    }
+  }
+  return [...found].sort();
+}
+var transpilers = new Map;
+function scan(file, text) {
+  const loader = loaderFor(file);
+  let t = transpilers.get(loader);
+  if (!t) {
+    t = new Bun.Transpiler({ loader });
+    transpilers.set(loader, t);
+  }
+  try {
+    return t.scanImports(text).map((i) => i.path);
+  } catch {
+    return [];
+  }
+}
+function resolveImports(file, text) {
+  const out = [];
+  for (const spec of scan(file, text)) {
+    if (spec.startsWith("bun:") || spec.startsWith("node:"))
+      continue;
+    let resolved;
+    try {
+      resolved = real2(Bun.resolveSync(spec, dirname4(file)));
+    } catch {
+      continue;
+    }
+    if (!resolved.includes("/node_modules/") && SOURCE_EXTENSIONS.has(extname(resolved))) {
+      out.push(resolved);
+    }
+  }
+  return out;
+}
+async function buildImportGraph(testFiles) {
+  const imports = new Map;
+  const queue = [...testFiles];
+  for (let file = queue.pop();file !== undefined; file = queue.pop()) {
+    if (imports.has(file))
+      continue;
+    const out = resolveImports(file, await Bun.file(file).text());
+    imports.set(file, out);
+    queue.push(...out.filter((f) => !imports.has(f)));
+  }
+  return { testFiles, imports };
+}
+function importersOf(graph) {
+  const importers = new Map;
+  for (const [from, tos] of graph.imports) {
+    for (const to of tos)
+      importers.set(to, [...importers.get(to) ?? [], from]);
+  }
+  return importers;
+}
+function coveringTests(graph, target) {
+  const importers = importersOf(graph);
+  const wanted = real2(target);
+  const seen = new Set([wanted]);
+  const stack = [wanted];
+  for (let f = stack.pop();f !== undefined; f = stack.pop()) {
+    const fresh = (importers.get(f) ?? []).filter((p) => !seen.has(p));
+    for (const p of fresh)
+      seen.add(p);
+    stack.push(...fresh);
+  }
+  const tests = new Set(graph.testFiles);
+  return [...seen].filter((f) => tests.has(f)).sort();
+}
+function closureOf(graph, files) {
+  const seen = new Set(files);
+  const stack = [...files];
+  for (let f = stack.pop();f !== undefined; f = stack.pop()) {
+    for (const next of graph.imports.get(f) ?? []) {
+      if (!seen.has(next)) {
+        seen.add(next);
+        stack.push(next);
+      }
+    }
+  }
+  return [...seen].sort();
+}
+
+// tools/mutate/src/engine/report-writer.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname5, relative as relative4 } from "node:path";
+var ENGINE_NAME = "polly mutate (bun engine)";
+async function toMutationReport(result, cwd, meta) {
+  const files = {};
+  const testFiles = {};
+  for (const target of result.targets) {
+    const rel = relative4(cwd, target.file);
+    files[rel] = {
+      language: target.file.endsWith(".js") || target.file.endsWith(".jsx") ? "javascript" : "typescript",
+      source: await Bun.file(target.file).text(),
+      mutants: target.results.map((r) => ({
+        id: r.mutant.id,
+        mutatorName: r.mutant.mutatorName,
+        replacement: r.mutant.replacement,
+        status: r.status,
+        ...r.statusReason ? { statusReason: r.statusReason } : {},
+        location: r.mutant.location,
+        killedBy: r.killedBy ?? [],
+        coveredBy: r.coveredBy ?? [],
+        killedByContract: r.killedByContract ?? [],
+        ...r.contractOnly ? { contractOnly: true } : {}
+      }))
+    };
+    for (const t of target.coveringTests)
+      testFiles[relative4(cwd, t)] ??= { tests: [] };
+    for (const t of target.tests) {
+      const rel = relative4(cwd, t.file);
+      testFiles[rel] ??= { tests: [] };
+      const entry = testFiles[rel];
+      if (!entry.tests.some((x) => x.id === t.id)) {
+        entry.tests.push({
+          id: t.id,
+          name: t.name,
+          location: { start: { line: t.line, column: 1 } }
+        });
+      }
+    }
+  }
+  const sites = result.targets.flatMap((t) => t.contracts.map((c) => ({
+    id: `${relative4(cwd, c.file)}:${c.line}`,
+    file: relative4(cwd, c.file),
+    line: c.line,
+    primitive: c.primitive,
+    ...c.message === undefined ? {} : { message: c.message },
+    ...c.handler ? { handler: c.handler } : {}
+  })));
+  return {
+    schemaVersion: "1",
+    thresholds: { high: 80, low: 60 },
+    framework: { name: ENGINE_NAME },
+    files,
+    testFiles,
+    contracts: {
+      mode: meta.contracts,
+      runner: meta.runner,
+      sites,
+      violations: result.contractViolations.map((v) => ({
+        target: relative4(cwd, v.target),
+        test: v.test,
+        contracts: v.contracts
+      }))
+    }
+  };
+}
+async function writeReport(report, path) {
+  mkdirSync3(dirname5(path), { recursive: true });
+  await Bun.write(path, `${JSON.stringify(report, null, 2)}
+`);
+}
+
+// tools/mutate/src/engine/stray-writes.ts
+function git(cwd, args) {
+  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], { stdout: "pipe", stderr: "ignore" });
+  return proc.exitCode === 0 ? proc.stdout.toString() : null;
+}
+function snapshotWorktree(cwd) {
+  const root = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
+  if (!root)
+    return null;
+  const out = git(root, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--ignored=matching"
+  ]);
+  if (out === null)
+    return null;
+  const entries = new Set;
+  const tokens = out.split("\x00");
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token)
+      continue;
+    entries.add(token);
+    if (token[0] === "R" || token[0] === "C")
+      i++;
+  }
+  return { root, entries };
+}
+function newPaths(before, after) {
+  if (!before || !after || before.root !== after.root)
+    return [];
+  const paths = new Set;
+  for (const entry of after.entries)
+    if (!before.entries.has(entry))
+      paths.add(entry.slice(3));
+  return [...paths].sort();
+}
+
+// tools/mutate/src/engine/typecheck.ts
+import { existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname6, join as join8, relative as relative5 } from "node:path";
+var TYPECHECK_OVERRIDES = {
+  allowUnreachableCode: true,
+  noUnusedLocals: false,
+  noUnusedParameters: false
+};
+var TYPECHECK_CONFIG_NAME = "tsconfig.polly-mutate.json";
+var REASON_LIMIT = 300;
+async function loadApi() {
+  try {
+    return await import("typescript-7/unstable/async");
+  } catch {
+    return null;
+  }
+}
+function tsconfigCandidates(file) {
+  const out = [];
+  let dir = dirname6(file);
+  for (;; ) {
+    const candidate = join8(dir, "tsconfig.json");
+    if (existsSync8(candidate))
+      out.push(candidate);
+    const parent = dirname6(dir);
+    if (parent === dir)
+      return out;
+    dir = parent;
+  }
+}
+function virtualConfigFor(tsconfig) {
+  return join8(dirname6(tsconfig), TYPECHECK_CONFIG_NAME);
+}
+var VIRTUAL_CONFIG_TEXT = JSON.stringify({
+  extends: "./tsconfig.json",
+  compilerOptions: TYPECHECK_OVERRIDES
+});
+function errorKeys(api, diagnostics) {
+  return diagnostics.filter((d) => d.category === api.DiagnosticCategory.Error).map((d) => `${d.code}|${d.text}`);
+}
+function reasonOf(key) {
+  const sep = key.indexOf("|");
+  const text = key.slice(sep + 1).replace(/\s+/g, " ");
+  const reason = `TS${key.slice(0, sep)}: ${text}`;
+  return reason.length > REASON_LIMIT ? `${reason.slice(0, REASON_LIMIT - 1)}…` : reason;
+}
+
+class Session {
+  mod;
+  snapshot = null;
+  overlay = new Map;
+  opened = new Map;
+  api;
+  constructor(mod, cwd) {
+    this.mod = mod;
+    this.api = new mod.API({
+      cwd,
+      fs: {
+        readFile: (f) => this.overlay.get(f),
+        fileExists: (f) => this.overlay.has(f) ? true : undefined
+      }
+    });
+  }
+  async update(params) {
+    const next = await this.api.updateSnapshot(params);
+    await this.snapshot?.dispose();
+    this.snapshot = next;
+    return next;
+  }
+  program(config) {
+    const project = this.snapshot?.getProject(config);
+    if (!project)
+      throw new Error(`polly mutate: tsgo lost the project ${config}`);
+    return project.program;
+  }
+  async projectFor(file) {
+    for (const tsconfig of tsconfigCandidates(file)) {
+      let config = this.opened.get(tsconfig);
+      if (config === undefined) {
+        config = virtualConfigFor(tsconfig);
+        this.overlay.set(config, VIRTUAL_CONFIG_TEXT);
+        const snap = await this.update({ openProjects: [config] });
+        if (!snap.getProject(config))
+          config = null;
+        this.opened.set(tsconfig, config);
+      }
+      if (config === null)
+        continue;
+      const project = this.snapshot?.getProject(config);
+      if (project?.rootFiles.some((f) => samePath(f, file)))
+        return config;
+    }
+    return null;
+  }
+  async errorsIn(config, file) {
+    const program = this.program(config);
+    const [syntactic, semantic] = await Promise.all([
+      program.getSyntacticDiagnostics(file),
+      program.getSemanticDiagnostics(file)
+    ]);
+    return [...errorKeys(this.mod, syntactic), ...errorKeys(this.mod, semantic)];
+  }
+  async check(config, target, src) {
+    const invalid = new Map;
+    const baseline = new Set(await this.errorsIn(config, target.file));
+    try {
+      for (const m of target.mutants) {
+        this.overlay.set(target.file, applyMutant(src, m));
+        await this.update({ fileChanges: { changed: [target.file] } });
+        const fresh = (await this.errorsIn(config, target.file)).find((k) => !baseline.has(k));
+        if (fresh !== undefined)
+          invalid.set(m.id, reasonOf(fresh));
+      }
+    } finally {
+      this.overlay.delete(target.file);
+      await this.update({ fileChanges: { changed: [target.file] } });
+    }
+    return invalid;
+  }
+  async close() {
+    await this.api.close();
+  }
+}
+function samePath(a, b) {
+  return a === b || a.toLowerCase() === b.toLowerCase();
+}
+async function typecheckMutants(targets, opts) {
+  const log = opts.log ?? (() => {
+    return;
+  });
+  const started = performance.now();
+  const outcome = { invalid: new Map, skipped: [], checked: 0, wallMs: 0 };
+  const withConfig = targets.filter((t) => {
+    if (tsconfigCandidates(t.file).length > 0)
+      return true;
+    outcome.skipped.push({ file: t.file, reason: "no tsconfig.json above it" });
+    return false;
+  });
+  if (withConfig.length === 0) {
+    for (const s of outcome.skipped)
+      log(`type filter: ${relative5(opts.cwd, s.file)}: ${s.reason}`);
+    outcome.wallMs = Math.round(performance.now() - started);
+    return outcome;
+  }
+  const mod = await loadApi();
+  if (!mod) {
+    log("type filter off: typescript-7 is not installed (bun add typescript-7@npm:typescript@7.0.2)");
+    return null;
+  }
+  const session = new Session(mod, opts.cwd);
+  try {
+    for (const target of withConfig) {
+      const config = await session.projectFor(target.file);
+      if (!config) {
+        outcome.skipped.push({ file: target.file, reason: "no tsconfig.json includes it" });
+        continue;
+      }
+      const src = await Bun.file(target.file).text();
+      const verdicts = await session.check(config, target, src);
+      for (const [id, reason] of verdicts)
+        outcome.invalid.set(id, reason);
+      outcome.checked += target.mutants.length;
+    }
+  } finally {
+    await session.close();
+  }
+  outcome.wallMs = Math.round(performance.now() - started);
+  for (const s of outcome.skipped)
+    log(`type filter: ${relative5(opts.cwd, s.file)}: ${s.reason}`);
+  log(`type filter: ${outcome.invalid.size} of ${outcome.checked} mutants fail to type-check (${(outcome.wallMs / 1000).toFixed(1)} s)`);
+  return outcome;
+}
+
+// tools/mutate/src/engine/index.ts
+function projectFiles(cfg) {
+  return [
+    ...cfg.testPreload,
+    ...["tsconfig.json", "bunfig.toml", "bun.lock"].map((f) => join9(cfg.cwd, f))
+  ];
+}
+async function runEngine(cfg, hooks = {}) {
+  if (cfg.runner.kind === "command" && cfg.mode === "matrix") {
+    throw new Error("matrix mode needs per-test results; the command runner has none");
+  }
+  const workdirs = cfg.scratchCwd ? createWorkdirs(cfg.cwd) : null;
+  try {
+    return await run(cfg, hooks, workdirs);
+  } finally {
+    workdirs?.remove();
+  }
+}
+async function generateAll(cfg, graph) {
+  const out = [];
+  for (const [index, target] of cfg.targets.entries()) {
+    const file = realpathSync4(target.file);
+    const { mutants, compileErrors, contracts } = generateMutants(file, await Bun.file(file).text(), {
+      ignoreVerifyCallsites: cfg.ignoreVerifyCallsites,
+      lines: target.lines,
+      idPrefix: `${index}.`,
+      exclude: cfg.excludeMutators
+    });
+    out.push({
+      file,
+      mutants,
+      compileErrors,
+      covering: graph ? coveringTests(graph, file) : [],
+      contracts
+    });
+  }
+  return out;
+}
+async function dynamicCoverage(cfg, graph, generated, preloads, workdirs, log) {
+  const targets = generated.map((g) => ({
+    file: g.file,
+    mutants: g.mutants.filter((m) => !m.ignoredReason),
+    covering: g.covering
+  }));
+  const key = cfg.cacheDir ? await cacheKey({
+    mutants: targets.flatMap((t) => t.mutants),
+    closure: [...graph.imports.keys()].sort(),
+    projectFiles: projectFiles(cfg),
+    settings: {
+      coverage: COVERAGE_VERSION,
+      targets: targets.map((t) => [t.file, t.mutants.length]),
+      tests: graph.testFiles,
+      contracts: cfg.contracts
+    }
+  }) : null;
+  const cached = cfg.cacheDir && key ? await readCoverageCache(cfg.cacheDir, key) : null;
+  if (cached) {
+    log("coverage pass: from cache");
+    return cached;
+  }
+  const started = performance.now();
+  const coverage = await collectCoverage({
+    cwd: cfg.cwd,
+    testFiles: graph.testFiles,
+    targets,
+    preloads,
+    concurrency: cfg.concurrency,
+    workdirs,
+    contracts: cfg.contracts,
+    log
   });
-  ingest();
-  return db;
+  if (!coverage)
+    return null;
+  log(`coverage pass: ${Object.keys(coverage.tests).length} tests in ` + `${((performance.now() - started) / 1000).toFixed(1)} s`);
+  if (cfg.cacheDir && key)
+    writeCoverageCache(cfg.cacheDir, key, coverage);
+  return coverage;
 }
-function queryAll(db, sql) {
-  return db.query(sql).all();
+function sortedUnique(items) {
+  return [...new Set(items)].sort();
 }
-function queryGet(db, sql) {
-  return db.query(sql).get();
+function dynamicSelection(g, target, coverage) {
+  const selections = new Map;
+  for (const m of g.mutants) {
+    const cov = target.mutants[m.id];
+    if (cov)
+      selections.set(m.id, selectionFor(cov, coverage));
+  }
+  const covering = sortedUnique([...selections.values()].flatMap((sel) => sel.files));
+  const coverageTests = covering.flatMap((f) => (coverage.byFile[f] ?? []).flatMap((id) => {
+    const t = coverage.tests[id];
+    return t ? [{ id: t.id, file: t.file, name: t.name, line: t.line }] : [];
+  }));
+  return { covering, selections, coverageTests };
 }
-async function loadMutationReport(path) {
-  return await Bun.file(path).json();
+function selectionKey(mutants, selections) {
+  if (!selections)
+    return null;
+  return mutants.map((m) => {
+    const sel = selections.get(m.id);
+    return [mutantSig(m), sel?.files ?? [], sel?.namePattern ?? ""];
+  });
 }
-if (false) {}
-
-// tools/mutate/src/decisions.ts
-var DEFAULT_LOG = ".polly/test-debt/decisions.jsonl";
-var VERDICTS = ["keep", "prune", "rewrite", "investigate"];
-function normalizeSource(src) {
-  return src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/[^\n]*/g, "$1").replace(/\s+/g, " ").trim();
+async function withCache(cfg, graph, g, picked) {
+  const { covering, selections } = picked;
+  const settings = {
+    mode: cfg.mode,
+    timeout: cfg.timeout,
+    scratchCwd: cfg.scratchCwd,
+    testPreload: cfg.testPreload,
+    coverage: cfg.coverage,
+    typecheck: cfg.typecheck,
+    contracts: cfg.contracts,
+    selections: selectionKey(g.mutants, selections)
+  };
+  const key = cfg.cacheDir && graph && covering.length > 0 ? await cacheKey({
+    mutants: g.mutants,
+    closure: closureOf(graph, covering),
+    projectFiles: projectFiles(cfg),
+    settings
+  }) : null;
+  return {
+    file: g.file,
+    mutants: g.mutants,
+    compileErrors: g.compileErrors,
+    ...picked,
+    covered: cfg.runner.kind === "command" || covering.length > 0,
+    cacheKey: key,
+    cached: cfg.cacheDir && key ? await readCache(cfg.cacheDir, key) : null,
+    contracts: g.contracts
+  };
 }
-async function fileHash(file) {
-  const f = Bun.file(file);
-  if (!await f.exists())
-    return null;
-  return createHash("sha256").update(normalizeSource(await f.text())).digest("hex").slice(0, 16);
+async function prepare(cfg, preloads, workdirs, log) {
+  const command = cfg.runner.kind === "command";
+  const testFiles = command ? [] : await findTestFiles(cfg.cwd, cfg.testInclude);
+  if (!command && testFiles.length === 0) {
+    throw new Error(`no test files match ${cfg.testInclude.join(", ")} under ${cfg.cwd}`);
+  }
+  const graph = command ? null : await buildImportGraph(testFiles);
+  const generated = await generateAll(cfg, graph);
+  const coverage = graph && cfg.coverage === "dynamic" ? await dynamicCoverage(cfg, graph, generated, preloads, workdirs, log) : null;
+  const prepared = [];
+  for (const [index, g] of generated.entries()) {
+    const target = coverage?.targets[index];
+    if (target?.kind === "static") {
+      log(`${relative6(cfg.cwd, g.file)}: static test selection (${target.reason})`);
+    }
+    const picked = coverage && target?.kind === "dynamic" ? dynamicSelection(g, target, coverage) : { covering: g.covering, selections: null, coverageTests: [] };
+    prepared.push(await withCache(cfg, graph, g, picked));
+  }
+  return { prepared, testFiles: testFiles.length };
 }
-function fileSignals(db) {
-  const rows = queryAll(db, `
-			WITH file_kill AS (SELECT DISTINCT t.file file, k.mutant_id mid FROM kills k JOIN tests t ON t.id=k.test_id),
-			     owner AS (SELECT mid, count(DISTINCT file) nf FROM file_kill GROUP BY mid)
-			SELECT fk.file file, count(DISTINCT fk.mid) kills,
-			       sum(CASE WHEN o.nf=1 THEN 1 ELSE 0 END) unique_kills
-			FROM file_kill fk JOIN owner o ON o.mid=fk.mid GROUP BY fk.file`);
-  const m = new Map;
-  for (const r of rows)
-    m.set(r.file, {
-      kills: r.kills,
-      uniqueKills: r.unique_kills,
-      subsumed: r.kills > 0 && r.unique_kills === 0
-    });
-  return m;
+function collectContractViolations(cfg, baselines, log) {
+  const out = [];
+  for (const [p, baseline] of baselines) {
+    for (const v of baseline?.contractViolations ?? []) {
+      out.push({ target: p.file, test: v.test, contracts: v.contracts });
+      const where = v.contracts.length > 0 ? ` → ${v.contracts.join(", ")}` : "";
+      log(`${relative6(cfg.cwd, p.file)}: test violates contract: ${v.test}${where}`);
+    }
+  }
+  return out;
 }
-async function loadDecisions(logPath) {
-  const m = new Map;
-  const f = Bun.file(logPath);
-  if (!await f.exists())
-    return m;
-  for (const line of (await f.text()).split(`
-`)) {
-    const t = line.trim();
-    if (!t)
-      continue;
-    const d = JSON.parse(t);
-    m.set(d.file, d);
+function selected(p, mutant) {
+  return !p.selections || (p.selections.get(mutant.id)?.files.length ?? 0) > 0;
+}
+async function runMutant(cfg, workdirs, preloads, p, baseline, job) {
+  const matrix = cfg.mode === "matrix";
+  const selection = p.selections?.get(job.mutant.id);
+  const files = selection?.files ?? p.covering;
+  const coveredBy = selection ? { coveredBy: selection.coveredBy } : {};
+  let runCwd = cfg.cwd;
+  const attempt = (namePattern) => inCwd(job.inTree ? null : workdirs, cfg.cwd, (cwd) => {
+    runCwd = cwd;
+    return runBunTest({
+      cwd,
+      files,
+      preloads,
+      contracts: cfg.contracts,
+      env: {
+        POLLY_MUTATE_FILE: job.mutant.file,
+        POLLY_MUTATE_SPAN: JSON.stringify({
+          start: job.mutant.start,
+          end: job.mutant.end,
+          replacement: job.mutant.replacement
+        })
+      },
+      bail: !matrix,
+      junit: matrix || namePattern !== undefined,
+      timeoutMs: job.timeoutMs,
+      ...namePattern ? { namePattern } : {}
+    }, cfg.runner);
+  });
+  let outcome = await attempt(selection?.namePattern);
+  let cases = outcome.junitXml ? parseJunit(outcome.junitXml, runCwd) : [];
+  if (selection?.namePattern && !outcome.timedOut && outcome.exitCode !== 0 && matchedNothing(cases)) {
+    outcome = await attempt(undefined);
+    cases = outcome.junitXml ? parseJunit(outcome.junitXml, runCwd) : [];
   }
-  return m;
+  const durationMs = Math.round(outcome.ms);
+  const result = { mutant: job.mutant, durationMs, ...coveredBy };
+  if (outcome.timedOut)
+    return { ...result, status: "Timeout" };
+  if (outcome.exitCode === 0)
+    return { ...result, status: "Survived" };
+  if (!matrix)
+    return { ...result, status: "Killed" };
+  const ran = new Set(files);
+  const reported = new Set([...baseline.reportedFiles].filter((f) => ran.has(f)));
+  const killedBy = killers(cases, reported, cfg.cwd);
+  return { ...result, status: "Killed", killedBy, ...contractAttribution(cfg, cases, killedBy) };
 }
-function staleReason(d, currentHash, current) {
-  if (!current)
-    return "file no longer kills any mutant (renamed/deleted/refactored?)";
-  if (d.hash !== currentHash)
-    return "test file changed since the decision";
-  if (d.signal.subsumed !== current.subsumed)
-    return `subsumption flipped (${d.signal.subsumed} → ${current.subsumed})`;
-  if (d.signal.uniqueKills > 0 !== current.uniqueKills > 0)
-    return `unique-kill status changed (${d.signal.uniqueKills} → ${current.uniqueKills})`;
-  return null;
+function contractAttribution(cfg, cases, killedBy) {
+  if (cfg.contracts === "off")
+    return {};
+  const kills = contractKills(cases, cfg.cwd);
+  if (kills.length === 0)
+    return {};
+  const killedByContract = sortedUnique(kills.flatMap((k) => k.contracts));
+  const failed = cases.filter((c) => c.status === "failed").length;
+  const contractOnly = kills.length === failed && killedBy.length === failed;
+  return { killedByContract, ...contractOnly ? { contractOnly: true } : {} };
 }
-async function status(db, logPath = DEFAULT_LOG) {
-  const signals = fileSignals(db);
-  const decisions = await loadDecisions(logPath);
-  const needsReview = [];
-  const stale = [];
-  const settled = [];
-  for (const [file, sig] of [...signals].sort((a, b) => b[1].kills - a[1].kills)) {
-    const d = decisions.get(file);
-    if (!d) {
-      if (sig.subsumed)
-        needsReview.push(`  ${file}  (${sig.kills} kills, 0 unique)`);
-      continue;
+function matchedNothing(cases) {
+  return cases.length > 0 && cases.every((c) => c.status === "skipped");
+}
+function fromCache(p, entry) {
+  const bySig = new Map(entry.results.map((r) => [r.sig, r]));
+  const results = [...p.mutants, ...p.compileErrors].map((mutant) => {
+    const hit = bySig.get(mutantSig(mutant));
+    if (!hit)
+      return { mutant, status: "RuntimeError", statusReason: "missing from the cache entry" };
+    const { sig: _sig, ...rest } = hit;
+    return { mutant, ...rest };
+  });
+  results.sort((a, b) => a.mutant.start - b.mutant.start);
+  return {
+    file: p.file,
+    coveringTests: p.covering,
+    baselineMs: entry.baselineMs,
+    inTree: entry.inTree,
+    cached: true,
+    tests: entry.tests,
+    results,
+    contracts: p.contracts
+  };
+}
+function testsFor(cfg, p, baseline, results) {
+  const tests = [...baseline.tests];
+  const known = new Set(tests.map((t) => t.id));
+  for (const t of p.coverageTests) {
+    if (!known.has(t.id)) {
+      known.add(t.id);
+      tests.push(t);
     }
-    const reason = staleReason(d, await fileHash(file), sig);
-    if (reason)
-      stale.push(`  ${file}  [${d.verdict}] — ${reason}`);
-    else
-      settled.push(`  ${file}  [${d.verdict}] ${d.rationale ? `— ${d.rationale}` : ""}`);
   }
-  for (const [file, d] of decisions) {
-    if (!signals.has(file))
-      stale.push(`  ${file}  [${d.verdict}] — file no longer in matrix`);
+  const used = new Set(results.flatMap((r) => r.killedBy ?? []));
+  for (const file of p.covering) {
+    const id = loadFailureId(cfg.cwd, file);
+    if (used.has(id) && !known.has(id))
+      tests.push({ id, file, name: LOAD_FAILURE_NAME, line: 0 });
   }
-  const out = [];
-  out.push(`NEEDS REVIEW  (subsumed files with no decision — ${needsReview.length})`);
-  out.push(needsReview.length ? needsReview.join(`
-`) : "  none");
-  out.push(`
-STALE  (decision's basis drifted — re-review — ${stale.length})`);
-  out.push(stale.length ? stale.join(`
-`) : "  none");
-  out.push(`
-SETTLED  (fresh decisions, suppressed from action list — ${settled.length})`);
-  out.push(settled.length ? settled.join(`
-`) : "  none");
-  return out.join(`
-`);
+  return tests;
 }
-async function decide(file, verdict, rationale, db, logPath = DEFAULT_LOG) {
-  if (!VERDICTS.includes(verdict)) {
-    console.log(`✗ verdict must be one of: ${VERDICTS.join(", ")}`);
-    process.exit(1);
+function unrun(mutant, statusReason) {
+  return { mutant, status: "RuntimeError", statusReason };
+}
+function notRun(p, baseline, mutant) {
+  if (!p.covered) {
+    const reason = p.selections ? "no test ran this target" : "no test file imports this target";
+    return { mutant, status: "NoCoverage", statusReason: reason };
   }
-  const sig = fileSignals(db).get(file);
-  if (!sig) {
-    console.log(`✗ ${file} is not a test file that kills any mutant in the current matrix`);
-    process.exit(1);
+  if (baseline?.contractViolations)
+    return unrun(mutant, baseline.reason);
+  if (!selected(p, mutant)) {
+    return { mutant, status: "NoCoverage", statusReason: "no test ran this code", coveredBy: [] };
   }
-  const decided = new Date().toISOString().slice(0, 10);
-  const record = {
-    file,
-    verdict,
-    rationale,
-    signal: sig,
-    hash: await fileHash(file),
-    decided
+  if (!baseline?.ok)
+    return unrun(mutant, baseline?.reason);
+  return null;
+}
+function summarise(cfg, p, baseline, byId, invalid, workdirs) {
+  const results = p.mutants.map((mutant) => {
+    if (mutant.ignoredReason)
+      return { mutant, status: "Ignored", statusReason: mutant.ignoredReason };
+    const typeError = invalid.get(mutant.id);
+    if (typeError)
+      return { mutant, status: "CompileError", statusReason: typeError };
+    return notRun(p, baseline, mutant) ?? byId.get(mutant.id) ?? unrun(mutant, "mutant was not run");
+  });
+  for (const mutant of p.compileErrors) {
+    results.push({ mutant, status: "CompileError", statusReason: "mutated source does not parse" });
+  }
+  results.sort((a, b) => a.mutant.start - b.mutant.start);
+  return {
+    file: p.file,
+    coveringTests: p.covering,
+    baselineMs: baseline?.ok ? Math.round(baseline.ms) : null,
+    inTree: baseline?.inTree ?? !workdirs,
+    cached: false,
+    tests: baseline?.ok ? testsFor(cfg, p, baseline, results) : p.coverageTests,
+    results,
+    contracts: p.contracts
   };
-  await Bun.write(logPath, (await Bun.file(logPath).exists() ? await Bun.file(logPath).text() : "") + JSON.stringify(record) + `
-`);
-  console.log(`✓ recorded: ${file} [${verdict}]${rationale ? ` — ${rationale}` : ""}`);
 }
-if (false) {}
+async function run(cfg, hooks, workdirs) {
+  const log = hooks.log ?? (() => {
+    return;
+  });
+  const started = performance.now();
+  const preloads = [...cfg.testPreload, preloadPath()];
+  const beforeRun = snapshotWorktree(cfg.cwd);
+  const { prepared, testFiles } = await prepare(cfg, preloads, workdirs, log);
+  const totalMutants = prepared.reduce((n, p) => n + p.mutants.length, 0);
+  const hits = prepared.filter((p) => p.cached).length;
+  log(`${prepared.length} target(s), ${totalMutants} mutants, ` + (cfg.runner.kind === "command" ? `command \`${cfg.runner.argv.join(" ")}\`` : `${testFiles} test files in scope`) + `, ${cfg.mode} mode` + (cfg.runner.kind === "bun-test" ? `, ${cfg.coverage} coverage` : "") + (cfg.cacheDir ? `, ${hits} target(s) from cache` : ""));
+  const fresh = prepared.filter((p) => !p.cached && p.covered);
+  const [measured, typed] = await Promise.all([
+    pool(fresh, cfg.concurrency, (p) => measureBaseline(cfg, workdirs, preloads, p, log)),
+    cfg.typecheck ? typecheckMutants(prepared.filter((p) => !p.cached).map((p) => ({ file: p.file, mutants: p.mutants.filter((m) => !m.ignoredReason) })), { cwd: cfg.cwd, log }) : null
+  ]);
+  const invalid = typed?.invalid ?? new Map;
+  const baselines = new Map(fresh.map((p, i) => [p, measured[i] ?? null]));
+  const afterBaselines = snapshotWorktree(cfg.cwd);
+  const contractViolations = collectContractViolations(cfg, baselines, log);
+  const jobs = [];
+  prepared.forEach((p, target) => {
+    const baseline = baselines.get(p);
+    if (!baseline?.ok)
+      return;
+    const timeoutMs = Math.round(baseline.ms * cfg.timeout.factor + cfg.timeout.extraMs);
+    for (const mutant of p.mutants) {
+      if (!mutant.ignoredReason && !invalid.has(mutant.id) && selected(p, mutant))
+        jobs.push({ target, mutant, timeoutMs, inTree: baseline.inTree });
+    }
+  });
+  jobs.sort((a, b) => b.timeoutMs - a.timeoutMs);
+  let done = 0;
+  const runResults = await pool(jobs, cfg.concurrency, async (job) => {
+    const p = prepared[job.target];
+    const baseline = p && baselines.get(p);
+    if (!p || !baseline)
+      throw new Error(`job for target ${job.target} has no baseline`);
+    const result = await runMutant(cfg, workdirs, preloads, p, baseline, job);
+    done++;
+    hooks.progress?.(done, jobs.length);
+    return result;
+  });
+  const byId = new Map(runResults.map((r) => [r.mutant.id, r]));
+  const targets = prepared.map((p) => p.cached ? fromCache(p, p.cached) : summarise(cfg, p, baselines.get(p) ?? null, byId, invalid, workdirs));
+  const afterMutants = snapshotWorktree(cfg.cwd);
+  const strayWrites = beforeRun ? {
+    root: beforeRun.root,
+    baseline: newPaths(beforeRun, afterBaselines),
+    mutants: newPaths(afterBaselines, afterMutants)
+  } : null;
+  for (const path of strayWrites?.mutants ?? [])
+    log(`warning: a mutant run wrote ${path}`);
+  if (cfg.cacheDir) {
+    targets.forEach((t, i) => {
+      const p = prepared[i];
+      if (!cfg.cacheDir || !p?.cacheKey || t.cached || t.baselineMs === null)
+        return;
+      writeCache(cfg.cacheDir, p.cacheKey, {
+        baselineMs: t.baselineMs,
+        inTree: t.inTree,
+        tests: t.tests,
+        results: t.results.map(cachedResult)
+      });
+    });
+  }
+  const result = {
+    targets,
+    wallMs: Math.round(performance.now() - started),
+    strayWrites,
+    contractViolations
+  };
+  await writeReport(await toMutationReport(result, cfg.cwd, { contracts: cfg.contracts, runner: cfg.runner.kind }), cfg.reportPath);
+  return result;
+}
+function mutationScore(results) {
+  let detected = 0;
+  let valid = 0;
+  for (const r of results) {
+    if (r.status === "Killed" || r.status === "Timeout")
+      detected++;
+    if (r.status === "Killed" || r.status === "Timeout" || r.status === "Survived" || r.status === "NoCoverage")
+      valid++;
+  }
+  return valid === 0 ? null : 100 * detected / valid;
+}
 
-// tools/mutate/src/init.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join2, relative } from "node:path";
-function resolvePluginRef(projectDir) {
-  const resolved = Bun.resolveSync("@fairfox/polly/stryker", projectDir);
-  const hoisted = resolved.includes("/node_modules/") && !resolved.includes("/.bun/");
-  return hoisted ? "@fairfox/polly/stryker" : relative(projectDir, resolved);
+// tools/mutate/src/engine-config.ts
+import { availableParallelism } from "node:os";
+import { dirname as dirname7, join as join10, resolve as resolve4 } from "node:path";
+import { Glob as Glob3 } from "bun";
+var RANGE = /^(.*?):(\d+)(?::\d+)?-(\d+)(?::\d+)?$/;
+async function scanGlob(cwd, pattern) {
+  const out = [];
+  for await (const f of new Glob3(pattern).scan({ cwd, absolute: true, onlyFiles: true })) {
+    if (!f.includes("/node_modules/"))
+      out.push(f);
+  }
+  return out;
 }
-function detectMutate(projectDir) {
-  if (existsSync2(join2(projectDir, "src"))) {
-    return ["src/**/*.ts", "!src/**/*.test.ts", "!src/**/*.d.ts"];
+function parseEntry(entry) {
+  const range = RANGE.exec(entry);
+  if (!range?.[1])
+    return { pattern: entry };
+  return { pattern: range[1], lines: { from: Number(range[2]), to: Number(range[3]) } };
+}
+async function expandMutateEntries(cwd, entries) {
+  const negated = entries.filter((x) => x.startsWith("!"));
+  const excluded = new Set((await Promise.all(negated.map((e) => scanGlob(cwd, e.slice(1))))).flat());
+  const targets = new Map;
+  for (const entry of entries.filter((x) => !x.startsWith("!"))) {
+    const { pattern, lines } = parseEntry(entry);
+    const files = (await scanGlob(cwd, pattern)).filter((f) => !excluded.has(f));
+    for (const f of files)
+      targets.set(f, lines ? { file: f, lines } : { file: f });
   }
-  return ["**/*.ts", "!**/*.test.ts", "!**/*.d.ts", "!node_modules/**", "!dist/**"];
+  return [...targets.values()].sort((a, b) => a.file.localeCompare(b.file));
 }
-function detectTestGlob(projectDir) {
-  for (const d of ["tests", "test"]) {
-    if (existsSync2(join2(projectDir, d)))
-      return `${d}/**/*.test.ts`;
+async function changedSince(cwd, ref) {
+  const proc = Bun.spawn(["git", "diff", "--name-only", "--relative", ref], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+  if (code !== 0)
+    throw new Error(`git diff --name-only ${ref} failed: ${await new Response(proc.stderr).text()}`);
+  return new Set(out.split(`
+`).filter(Boolean).map((p) => resolve4(cwd, p)));
+}
+async function selectTargets(dir, config, args) {
+  const entries = args.files ? args.files.split(",").map((s) => s.trim()).filter(Boolean) : config.targets;
+  const targets = await expandMutateEntries(dir, entries);
+  if (!args.since)
+    return targets;
+  const changed = await changedSince(dir, args.since);
+  return targets.filter((t) => changed.has(t.file));
+}
+function resolveConcurrency(flag, fromConfig) {
+  if (flag === undefined)
+    return fromConfig ?? Math.max(1, availableParallelism() - 1);
+  const n = Number(flag);
+  if (!(Number.isInteger(n) && n > 0)) {
+    throw new Error(`--concurrency must be a positive integer, got "${flag}"`);
   }
-  return "**/*.test.ts";
+  return n;
 }
-async function initConfig(projectDir, opts = {}) {
-  const configPath = join2(projectDir, "stryker.conf.json");
-  const warnings = [];
-  let pluginRef;
-  try {
-    pluginRef = resolvePluginRef(projectDir);
-  } catch {
-    throw new Error("Cannot resolve @fairfox/polly from here. Run `polly mutate init` in a project that depends on @fairfox/polly.");
+function resolveMode(flag, config) {
+  const mode = flag ?? config.mode ?? "fast";
+  if (mode !== "fast" && mode !== "matrix") {
+    throw new Error(`--mode ${mode}: expected fast or matrix`);
   }
-  const mutate = detectMutate(projectDir);
-  const testGlob = detectTestGlob(projectDir);
-  if (!existsSync2(join2(projectDir, "src"))) {
-    warnings.push("no src/ directory — adjust the `mutate` globs to point at your source");
-  }
-  if (!existsSync2(join2(projectDir, "tests")) && !existsSync2(join2(projectDir, "test"))) {
-    warnings.push(`no tests/ directory — using "${testGlob}"; adjust bun.testFiles if needed`);
-  }
-  if (existsSync2(configPath) && !opts.force) {
-    return { configPath, created: false, pluginRef, mutate, testGlob, warnings };
-  }
-  const config = {
-    testRunner: "bun",
-    bun: { testFiles: [testGlob], timeout: 30000 },
-    plugins: ["stryker-mutator-bun-runner", pluginRef],
-    ignorers: ["polly-verify"],
-    coverageAnalysis: "all",
-    disableBail: true,
-    reporters: ["json", "clear-text"],
-    mutate,
-    thresholds: { high: 90, low: 70, break: null },
-    ignorePatterns: [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/.git/**",
-      "**/.stryker-tmp/**",
-      "**/reports/**"
-    ],
-    timeoutMS: 60000,
-    concurrency: 4
+  if (mode === "matrix" && config.runner?.kind === "command") {
+    throw new Error("matrix mode needs per-test results; the command runner has none (use fast)");
+  }
+  return mode;
+}
+function resolveCoverage(flag, config) {
+  const coverage = flag ?? config.coverage ?? "dynamic";
+  if (coverage !== "dynamic" && coverage !== "static") {
+    throw new Error(`--coverage ${coverage}: expected dynamic or static`);
+  }
+  return coverage;
+}
+function resolveContracts(flag, config) {
+  const contracts = flag ?? config.contracts ?? "all";
+  if (!isContractsMode(contracts)) {
+    throw new Error(`--contracts ${contracts}: expected off, ensures or all`);
+  }
+  return contracts;
+}
+async function engineConfigFor(cfg, args) {
+  if (!cfg.mutation) {
+    throw new Error(cfg.mutationError ?? `no ${MUTATION_CONFIG_FILE} found — run 'polly mutate init', or pass --config <path>`);
+  }
+  const { config, path } = cfg.mutation;
+  const dir = dirname7(path);
+  const mode = resolveMode(args.mode, config);
+  const command = config.runner?.kind === "command" ? config.runner : null;
+  return {
+    cwd: dir,
+    targets: await selectTargets(dir, config, args),
+    runner: command ?? { kind: "bun-test" },
+    testInclude: config.tests?.include ?? [],
+    testPreload: (config.tests?.preload ?? []).map((p) => resolve4(dir, p)),
+    mode,
+    coverage: command ? "static" : resolveCoverage(args.coverage, config),
+    concurrency: resolveConcurrency(args.concurrency, config.concurrency),
+    timeout: config.timeout ?? { factor: 2, extraMs: 3000 },
+    typecheck: !args.noTypecheck && (config.typecheck ?? true),
+    excludeMutators: config.mutators?.exclude ?? [],
+    ignoreVerifyCallsites: config.ignoreVerifyCallsites ?? true,
+    contracts: resolveContracts(args.contracts, config),
+    scratchCwd: !(args.inTree || command),
+    cacheDir: args.noCache ? null : join10(dir, ".polly", "mutate", "cache"),
+    reportPath: cfg.reportPath
   };
-  await Bun.write(configPath, `${JSON.stringify(config, null, 2)}
-`);
-  return { configPath, created: true, pluginRef, mutate, testGlob, warnings };
 }
 
-// tools/mutate/src/run.ts
-import { resolve as resolve3 } from "node:path";
-
 // tools/mutate/src/report.ts
+function contractsSection(db, p) {
+  const meta = new Map(queryAll(db, "SELECT key, value FROM report_meta").map((r) => [
+    r.key,
+    r.value
+  ]));
+  const mode = meta.get("contracts_mode");
+  if (mode === undefined)
+    return;
+  const nSites = queryGet(db, "SELECT count(*) n FROM contract_sites")?.n ?? 0;
+  p(`
+CONTRACTS  (requires/ensures as kill oracles — mode ${mode}, ${nSites} site(s))`);
+  if (mode === "off") {
+    p(`  off — the sites are inventoried only; 'polly mutate run --contracts all' makes each one fail the test that falsifies it`);
+    return;
+  }
+  const violations = queryAll(db, "SELECT target, test, contract_id FROM contract_violations ORDER BY target, test, contract_id");
+  if (violations.length > 0) {
+    p(`  TEST VIOLATES CONTRACT  (the unmutated code fails a contract under a test: ${violations.length})`);
+    for (const v of violations) {
+      p(`    ${v.target}: ${v.test}${v.contract_id ? ` → ${v.contract_id}` : ""}`);
+    }
+  }
+  if (meta.get("runner") === "command") {
+    p(`  command runner: no per-test results, so kills are not attributed to contracts; compare the killed count against a --contracts off run`);
+    return;
+  }
+  if (mode === "ensures")
+    p(`  requires sites are inventoried, not enforced (mode ensures)`);
+  const only = queryAll(db, "SELECT file, line, mutator, count(*) n FROM mutants WHERE contract_only=1 GROUP BY file, line, mutator ORDER BY file, line");
+  const onlyTotal = only.reduce((a, r) => a + r.n, 0);
+  p(`  CONTRACT-ONLY KILLS  (no test assertion caught these; a contract did: ${onlyTotal})`);
+  for (const r of only)
+    p(`    ${r.file}:${r.line}  ${r.mutator}${r.n > 1 ? ` ×${r.n}` : ""}`);
+  if (nSites === 0)
+    return;
+  const sites = queryAll(db, `SELECT s.id, s.primitive, s.message,
+            (SELECT count(*) FROM contract_kills k WHERE k.contract_id = s.id) n,
+            (SELECT count(*) FROM mutants m
+              WHERE m.file = s.file AND s.handler_from IS NOT NULL
+                AND m.line BETWEEN s.handler_from AND s.handler_to
+                AND m.status IN ('Killed', 'Survived', 'Timeout')) exercised
+     FROM contract_sites s ORDER BY n DESC, s.id`);
+  p(`  KILLS PER CONTRACT`);
+  for (const s of sites) {
+    p(`    ${s.id}  ${s.primitive}  ${s.n} kill(s)${s.message ? `  “${s.message}”` : ""}`);
+  }
+  const toothless = sites.filter((s) => s.n === 0 && s.exercised > 0);
+  const idle = sites.filter((s) => s.n === 0 && s.exercised === 0);
+  p(`  CONTRACTS WITHOUT TEETH  (the handler's mutants ran, the contract never fired: ${toothless.length})`);
+  if (toothless.length === 0)
+    p(`    none`);
+  for (const s of toothless)
+    p(`    ${s.id}  ${s.primitive}${s.message ? `  “${s.message}”` : ""}`);
+  if (idle.length > 0) {
+    p(`  HANDLER NOT EXERCISED  (no mutant in the contract's handler ran: ${idle.length})`);
+    for (const s of idle)
+      p(`    ${s.id}  ${s.primitive}`);
+  }
+}
 function greedyCover(units, universe) {
   const remaining = new Set(universe);
   const chosen = [];
@@ -404,11 +3209,16 @@ function report(db, opts = {}) {
   const matrixComplete = opts.matrixComplete ?? true;
   const out = [];
   const p = (s = "") => out.push(s);
-  const tot = queryGet(db, "SELECT count(*) n, sum(status='Killed') killed, sum(status='Survived') survived, sum(status='Timeout') timeout, sum(status='NoCoverage') nocov FROM mutants") ?? { n: 0, killed: 0, survived: 0, timeout: 0, nocov: 0 };
+  const tot = queryGet(db, "SELECT count(*) n, sum(status='Killed') killed, sum(status='Survived') survived, sum(status='Timeout') timeout, sum(status='NoCoverage') nocov, sum(status='CompileError') invalid, sum(status='Ignored') ignored FROM mutants") ?? { n: 0, killed: 0, survived: 0, timeout: 0, nocov: 0, invalid: 0, ignored: 0 };
   const nTests = queryGet(db, "SELECT count(*) n FROM tests")?.n ?? 0;
   const detected = tot.killed + tot.timeout;
-  const score = (detected / (tot.n - tot.nocov || 1) * 100).toFixed(1);
-  p(`MUTATION  score ${score}%   ${tot.killed} killed · ${tot.timeout} timeout · ${tot.survived} survived · ${tot.nocov} no-coverage   (${tot.n} mutants, ${nTests} tests)`);
+  const valid = detected + tot.survived + tot.nocov;
+  const score = valid === 0 ? "n/a" : `${(detected / valid * 100).toFixed(1)}%`;
+  const excluded = [
+    tot.invalid > 0 ? `${tot.invalid} invalid` : "",
+    tot.ignored > 0 ? `${tot.ignored} ignored` : ""
+  ].filter(Boolean).map((s) => ` · ${s}`).join("");
+  p(`MUTATION  score ${score}   ${tot.killed} killed · ${tot.timeout} timeout · ${tot.survived} survived · ${tot.nocov} no-coverage${excluded}   (${tot.n} mutants, ${nTests} tests)`);
   if (matrixComplete) {
     const mult = queryAll(db, `
 			SELECT CASE WHEN c=1 THEN '1' WHEN c=2 THEN '2' WHEN c BETWEEN 3 AND 5 THEN '3-5' ELSE '6+' END bucket, count(*) n
@@ -473,26 +3283,28 @@ SUBSUMED CASES  (${subsumedCases.length} individual tests whose every kill is ca
     p(`
 ⚠ KILL MATRIX INCOMPLETE — redundancy/subsumption analysis suppressed.`);
     p(`  Every mutant has at most one recorded killer, so "which tests are redundant"`);
-    p(`  cannot be derived. This needs the no-bail patched Bun runner (not shipped with`);
-    p(`  @fairfox/polly). Run 'polly mutate verify' to diagnose. Score/gaps/theatre below still hold.`);
+    p(`  cannot be derived. Run 'polly mutate run --mode matrix' (every`);
+    p(`  killer recorded), or 'polly mutate verify' to diagnose. Score/gaps/theatre below still hold.`);
   }
-  const srcFile = queryGet(db, "SELECT file FROM mutants LIMIT 1")?.file;
-  const gaps = queryAll(db, "SELECT line, mutator, count(*) n FROM mutants WHERE status='NoCoverage' GROUP BY line, mutator ORDER BY line");
+  const byLine = (status) => queryAll(db, `SELECT file, line, mutator, count(*) n FROM mutants WHERE status='${status}' GROUP BY file, line, mutator ORDER BY file, line`);
+  const lineOf = (r) => `  ${r.file}:${r.line}  ${r.mutator}${r.n > 1 ? ` ×${r.n}` : ""}`;
+  const gaps = byLine("NoCoverage");
   const gapTotal = gaps.reduce((a, r) => a + r.n, 0);
   p(`
 GAPS  (NoCoverage — no test executes this code: ${gapTotal})`);
   if (gapTotal === 0)
     p(`  none — every mutable location is reached by some test`);
   for (const r of gaps)
-    p(`  ${srcFile}:${r.line}  ${r.mutator}${r.n > 1 ? ` ×${r.n}` : ""}`);
-  const theatre = queryAll(db, "SELECT line, mutator, count(*) n FROM mutants WHERE status='Survived' GROUP BY line, mutator ORDER BY line");
+    p(lineOf(r));
+  const theatre = byLine("Survived");
   const theatreTotal = theatre.reduce((a, r) => a + r.n, 0);
   p(`
 THEATRE  (Survived — code is covered but no test detects the mutation: ${theatreTotal})`);
   if (theatreTotal === 0)
     p(`  none`);
   for (const r of theatre)
-    p(`  ${srcFile}:${r.line}  ${r.mutator}${r.n > 1 ? ` ×${r.n}` : ""}`);
+    p(lineOf(r));
+  contractsSection(db, p);
   return out.join(`
 `);
 }
@@ -512,20 +3324,6 @@ function isMatrixComplete(report) {
 }
 async function verifyMatrix(opts = {}) {
   const reportPath = opts.reportPath ?? DEFAULT_REPORT2;
-  if (opts.run) {
-    console.log("Running mutation pass (this can take many minutes for a large mutate set)...");
-    const cmd = [
-      "bunx",
-      "stryker",
-      "run",
-      ...opts.strykerConfig ? ["--configFile", opts.strykerConfig] : []
-    ];
-    const proc = Bun.spawn(cmd, { stdout: "inherit", stderr: "inherit" });
-    const code = await proc.exited;
-    if (code !== 0) {
-      return { ok: false, checks: [{ name: "stryker run", ok: false, detail: `exited ${code}` }] };
-    }
-  }
   if (!await Bun.file(reportPath).exists()) {
     return {
       ok: false,
@@ -533,7 +3331,7 @@ async function verifyMatrix(opts = {}) {
         {
           name: "report exists",
           ok: false,
-          detail: `no report at ${reportPath}. Run with --run, or 'bun run mutation' first.`
+          detail: `no report at ${reportPath}. Run 'polly mutate verify --run' first.`
         }
       ]
     };
@@ -558,24 +3356,118 @@ async function verifyMatrix(opts = {}) {
   add("coverage collected (not all NoCoverage)", noCov < mutants.length, `${noCov}/${mutants.length} NoCoverage — all-NoCoverage means the coverage dump broke`);
   return { ok: checks.every((c) => c.ok), checks };
 }
-if (false) {}
 
 // tools/mutate/src/run.ts
-async function runStryker(cfg) {
-  const autoDiscoverable = cfg.strykerConfigPath === resolve3(cfg.cwd, "stryker.conf.json");
-  const configFlag = cfg.strykerConfigPath && !autoDiscoverable ? ["--configFile", cfg.strykerConfigPath] : [];
-  const proc = Bun.spawn(["bunx", "stryker", "run", ...configFlag], {
-    cwd: cfg.cwd,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit",
-    env: process.env
+function resolveEngine(args) {
+  const engine = args.engine ?? "bun";
+  if (engine === "bun")
+    return engine;
+  if (engine === "stryker") {
+    throw new Error("--engine stryker was removed; the bun engine (the default) replaces it");
+  }
+  throw new Error(`unknown --engine "${engine}" (expected bun)`);
+}
+function deprecationNotice(cfg) {
+  const m = cfg.mutation;
+  if (m?.format !== "stryker")
+    return null;
+  return [
+    `deprecated: reading ${relative7(cfg.cwd, m.path) || m.path} — Stryker is no longer supported; its config is read for migration only.`,
+    "  'polly mutate migrate --write' writes the equivalent polly.mutate.ts.",
+    ...m.notes.map((n) => `  ${n}`)
+  ].join(`
+`);
+}
+function thresholdFailure(score, cfg) {
+  const floor = cfg.mutation?.config.thresholds?.break;
+  if (floor === undefined || score === null || score >= floor)
+    return null;
+  return `mutation score ${score.toFixed(1)}% is below thresholds.break ${floor}%`;
+}
+async function runBunEngine(cfg, args) {
+  const notice = deprecationNotice(cfg);
+  if (notice)
+    console.log(`${notice}
+`);
+  const engineCfg = await engineConfigFor(cfg, args);
+  if (engineCfg.targets.length === 0) {
+    console.log(args.since ? `no mutate targets changed since ${args.since}` : "no mutate targets matched");
+    return 0;
+  }
+  let lastPct = -1;
+  const result = await runEngine(engineCfg, {
+    log: (line) => console.log(line),
+    progress: (done, total) => {
+      const pct = Math.floor(100 * done / total);
+      if (pct >= lastPct + 10 || done === total) {
+        lastPct = pct;
+        console.log(`  ${done}/${total} mutants`);
+      }
+    }
   });
-  return await proc.exited;
+  console.log(`
+file | tests | killed | survived | timeout | no-cov | invalid | other | score`);
+  const all = result.targets.flatMap((t) => t.results);
+  for (const t of result.targets) {
+    const count = (s) => t.results.filter((r) => r.status === s).length;
+    const other = t.results.length - count("Killed") - count("Survived") - count("Timeout") - count("NoCoverage") - count("CompileError");
+    const score = mutationScore(t.results);
+    console.log([
+      relative7(engineCfg.cwd, t.file),
+      t.coveringTests.length,
+      count("Killed"),
+      count("Survived"),
+      count("Timeout"),
+      count("NoCoverage"),
+      count("CompileError"),
+      other,
+      score === null ? "n/a" : `${score.toFixed(1)}%`
+    ].join(" | "));
+  }
+  const total = mutationScore(all);
+  console.log(`
+${all.length} mutants in ${(result.wallMs / 1000).toFixed(1)} s · score ${total === null ? "n/a" : `${total.toFixed(1)}%`} · report ${cfg.reportPath}`);
+  const stray = result.strayWrites;
+  if (stray && stray.mutants.length > 0) {
+    console.log(`
+warning: mutant runs wrote ${stray.mutants.length} path(s) into ${stray.root} (not deleted — check, then remove):`);
+    for (const path of stray.mutants)
+      console.log(`  ${path}`);
+  }
+  if (result.contractViolations.length > 0) {
+    console.log(contractViolationsBlock(result, engineCfg.cwd));
+    return 1;
+  }
+  const failure = thresholdFailure(total, cfg);
+  if (failure) {
+    console.log(`
+✗ ${failure}`);
+    return 1;
+  }
+  return 0;
+}
+function contractViolationsBlock(result, cwd) {
+  const sites = new Map(result.targets.flatMap((t) => t.contracts.map((c) => [`${relative7(cwd, c.file)}:${c.line}`, c])));
+  const lines = [
+    `
+✗ TEST VIOLATES CONTRACT  (${result.contractViolations.length}; the mutants of these targets did not run)`
+  ];
+  for (const v of result.contractViolations) {
+    const where = v.contracts.length === 0 ? "" : ` → ${v.contracts.join(", ")}`;
+    lines.push(`  ${relative7(cwd, v.target)}: ${v.test}${where}`);
+    for (const id of v.contracts) {
+      const site = sites.get(id);
+      if (site)
+        lines.push(`      ${site.primitive}${site.message ? ` “${site.message}”` : ""}`);
+    }
+  }
+  lines.push("  A test drives a handler outside its declared precondition, or a handler breaks its own", "  postcondition. Fix the test or the contract; '--contracts ensures' leaves requires inert,", "  '--contracts off' restores the no-op primitives.");
+  return lines.join(`
+`);
 }
 async function reportFromFile(cfg) {
   if (!await Bun.file(cfg.reportPath).exists()) {
-    throw new Error(`no mutation report at ${cfg.reportPath}. Run 'polly mutate run' (or 'bun run mutation') first, or pass --report <path>.`);
+    throw new Error(`no mutation report at ${cfg.reportPath}. Run 'polly mutate run' first, or pass --report <path>.`);
   }
   const mreport = await loadMutationReport(cfg.reportPath);
   const db = buildDb(mreport, cfg.dbPath);
@@ -585,18 +3477,6 @@ async function reportFromFile(cfg) {
     db.close();
   }
 }
-async function presetAdvisory(cfg) {
-  if (!cfg.strykerConfigPath?.endsWith(".json"))
-    return null;
-  try {
-    const conf = await Bun.file(cfg.strykerConfigPath).json();
-    if ((conf.plugins ?? []).includes("@fairfox/polly/stryker"))
-      return null;
-    return "Tip: spread pollyStrykerPreset (from @fairfox/polly/stryker) into your Stryker config — " + "verify primitives (requires/ensures/…) are runtime no-ops and their mutants always survive, " + "dragging the score down with noise. See polly#143.";
-  } catch {
-    return null;
-  }
-}
 
 // tools/mutate/src/cli.ts
 var HELP = `polly mutate — mutation testing + useless-test detection
@@ -609,8 +3489,10 @@ theatre (code a test ran but never actually checked). How the matrix is built:
 tools/mutate/README.md.
 
 Usage:
-  polly mutate init [--force]        Scaffold a stryker.conf.json for this project
-  polly mutate [run]                 Run Stryker, then print the useless-test report
+  polly mutate init [--force]        Scaffold a polly.mutate.ts for this project
+  polly mutate migrate [--write]     Convert stryker.conf.json to polly.mutate.ts (prints it
+                                     unless --write; --force overwrites an existing one)
+  polly mutate [run]                 Run mutation testing, then print the useless-test report
   polly mutate report                Print the report from an existing mutation.json
   polly mutate decisions             Review verdicts: needs-review / stale / settled
   polly mutate decisions decide <file> <keep|prune|rewrite|investigate> "<rationale>"
@@ -618,16 +3500,35 @@ Usage:
   polly mutate help                  Show this help
 
 Flags:
-  --config <path>     Stryker config (default: auto-discovered)
+  --config <path>     polly.mutate.ts, or a stryker.conf.json (default: ./polly.mutate.ts,
+                      else the discovered Stryker config, deprecated)
   --report <path>     mutation report JSON (default: reports/mutation/mutation.json)
   --decisions <path>  verdict log (default: .polly/test-debt/decisions.jsonl)
   --db <path>         intermediate SQLite (default: in-memory)
   --no-report         'run' only — skip the analysis
+  --files <a,b>       mutate only these files (globs and :from-to ranges allowed)
+  --since <git-ref>   mutate only targets changed since the ref
+  --in-tree           run tests in the project dir, not a scratch cwd
+  --concurrency <n>   parallel test processes (default: config, else cores-1)
+  --mode <fast|matrix> fast stops each run at the first failing test (default
+                      unless the config sets mode);
+                      matrix runs every test and records each killer (the kill matrix)
+  --coverage <dynamic|static> dynamic (default) runs one probed pass to find the
+                      tests that run each mutant, and marks unrun code NoCoverage;
+                      static runs every test file that imports the target
+  --no-cache          rerun targets whose inputs are unchanged
+  --no-typecheck      run mutants the project's tsconfig rejects (default: report
+                      them CompileError without a run; needs typescript-7)
+  --contracts <off|ensures|all> POLLY_CONTRACTS for every test process: a false
+                      requires/ensures throws, so each contract kills the mutants
+                      that falsify it (default all; ensures leaves requires inert;
+                      a baseline that violates a contract stops the run)
   -h, --help
 
-The redundancy/subsumption sections need a COMPLETE kill matrix (the no-bail
-patched Bun runner). Without it the report degrades to score + gaps + theatre;
-'polly mutate verify' diagnoses the matrix.`;
+The redundancy/subsumption sections need a COMPLETE kill matrix ('--mode matrix').
+Without it the report degrades
+to score + gaps + theatre; 'polly mutate verify' diagnoses the matrix
+('verify --run' runs a matrix pass first).`;
 async function openDb(reportPath, dbPath) {
   if (!await Bun.file(reportPath).exists()) {
     console.log(`no mutation report at ${reportPath}. Run 'polly mutate run' first, or pass --report <path>.`);
@@ -635,6 +3536,46 @@ async function openDb(reportPath, dbPath) {
   }
   return buildDb(await loadMutationReport(reportPath), dbPath);
 }
+async function init(cwd, force) {
+  const result = await initConfig(cwd, { force });
+  if (!result.created) {
+    console.log(`${result.configPath} already exists. Re-run with --force to overwrite.`);
+    return 1;
+  }
+  console.log(`✓ wrote ${result.configPath}`);
+  console.log(`  import:  ${result.specifier}`);
+  console.log(`  targets: ${result.mutate.join(", ")}`);
+  console.log(`  tests:   ${result.testGlob}`);
+  for (const w of result.warnings)
+    console.log(`  ⚠ ${w}`);
+  console.log(`
+Next: polly mutate run`);
+  return 0;
+}
+async function migrate(cwd, args) {
+  const strykerPath = args.config ? resolve5(cwd, args.config) : (await findStrykerConfigs(cwd))[0] ?? null;
+  if (!strykerPath) {
+    console.log("no stryker.conf.json found — pass --config <path>");
+    return 1;
+  }
+  const result = await migrateConfig(strykerPath, { write: args.write, force: args.force });
+  for (const n of result.notes)
+    console.log(`note: ${n}`);
+  if (!args.write) {
+    console.log(`
+// ${result.path}
+${result.source}`);
+    console.log("Re-run with --write to write it.");
+    return 0;
+  }
+  if (!result.written) {
+    console.log(`${result.path} already exists. Re-run with --force to overwrite.`);
+    return 1;
+  }
+  console.log(`✓ wrote ${result.path}`);
+  console.log(`  ${strykerPath} is no longer read once polly.mutate.ts exists; delete it.`);
+  return 0;
+}
 async function main() {
   const args = parseMutateArgs(process.argv.slice(2));
   if (args.help) {
@@ -642,30 +3583,15 @@ async function main() {
     return 0;
   }
   const cwd = process.cwd();
+  if (args.verb === "init")
+    return await init(cwd, args.force);
+  if (args.verb === "migrate")
+    return await migrate(cwd, args);
   const cfg = await resolveMutateConfig(cwd, args);
   switch (args.verb) {
-    case "init": {
-      const result = await initConfig(cwd, { force: args.force });
-      if (!result.created) {
-        console.log(`stryker.conf.json already exists at ${result.configPath}. Re-run with --force to overwrite.`);
-        return 1;
-      }
-      console.log(`✓ wrote ${result.configPath}`);
-      console.log(`  plugin:    ${result.pluginRef}`);
-      console.log(`  mutate:    ${result.mutate.join(", ")}`);
-      console.log(`  testFiles: ${result.testGlob}`);
-      for (const w of result.warnings)
-        console.log(`  ⚠ ${w}`);
-      console.log(`
-Next: polly mutate run`);
-      return 0;
-    }
     case "run": {
-      const tip = await presetAdvisory(cfg);
-      if (tip)
-        console.log(`${tip}
-`);
-      const code = await runStryker(cfg);
+      resolveEngine(args);
+      const code = await runBunEngine(cfg, args);
       if (code !== 0)
         return code;
       if (args.noReport)
@@ -699,18 +3625,18 @@ ${await reportFromFile(cfg)}`);
       return 0;
     }
     case "verify": {
-      const result = await verifyMatrix({
-        reportPath: cfg.reportPath,
-        run: args.run,
-        strykerConfig: cfg.strykerConfigPath ?? undefined
-      });
+      if (args.run) {
+        resolveEngine(args);
+        await runBunEngine(cfg, { ...args, mode: "matrix" });
+      }
+      const result = await verifyMatrix({ reportPath: cfg.reportPath });
       console.log(`
 Kill-matrix contract:`);
       for (const c of result.checks)
         console.log(`  ${c.ok ? "✓" : "✗"} ${c.name}  (${c.detail})`);
       if (!result.ok) {
         console.log(`
-✗ Contract broken. The pinned pair has drifted — re-check Bun version and that the patch applies (bun install).`);
+✗ Contract broken. Re-check the Bun version: matrix mode reads Bun's junit output (engine/junit.ts).`);
         return 1;
       }
       console.log(`
@@ -730,4 +3656,4 @@ main().then((code) => process.exit(code)).catch((err) => {
   process.exit(1);
 });
 
-//# debugId=C09CAFE7F39DD42A64756E2164756E21
+//# debugId=42FD32590F43AB6F64756E2164756E21