test(mutmut): item D closure - wl_csv.py 547 survivors + harness cache-leak fix

v1.1 item D from the 2026-05-18 pre-release sweep. First real

survivor data for bin/wl_csv.py with the correct test selector,

and a fix for a cache-leak harness bug discovered during the run.

## wl_csv.py fresh-run result

Mutmut run with the corrected selector (tests/unit/test_csv.py +

tests/unit/test_diff_fuzz.py) on a fresh :ro-mount + tmpfs

container. 723 mutations applied, 547 survived, 176 killed.

Effective mutation score: 24%.

Why the score is low: bin/wl_csv.py is 1244 lines. Only ~600 of

those (the diff engine + hash-registry plumbing) have unit-test

coverage in test_csv.py / test_diff_fuzz.py. The other ~600 lines

(save_csv_pipeline + create_csv_pipeline) are integration-tested

in tests/integration/, NOT exercised by the unit selector mutmut

uses. This shows up in the survivor ID ranges: 191-472 have a

mix of killed and survived (~50% each); 494-913 are almost all

survivors (integration paths).

Triage on 10 sampled survivors shows the killable subset:

  - logger / docstring strings: skip (low value)

  - constant strings → paths: killable, low priority

  - value→None crash mutations: killable, trivial tests

  - hidden-column filter strings: killable, security boundary

  - tuple default-value sentinels: mostly equivalent

  - response-dict key names: killable, highest value (contract pin)

  - JSON formatting params: equivalent (indent=2 vs 3)

  - integration-path mutations (~400 of them): killable but

    expensive (needs integration test coverage)

Genuine killable survivors in the unit-tested core: ~100-150.

Closing them = ~100-150 new unit tests = 1-2 days of work.

Deferred to v1.1 item G (test coverage push 32.4% → 80%), which

naturally covers the same code paths. Doing the work twice would

be wasteful.

## Harness cache-leak fix

Discovered during this run: a leftover .mutmut-cache (~192 KB)

from a prior :rw-mount session was sitting on the host repo.

populate_scratch()'s 'cp -a /repo/. /scratch/' copied this stale

cache into the fresh tmpfs, polluting 'mutmut results' with

phantom entries from prior misconfigured runs (37 wl_audit + 10-

12 wl_validation entries that survived in old caches but were

killed in newer runs).

Fix: populate_scratch() now wipes /scratch/.mutmut-cache and

C:/Program Files/Git/scratch/mutants after the cp. Two-line addition.

The wl_csv.py survivor count for THIS run is unaffected by the

leak (mutmut's progress counter showed 723/723 actually tested

— the leak only polluted the cumulative results display, not the

current-run results).

Host-side leftover at wl_manager/.mutmut-cache was also deleted.

.gitignore already excludes it from tracking.

## Doc updates in MUTATION_TESTING.md

- New section: "2026-05-19 wl_csv.py fresh-run results (item D)"

  with triage categories table + harness-fix note

- "Open" list: items 3 (wl_validation re-run, item C) and 4

  (wl_csv run, item D) marked CLOSED. Only wl_audit re-run

  remains in the open queue.

doc-drift: OK (33 docs against build 660).

Author: RelativisticJet

docs/MUTATION_TESTING.md

@@ -189,7 +189,7 @@ test selector. Notable findings:
 The 45 "survivors" reported for `bin/wl_csv.py` are NOT actionable.
 The mutmut command in the prior session was:
 
-```
+```text
 mutmut run --paths-to-mutate=bin/wl_csv.py --tests-dir=tests/unit \
   --runner='python -m pytest -x -q --tb=no \
             tests/unit/test_validation.py tests/unit/test_ascii_validation.py'
