146 survivors out of 533 mutants (72.6 % killed)

### ggufone.bench.isolation.x__child_verdict: 92 survivor(s)
    ggufone.bench.isolation.x__child_verdict__mutmut_1 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_1(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics: dict[str, str] = {} | +    diagnostics: dict[str, str] = None
    ggufone.bench.isolation.x__child_verdict__mutmut_100 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_100(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            backend, command, None,
    ggufone.bench.isolation.x__child_verdict__mutmut_102 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_102(config: Any, backend: str, directory: pathlib.Path, *, | -            f"{out_path}{_tail_hint(stderr_tail)}", stderr_tail), diagnostics | +            f"{out_path}{_tail_hint(stderr_tail)}", None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_108 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_108(config: Any, backend: str, directory: pathlib.Path, *, | -            f"the isolated child exited {_exit_desc(exit_code)} without writing a report to " | +            f"the isolated child exited {_exit_desc(None)} without writing a report to "
    ggufone.bench.isolation.x__child_verdict__mutmut_112 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_112(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if (report.get("ok", True)) or True else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_114 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_114(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get(None, True) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_115 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_115(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("ok", None) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_117 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_117(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("ok", ) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_118 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_118(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("XXokXX", True) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_119 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_119(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("OK", True) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_120 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_120(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("ok", False) else 1
    ggufone.bench.isolation.x__child_verdict__mutmut_121 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_121(config: Any, backend: str, directory: pathlib.Path, *, | -    expected_exit = 0 if report.get("ok", True) else 1 | +    expected_exit = 0 if report.get("ok", True) else 2
    ggufone.bench.isolation.x__child_verdict__mutmut_127 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_127(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report), diagnostics | +            None, report=report), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_13 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_13(config: Any, backend: str, directory: pathlib.Path, *, | -    command = child_command(config, backend, python=python or sys.executable, out_path=out_path) | +    command = child_command(config, backend, python=python and sys.executable, out_path=out_path)
    ggufone.bench.isolation.x__child_verdict__mutmut_136 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_136(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get(None, True)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_137 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_137(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get('ok', None)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_138 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_138(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get(True)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_139 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_139(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get('ok', )}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_140 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_140(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get('XXokXX', True)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_141 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_141(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get('OK', True)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_142 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_142(config: Any, backend: str, directory: pathlib.Path, *, | -            f"`ok: {report.get('ok', True)}`: the exit code and the report contradict each other, " | +            f"`ok: {report.get('ok', False)}`: the exit code and the report contradict each other, "
    ggufone.bench.isolation.x__child_verdict__mutmut_150 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_150(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | -                             if isinstance(entry, Mapping)) or "nothing" | +        measured = None
    ggufone.bench.isolation.x__child_verdict__mutmut_151 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_151(config: Any, backend: str, directory: pathlib.Path, *, | -                             if isinstance(entry, Mapping)) or "nothing" | +                             if isinstance(entry, Mapping)) and "nothing"
    ggufone.bench.isolation.x__child_verdict__mutmut_153 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_153(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = "XX, XX".join(str(entry.get("backend")) for entry in report.get("backends") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_154 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_154(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(None) for entry in report.get("backends") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_155 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_155(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get(None)) for entry in report.get("backends") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_156 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_156(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("XXbackendXX")) for entry in report.get("backends") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_157 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_157(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("BACKEND")) for entry in report.get("backends") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_158 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_158(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") and []
    ggufone.bench.isolation.x__child_verdict__mutmut_159 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_159(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("backend")) for entry in report.get(None) or []
    ggufone.bench.isolation.x__child_verdict__mutmut_160 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_160(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("backend")) for entry in report.get("XXbackendsXX") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_161 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_161(config: Any, backend: str, directory: pathlib.Path, *, | -        measured = ", ".join(str(entry.get("backend")) for entry in report.get("backends") or [] | +        measured = ", ".join(str(entry.get("backend")) for entry in report.get("BACKENDS") or []
    ggufone.bench.isolation.x__child_verdict__mutmut_162 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_162(config: Any, backend: str, directory: pathlib.Path, *, | -                             if isinstance(entry, Mapping)) or "nothing" | +                             if isinstance(entry, Mapping)) or "XXnothingXX"
    ggufone.bench.isolation.x__child_verdict__mutmut_163 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_163(config: Any, backend: str, directory: pathlib.Path, *, | -                             if isinstance(entry, Mapping)) or "nothing" | +                             if isinstance(entry, Mapping)) or "NOTHING"
    ggufone.bench.isolation.x__child_verdict__mutmut_164 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_164(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            None, command, exit_code,
    ggufone.bench.isolation.x__child_verdict__mutmut_166 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_166(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            backend, command, None,
    ggufone.bench.isolation.x__child_verdict__mutmut_168 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_168(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report), diagnostics | +            None, report=report), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_169 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_169(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report), diagnostics | +            stderr_tail, report=None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_175 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_175(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report), diagnostics | +            stderr_tail, ), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_18 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_18(config: Any, backend: str, directory: pathlib.Path, *, | -                         "this report never names", ""), diagnostics | +                         "this report never names", None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_184 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_184(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            None, command, exit_code,
    ggufone.bench.isolation.x__child_verdict__mutmut_186 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_186(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            backend, command, None,
    ggufone.bench.isolation.x__child_verdict__mutmut_188 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_188(config: Any, backend: str, directory: pathlib.Path, *, | -            f"row would name a bundle it did not load", stderr_tail, report=report, | +            f"row would name a bundle it did not load", None, report=report,
    ggufone.bench.isolation.x__child_verdict__mutmut_189 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_189(config: Any, backend: str, directory: pathlib.Path, *, | -            f"row would name a bundle it did not load", stderr_tail, report=report, | +            f"row would name a bundle it did not load", stderr_tail, report=None,
    ggufone.bench.isolation.x__child_verdict__mutmut_190 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_190(config: Any, backend: str, directory: pathlib.Path, *, | -            row=row), diagnostics | +            row=None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_196 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_196(config: Any, backend: str, directory: pathlib.Path, *, | -            f"row would name a bundle it did not load", stderr_tail, report=report, | -            row=row), diagnostics | +            f"row would name a bundle it did not load", stderr_tail, row=row), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_197 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_197(config: Any, backend: str, directory: pathlib.Path, *, | -            row=row), diagnostics | +            ), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_212 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_212(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            None, command, exit_code,
    ggufone.bench.isolation.x__child_verdict__mutmut_214 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_214(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            backend, command, None,
    ggufone.bench.isolation.x__child_verdict__mutmut_216 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_216(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report, row=row), diagnostics | +            None, report=report, row=row), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_217 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_217(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report, row=row), diagnostics | +            stderr_tail, report=None, row=row), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_218 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_218(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report, row=row), diagnostics | +            stderr_tail, report=report, row=None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_224 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_224(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report, row=row), diagnostics | +            stderr_tail, row=row), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_225 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_225(config: Any, backend: str, directory: pathlib.Path, *, | -            stderr_tail, report=report, row=row), diagnostics | +            stderr_tail, report=report, ), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_226 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_226(config: Any, backend: str, directory: pathlib.Path, *, | -    return ChildRun(backend=backend, command=tuple(command), exit_code=exit_code, report=report, | +    return ChildRun(backend=None, command=tuple(command), exit_code=exit_code, report=report,
    ggufone.bench.isolation.x__child_verdict__mutmut_24 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_24(config: Any, backend: str, directory: pathlib.Path, *, | -                         "this run has no --model: a child is told the model path explicitly, and " | +                         "XXthis run has no --model: a child is told the model path explicitly, and XX"
    ggufone.bench.isolation.x__child_verdict__mutmut_26 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_26(config: Any, backend: str, directory: pathlib.Path, *, | -                         "one that resolved `GGUFONE_BENCH_MODEL` on its own could measure a model " | +                         "XXone that resolved `GGUFONE_BENCH_MODEL` on its own could measure a model XX"
    ggufone.bench.isolation.x__child_verdict__mutmut_28 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_28(config: Any, backend: str, directory: pathlib.Path, *, | -                         "one that resolved `GGUFONE_BENCH_MODEL` on its own could measure a model " | +                         "ONE THAT RESOLVED `GGUFONE_BENCH_MODEL` ON ITS OWN COULD MEASURE A MODEL "
    ggufone.bench.isolation.x__child_verdict__mutmut_29 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_29(config: Any, backend: str, directory: pathlib.Path, *, | -                         "this report never names", ""), diagnostics | +                         "XXthis report never namesXX", ""), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_30 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_30(config: Any, backend: str, directory: pathlib.Path, *, | -                         "this report never names", ""), diagnostics | +                         "THIS REPORT NEVER NAMES", ""), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_31 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_31(config: Any, backend: str, directory: pathlib.Path, *, | -                         "this report never names", ""), diagnostics | +                         "this report never names", "XXXX"), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_36 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_36(config: Any, backend: str, directory: pathlib.Path, *, | -        completed = launcher(command, env=dict(os.environ) if env is None else dict(env), | +        completed = launcher(command, env=None,
    ggufone.bench.isolation.x__child_verdict__mutmut_37 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_37(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=None, text=True, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_38 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_38(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=True, text=None, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_39 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_39(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=True, text=True, timeout=None)
    ggufone.bench.isolation.x__child_verdict__mutmut_41 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_41(config: Any, backend: str, directory: pathlib.Path, *, | -        completed = launcher(command, env=dict(os.environ) if env is None else dict(env), | -                             capture_output=True, text=True, timeout=timeout) | +        completed = launcher(command, capture_output=True, text=True, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_42 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_42(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             text=True, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_43 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_43(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=True, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_44 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_44(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=True, text=True, )
    ggufone.bench.isolation.x__child_verdict__mutmut_46 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_46(config: Any, backend: str, directory: pathlib.Path, *, | -        completed = launcher(command, env=dict(os.environ) if env is None else dict(env), | +        completed = launcher(command, env=dict(os.environ) if (env is None) or True else dict(env),
    ggufone.bench.isolation.x__child_verdict__mutmut_49 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_49(config: Any, backend: str, directory: pathlib.Path, *, | -        completed = launcher(command, env=dict(os.environ) if env is None else dict(env), | +        completed = launcher(command, env=dict(os.environ) if env is None else dict(None),
    ggufone.bench.isolation.x__child_verdict__mutmut_50 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_50(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=False, text=True, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_51 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_51(config: Any, backend: str, directory: pathlib.Path, *, | -                             capture_output=True, text=True, timeout=timeout) | +                             capture_output=True, text=False, timeout=timeout)
    ggufone.bench.isolation.x__child_verdict__mutmut_52 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_52(config: Any, backend: str, directory: pathlib.Path, *, | -        return _unusable(backend, command, None, | +        return _unusable(None, command, None,
    ggufone.bench.isolation.x__child_verdict__mutmut_55 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_55(config: Any, backend: str, directory: pathlib.Path, *, | -                         f"E_BENCH_CHILD: the child process never started ({exc})", ""), diagnostics | +                         f"E_BENCH_CHILD: the child process never started ({exc})", None), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_61 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_61(config: Any, backend: str, directory: pathlib.Path, *, | -                         f"E_BENCH_CHILD: the child process never started ({exc})", ""), diagnostics | +                         f"E_BENCH_CHILD: the child process never started ({exc})", "XXXX"), diagnostics
    ggufone.bench.isolation.x__child_verdict__mutmut_63 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_63(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"XXstdoutXX": getattr(completed, "stdout", "") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_64 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_64(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"STDOUT": getattr(completed, "stdout", "") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_65 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_65(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "stdout", "") and "",
    ggufone.bench.isolation.x__child_verdict__mutmut_66 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_66(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(None, "stdout", "") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_68 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_68(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "stdout", None) or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_7 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_7(config: Any, backend: str, directory: pathlib.Path, *, | -    command = child_command(config, backend, python=python or sys.executable, out_path=out_path) | +    command = child_command(config, backend, python=None, out_path=out_path)
    ggufone.bench.isolation.x__child_verdict__mutmut_71 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_71(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "stdout", ) or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_72 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_72(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "XXstdoutXX", "") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_73 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_73(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "STDOUT", "") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_74 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_74(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "stdout", "XXXX") or "",
    ggufone.bench.isolation.x__child_verdict__mutmut_75 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_75(config: Any, backend: str, directory: pathlib.Path, *, | -    diagnostics = {"stdout": getattr(completed, "stdout", "") or "", | +    diagnostics = {"stdout": getattr(completed, "stdout", "") or "XXXX",
    ggufone.bench.isolation.x__child_verdict__mutmut_81 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_81(config: Any, backend: str, directory: pathlib.Path, *, | -                   "stderr": getattr(completed, "stderr", "") or ""} | +                   "stderr": getattr(completed, "stderr", None) or ""}
    ggufone.bench.isolation.x__child_verdict__mutmut_84 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_84(config: Any, backend: str, directory: pathlib.Path, *, | -                   "stderr": getattr(completed, "stderr", "") or ""} | +                   "stderr": getattr(completed, "stderr", ) or ""}
    ggufone.bench.isolation.x__child_verdict__mutmut_87 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_87(config: Any, backend: str, directory: pathlib.Path, *, | -                   "stderr": getattr(completed, "stderr", "") or ""} | +                   "stderr": getattr(completed, "stderr", "XXXX") or ""}
    ggufone.bench.isolation.x__child_verdict__mutmut_88 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_88(config: Any, backend: str, directory: pathlib.Path, *, | -                   "stderr": getattr(completed, "stderr", "") or ""} | +                   "stderr": getattr(completed, "stderr", "") or "XXXX"}
    ggufone.bench.isolation.x__child_verdict__mutmut_98 :: -def x__child_verdict__mutmut_orig(config: Any, backend: str, directory: pathlib.Path, *, | +def x__child_verdict__mutmut_98(config: Any, backend: str, directory: pathlib.Path, *, | -            backend, command, exit_code, | +            None, command, exit_code,

### ggufone.bench.isolation.x_isolation_note: 11 survivor(s)
    ggufone.bench.isolation.x_isolation_note__mutmut_10 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_10(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get(None))}: {row.get('reason')}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_11 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_11(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get('XXexit_codeXX'))}: {row.get('reason')}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_12 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_12(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get('EXIT_CODE'))}: {row.get('reason')}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_13 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_13(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get(None)}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_14 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_14(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('XXreasonXX')}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_15 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_15(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('REASON')}. The row is "
    ggufone.bench.isolation.x_isolation_note__mutmut_2 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_2(row: Mapping[str, Any]) -> str: | -    process = row.get("process") or {} | +    process = row.get("process") and {}
    ggufone.bench.isolation.x_isolation_note__mutmut_3 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_3(row: Mapping[str, Any]) -> str: | -    process = row.get("process") or {} | +    process = row.get(None) or {}
    ggufone.bench.isolation.x_isolation_note__mutmut_4 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_4(row: Mapping[str, Any]) -> str: | -    process = row.get("process") or {} | +    process = row.get("XXprocessXX") or {}
    ggufone.bench.isolation.x_isolation_note__mutmut_5 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_5(row: Mapping[str, Any]) -> str: | -    process = row.get("process") or {} | +    process = row.get("PROCESS") or {}
    ggufone.bench.isolation.x_isolation_note__mutmut_9 :: -def x_isolation_note__mutmut_orig(row: Mapping[str, Any]) -> str: | +def x_isolation_note__mutmut_9(row: Mapping[str, Any]) -> str: | -            f"child exited {_exit_desc(process.get('exit_code'))}: {row.get('reason')}. The row is " | +            f"child exited {_exit_desc(None)}: {row.get('reason')}. The row is "

### ggufone.bench.isolation.x_run_backend_child: 11 survivor(s)
    ggufone.bench.isolation.x_run_backend_child__mutmut_11 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_11(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -    directory.mkdir(parents=True, exist_ok=True) | +    directory.mkdir(exist_ok=True)
    ggufone.bench.isolation.x_run_backend_child__mutmut_13 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_13(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -    directory.mkdir(parents=True, exist_ok=True) | +    directory.mkdir(parents=False, exist_ok=True)
    ggufone.bench.isolation.x_run_backend_child__mutmut_20 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_20(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -    verdict, diagnostics = _child_verdict(config, backend, directory, runner=runner, python=python, | +    verdict, diagnostics = _child_verdict(config, backend, directory, runner=runner, python=None,
    ggufone.bench.isolation.x_run_backend_child__mutmut_21 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_21(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -                                          env=env, timeout=timeout, runtime_dir=runtime_dir) | +                                          env=None, timeout=timeout, runtime_dir=runtime_dir)
    ggufone.bench.isolation.x_run_backend_child__mutmut_22 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_22(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -                                          env=env, timeout=timeout, runtime_dir=runtime_dir) | +                                          env=env, timeout=None, runtime_dir=runtime_dir)
    ggufone.bench.isolation.x_run_backend_child__mutmut_35 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_35(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -            shutil.rmtree(directory, ignore_errors=True) | +            shutil.rmtree(directory, ignore_errors=None)
    ggufone.bench.isolation.x_run_backend_child__mutmut_37 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_37(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -            shutil.rmtree(directory, ignore_errors=True) | +            shutil.rmtree(directory, )
    ggufone.bench.isolation.x_run_backend_child__mutmut_38 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_38(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -            shutil.rmtree(directory, ignore_errors=True) | +            shutil.rmtree(directory, ignore_errors=False)
    ggufone.bench.isolation.x_run_backend_child__mutmut_48 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_48(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -        verdict, detail=f"{verdict.detail} (the child's own report and logs are kept at " | -                        f"{directory})") | +        verdict, )
    ggufone.bench.isolation.x_run_backend_child__mutmut_8 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_8(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -        tempfile.mkdtemp(prefix=DEFAULT_OUT_PREFIX)) | +        tempfile.mkdtemp(prefix=None))
    ggufone.bench.isolation.x_run_backend_child__mutmut_9 :: -def x_run_backend_child__mutmut_orig(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | +def x_run_backend_child__mutmut_9(config: Any, backend: str, *, runner: Callable[..., Any] | None = None, | -    directory.mkdir(parents=True, exist_ok=True) | +    directory.mkdir(parents=None, exist_ok=True)

### ggufone.bench.isolation.x__exit_desc: 6 survivor(s)
    ggufone.bench.isolation.x__exit_desc__mutmut_10 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_10(exit_code: int | None) -> str: | -            name = f"signal {-exit_code}" | +            name = f"signal {+exit_code}"
    ggufone.bench.isolation.x__exit_desc__mutmut_13 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_13(exit_code: int | None) -> str: | -    return str(exit_code) | +    return str(None)
    ggufone.bench.isolation.x__exit_desc__mutmut_2 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_2(exit_code: int | None) -> str: | -        return "never started" | +        return "XXnever startedXX"
    ggufone.bench.isolation.x__exit_desc__mutmut_4 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_4(exit_code: int | None) -> str: | -    if exit_code < 0: | +    if exit_code <= 0:
    ggufone.bench.isolation.x__exit_desc__mutmut_5 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_5(exit_code: int | None) -> str: | -    if exit_code < 0: | +    if exit_code < 1:
    ggufone.bench.isolation.x__exit_desc__mutmut_9 :: -def x__exit_desc__mutmut_orig(exit_code: int | None) -> str: | +def x__exit_desc__mutmut_9(exit_code: int | None) -> str: | -            name = f"signal {-exit_code}" | +            name = None

### ggufone.bench.isolation.x__echo_mismatch: 4 survivor(s)
    ggufone.bench.isolation.x__echo_mismatch__mutmut_40 :: -def x__echo_mismatch__mutmut_orig(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | +def x__echo_mismatch__mutmut_40(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | -    for field in COMMON_ECHO + SUITE_ECHO.get(str(config.suite), ()): | +    for field in COMMON_ECHO + SUITE_ECHO.get(str(config.suite), None):
    ggufone.bench.isolation.x__echo_mismatch__mutmut_42 :: -def x__echo_mismatch__mutmut_orig(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | +def x__echo_mismatch__mutmut_42(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | -    for field in COMMON_ECHO + SUITE_ECHO.get(str(config.suite), ()): | +    for field in COMMON_ECHO + SUITE_ECHO.get(str(config.suite), ):
    ggufone.bench.isolation.x__echo_mismatch__mutmut_46 :: -def x__echo_mismatch__mutmut_orig(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | +def x__echo_mismatch__mutmut_46(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | -            return f"{field}={echo.get(field)!r}, this run asked {expected[field]!r}" | +            return f"{field}={echo.get(None)!r}, this run asked {expected[field]!r}"
    ggufone.bench.isolation.x__echo_mismatch__mutmut_6 :: -def x__echo_mismatch__mutmut_orig(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | +def x__echo_mismatch__mutmut_6(config: Any, backend: str, report: Mapping[str, Any]) -> str | None: | -        return "the report carries no `config` block (the child's run cannot be checked)" | +        return "XXthe report carries no `config` block (the child's run cannot be checked)XX"

### ggufone.bench.isolation.x_isolation_record: 4 survivor(s)
    ggufone.bench.isolation.x_isolation_record__mutmut_10 :: -def x_isolation_record__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_record__mutmut_10(config: Any, runtimes: Mapping[str, Any], | -            "suite": config.suite} | +            "XXsuiteXX": config.suite}
    ggufone.bench.isolation.x_isolation_record__mutmut_11 :: -def x_isolation_record__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_record__mutmut_11(config: Any, runtimes: Mapping[str, Any], | -            "suite": config.suite} | +            "SUITE": config.suite}
    ggufone.bench.isolation.x_isolation_record__mutmut_8 :: -def x_isolation_record__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_record__mutmut_8(config: Any, runtimes: Mapping[str, Any], | -            "reason": BUNDLE_ISOLATION_REASON, | +            "XXreasonXX": BUNDLE_ISOLATION_REASON,
    ggufone.bench.isolation.x_isolation_record__mutmut_9 :: -def x_isolation_record__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_record__mutmut_9(config: Any, runtimes: Mapping[str, Any], | -            "reason": BUNDLE_ISOLATION_REASON, | +            "REASON": BUNDLE_ISOLATION_REASON,

### ggufone.bench.isolation.x__keep_diagnostics: 3 survivor(s)
    ggufone.bench.isolation.x__keep_diagnostics__mutmut_2 :: -def x__keep_diagnostics__mutmut_orig(directory: pathlib.Path, backend: str, | +def x__keep_diagnostics__mutmut_2(directory: pathlib.Path, backend: str, | -            (directory / f"row-{backend}.{stream}").write_text(text, encoding="utf-8") | +            (directory / f"row-{backend}.{stream}").write_text(text, encoding=None)
    ggufone.bench.isolation.x__keep_diagnostics__mutmut_4 :: -def x__keep_diagnostics__mutmut_orig(directory: pathlib.Path, backend: str, | +def x__keep_diagnostics__mutmut_4(directory: pathlib.Path, backend: str, | -            (directory / f"row-{backend}.{stream}").write_text(text, encoding="utf-8") | +            (directory / f"row-{backend}.{stream}").write_text(text, )
    ggufone.bench.isolation.x__keep_diagnostics__mutmut_7 :: -def x__keep_diagnostics__mutmut_orig(directory: pathlib.Path, backend: str, | +def x__keep_diagnostics__mutmut_7(directory: pathlib.Path, backend: str, | -            (directory / f"row-{backend}.{stream}").write_text(text, encoding="utf-8") | +            (directory / f"row-{backend}.{stream}").write_text(text, encoding="UTF-8")

### ggufone.bench.isolation.x__read_report: 3 survivor(s)
    ggufone.bench.isolation.x__read_report__mutmut_3 :: -def x__read_report__mutmut_orig(path: pathlib.Path) -> Mapping[str, Any] | None: | +def x__read_report__mutmut_3(path: pathlib.Path) -> Mapping[str, Any] | None: | -        payload = json.loads(path.read_text(encoding="utf-8")) | +        payload = json.loads(path.read_text(encoding=None))
    ggufone.bench.isolation.x__read_report__mutmut_5 :: -def x__read_report__mutmut_orig(path: pathlib.Path) -> Mapping[str, Any] | None: | +def x__read_report__mutmut_5(path: pathlib.Path) -> Mapping[str, Any] | None: | -        payload = json.loads(path.read_text(encoding="utf-8")) | +        payload = json.loads(path.read_text(encoding="UTF-8"))
    ggufone.bench.isolation.x__read_report__mutmut_7 :: -def x__read_report__mutmut_orig(path: pathlib.Path) -> Mapping[str, Any] | None: | +def x__read_report__mutmut_7(path: pathlib.Path) -> Mapping[str, Any] | None: | -    return payload if isinstance(payload, Mapping) else None | +    return payload if (isinstance(payload, Mapping)) or True else None

### ggufone.bench.isolation.x_isolated_row: 3 survivor(s)
    ggufone.bench.isolation.x_isolated_row__mutmut_3 :: -def x_isolated_row__mutmut_orig(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | +def x_isolated_row__mutmut_3(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | -    if child.ok and child.row is not None: | +    if child.ok or child.row is not None:
    ggufone.bench.isolation.x_isolated_row__mutmut_7 :: -def x_isolated_row__mutmut_orig(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | +def x_isolated_row__mutmut_7(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | -    return {**gap, "backend": child.backend, "reason": child.detail, "process": block} | +    return {**gap, "XXbackendXX": child.backend, "reason": child.detail, "process": block}
    ggufone.bench.isolation.x_isolated_row__mutmut_8 :: -def x_isolated_row__mutmut_orig(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | +def x_isolated_row__mutmut_8(child: ChildRun, *, gap: Mapping[str, Any]) -> dict[str, Any]: | -    return {**gap, "backend": child.backend, "reason": child.detail, "process": block} | +    return {**gap, "BACKEND": child.backend, "reason": child.detail, "process": block}

### ggufone.bench.isolation.x__tail: 2 survivor(s)
    ggufone.bench.isolation.x__tail__mutmut_3 :: -def x__tail__mutmut_orig(text: str | None) -> str: | -    tail = (text or "").strip() | +def x__tail__mutmut_3(text: str | None) -> str: | +    tail = (text or "XXXX").strip()
    ggufone.bench.isolation.x__tail__mutmut_4 :: -def x__tail__mutmut_orig(text: str | None) -> str: | +def x__tail__mutmut_4(text: str | None) -> str: | -    if len(tail) <= STDERR_TAIL_CHARS: | +    if len(tail) < STDERR_TAIL_CHARS:

### ggufone.bench.isolation.x__tail_hint: 2 survivor(s)
    ggufone.bench.isolation.x__tail_hint__mutmut_2 :: -def x__tail_hint__mutmut_orig(tail: str) -> str: | -    return f" (stderr tail: {tail})" if tail else "" | +def x__tail_hint__mutmut_2(tail: str) -> str: | +    return f" (stderr tail: {tail})" if (tail) or True else ""
    ggufone.bench.isolation.x__tail_hint__mutmut_3 :: -def x__tail_hint__mutmut_orig(tail: str) -> str: | -    return f" (stderr tail: {tail})" if tail else "" | +def x__tail_hint__mutmut_3(tail: str) -> str: | +    return f" (stderr tail: {tail})" if tail else "XXXX"

### ggufone.bench.isolation.x__unusable: 2 survivor(s)
    ggufone.bench.isolation.x__unusable__mutmut_5 :: -def x__unusable__mutmut_orig(backend: str, command: Sequence[str], exit_code: int | None, detail: str, | +def x__unusable__mutmut_5(backend: str, command: Sequence[str], exit_code: int | None, detail: str, | -                    row=row, ok=False, detail=detail, stderr_tail=stderr_tail) | +                    row=None, ok=False, detail=detail, stderr_tail=stderr_tail)
    ggufone.bench.isolation.x__unusable__mutmut_8 :: -def x__unusable__mutmut_orig(backend: str, command: Sequence[str], exit_code: int | None, detail: str, | +def x__unusable__mutmut_8(backend: str, command: Sequence[str], exit_code: int | None, detail: str, | -                    row=row, ok=False, detail=detail, stderr_tail=stderr_tail) | +                    row=row, ok=False, detail=detail, stderr_tail=None)

### ggufone.bench.isolation.x_isolation_used_note: 2 survivor(s)
    ggufone.bench.isolation.x_isolation_used_note__mutmut_1 :: -def x_isolation_used_note__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_used_note__mutmut_1(config: Any, runtimes: Mapping[str, Any], | -    distinct = len({_bundle_key(runtimes[backend]) for backend in backends if backend in runtimes}) | +    distinct = None
    ggufone.bench.isolation.x_isolation_used_note__mutmut_3 :: -def x_isolation_used_note__mutmut_orig(config: Any, runtimes: Mapping[str, Any], | +def x_isolation_used_note__mutmut_3(config: Any, runtimes: Mapping[str, Any], | -            f"{', '.join(backends)} over {distinct} distinct local bundle directories, and " | +            f"{'XX, XX'.join(backends)} over {distinct} distinct local bundle directories, and "

### ggufone.bench.isolation.x_child_command: 1 survivor(s)
    ggufone.bench.isolation.x_child_command__mutmut_45 :: -def x_child_command__mutmut_orig(config: Any, backend: str, *, python: str, out_path: pathlib.Path) -> list[str]: | +def x_child_command__mutmut_45(config: Any, backend: str, *, python: str, out_path: pathlib.Path) -> list[str]: | -        parts += ["--sizes", ",".join(str(int(size)) for size in config.prefill_sizes)] | +        parts += ["--sizes", "XX,XX".join(str(int(size)) for size in config.prefill_sizes)]