@@ -208,9 +208,80 @@ TEST_RUNNER_FILES="tests/unit/test_csv.py" \
     scripts/mutmut.sh run
 ```
 
-This run was NOT executed during the 2026-05-18 session — the time
-budget was exhausted by the discovery + safety work above. It is
-queued as v1.1 maintenance work.
+Re-ran 2026-05-19 — see next section for results.
+
+---
+
+## 2026-05-19 wl_csv.py fresh-run results (item D)
+
+Mutmut run with the corrected selector
+(`tests/unit/test_csv.py tests/unit/test_diff_fuzz.py`) on a fresh
+`:ro`-mount + tmpfs container.
+
+**Result: 723 mutations applied, 547 survived, 176 killed.
+Effective mutation score: 24%.**
+
+### Why the score is low
+
+`bin/wl_csv.py` is 1244 lines. Only ~600 of those — the diff engine
+(`compute_diff`, `compute_added`, `compute_removed`, `compute_edited`)
+and the hash-registry plumbing (`_csv_file_hash`,
+`update_csv_expected_hash`, `bootstrap_csv_expected_hashes`,
+`remove_csv_expected_hash`) — have unit-test coverage in
+`test_csv.py` and `test_diff_fuzz.py`. The remaining ~600 lines
+(`save_csv_pipeline` ~lines 747–1148 and `create_csv_pipeline`
+~lines 1149–1244) are tested via the live Splunk container in
+`tests/integration/`, NOT by the unit suite mutmut is exercising.
+
+This shows up in the survivor ID ranges: IDs 191–472 (the unit-
+testable core) have a mix of killed and survived mutations (~50%
+each in spot checks), while IDs 494–913 (the integration-only code)
+are almost entirely survivors.
+
+### Triage categories
+
+Spot-checked 10 representative survivors across the range; the
+pattern divides cleanly:
+
+| Class | Example mutants | Killable? | Action |
+|---|---|---|---|
+| Logger / docstring strings | 191 (logger name) | Low value | Skip |
+| Constant strings flowing into paths | 200 (`CSV_EXPECTED_HASHES_FILE`) | Killable | Worth a test pin |
+| Value→None crash mutations | 207 (`parent = None`) | Killable | Trivial unit test |
+| Hidden-column filter strings | 264, 388 (`startswith("_")`) | Killable | Security boundary, worth pinning |
+| Tuple default-value sentinels | 313, 332 (`row.get(h, "")`) | Mostly equivalent | Skip |
+| Response-dict key names | 431, 600 (`"text_diff"`, `"added_row_count"`) | Killable | Contract pinning — highest value |
+| JSON formatting params | 494 (`indent=2 → 3`) | Equivalent | Skip |
+| Integration-path mutations | 600+ (most of 494–913) | Killable but expensive | Defer to integration-test coverage |
+
+Rough estimate of GENUINE killable survivors in the unit-tested
+core (IDs 191–472): ~100–150. Closing them would require ~100–150
+new unit tests, ~5–10 lines each. Total work: 1–2 days.
+
+### Not addressed in this commit
+
+Closing the 100–150 genuine survivors is in scope of v1.1 item G
+(test coverage push from 32.4% → 80%). Writing those tests would
+naturally exercise the same code paths and kill the same mutants.
+Doing the work twice (once for mutmut-survivors, once for coverage)
+would be wasteful.
+
+### Harness bug discovered + fixed
+
+During this run, a leftover `.mutmut-cache` (~192 KB) from a prior
+`:rw`-mount session was found on the host repo. The
+`populate_scratch()` helper's `cp -a /repo/. /scratch/` copied this
+stale cache into the fresh tmpfs, leaking prior-run results (37
+phantom wl_audit survivors + 10–12 wl_validation entries) into the
+cumulative results display. This didn't affect the wl_csv survivor
+count for the new run (the mutmut progress counter showed
+`723/723` mutations actually tested), but it polluted the
+`mutmut results` aggregate view.
+
+Fix: `populate_scratch()` now explicitly wipes
+`/scratch/.mutmut-cache` and `/scratch/mutants` after the cp. The
+host-side leftover at `wl_manager/.mutmut-cache` was also removed.
+`.gitignore` already excluded it from tracking.
 
 ---
 
@@ -238,17 +309,25 @@ queued as v1.1 maintenance work.
    Source-refresh signal: `scripts/mutmut.sh kill` then re-run (the
    tmpfs is repopulated from `/repo` only on container creation).
 
-### Open (queued for v1.1 release prep)
-
-1. **Re-run wl_validation with the correct selector** to get a
-   fresh survivor count after the 2 new tests above. Expected
-   result: ≤8 survivors (the equivalent mutants), down from 12.
+3. ~~**Re-run wl_validation with the correct selector**~~ — DONE.
+   Result: 10 surviving mutants, all equivalent. See "2026-05-19
+   fresh-run confirmation" section above. The estimate of "≤8
+   survivors" was off by 2 — the original triage incorrectly listed
+   mutants 138 and 146 as "killed by existing tests" when they're
+   actually equivalent. Doc corrected.
+
+4. ~~**Run wl_csv.py with the correct selector**~~ — DONE.
+   Result: 547 survivors of 723 mutations (24% kill rate). The
+   estimate of "5-20 genuine gaps" was wildly low — the actual
+   genuine-gap count is ~100-150 in the unit-tested core, plus
+   ~400 survivors in integration-only code that won't be killed
+   by unit tests at all. See "2026-05-19 wl_csv.py fresh-run
+   results (item D)" section above. Closing the ~100-150 genuine
+   survivors is deferred to v1.1 item G (test coverage push).
 
-2. **Run wl_csv.py with the correct selector**. Expected: real
-   survivor count, plausibly 5-20 genuine gaps in CSV diff /
-   hash-registry logic.
+### Open (queued for v1.1 release prep)
 
-3. **Add `bin/wl_audit.py` mutation pass.** The 37 reported survivors
+1. **Add `bin/wl_audit.py` mutation pass.** The 37 reported survivors
    on `wl_audit.py` from a prior session need the same re-validation
    under the correct selector before deciding what to do with them.
 

scripts/mutmut.sh

@@ -249,12 +249,25 @@ populate_scratch() {
     # Running as -u 0 (root) inside the container because /scratch is
     # owned by root after tmpfs mount; the default container user
     # cannot write to a fresh root-owned mount.
+    #
+    # Post-cp: explicitly wipe any stale mutmut artifacts that came
+    # along from /repo. The 2026-05-19 item D run discovered that a
+    # prior :rw-mount session had left a `.mutmut-cache` (~190 KB)
+    # on the host repo. cp -a happily copied it into /scratch, and
+    # mutmut then aggregated those stale entries into the cumulative
+    # results table — confusing the wl_csv (correct selector) result
+    # display with leftover wl_audit / wl_validation entries from
+    # misconfigured prior runs. The wipe forces every container
+    # creation to start with a guaranteed-empty mutmut cache.
     echo "→ populating /scratch from /repo (tmpfs is fresh)..."
     if ! docker exec -u 0 "$CONTAINER" sh -c 'cp -a /repo/. /scratch/'; then
         echo "✖ scratch population failed — removing container." >&2
         docker rm -f "$CONTAINER" >/dev/null
         exit 1
     fi
+    # Wipe any prior mutmut artifacts that may have ridden along from
+    # the host. Safe to run even if neither exists.
+    docker exec -u 0 "$CONTAINER" sh -c 'rm -rf /scratch/.mutmut-cache /scratch/mutants' >/dev/null 2>&1 || true
 }
 
 scratch_is_empty() {