---
name: climber-gate
description: Regenerate the window climber's adversarial trap traces and run the behavioral gate against the real cache in the simulator
argument-hint: "[gate|frontier|<family>]"
context: fork
allowed-tools: Read, Grep, Glob, Bash, Write
---

# Climber behavioral gate

Companion to `/audit-adaptivity` (which audits the code): this skill regenerates the
deterministic adversarial traces behind `.claude/docs/hill-climber.md` §3 and re-runs the real
cache (`product.Caffeine`) against fresh LRU / static-window-ceiling anchors. Run it after any
change to `WindowClimber` or the window-resize logic in `BoundedLocalCache`. This directory is
also the durable home of the trap generators — the trace files themselves are disposable and
regenerate bit-identically (verified against the 2026-07 study's battery).

## Harness

- Generate traces into a scratch dir; every generator is seeded and deterministic.
- The simulator drives the real library:
  `./gradlew simulator:run -q -Dcaffeine.simulator.maximum-size=<N>
  -Dcaffeine.simulator.files.paths.0=<fmt>:<path>
  -Dcaffeine.simulator.policies.0=product.Caffeine -Dcaffeine.simulator.policies.1=linked.Lru
  -Dcaffeine.simulator.admission.0=Always -Dcaffeine.simulator.report.format=csv`.
  Always pass `admission.0=Always` — the default admission list includes `Clairvoyant`, which
  materializes the whole trace.
- `probe.py <trace> --size N` is the per-cell verdict instrument: fresh LRU / Belady /
  best-static-window anchors, the real cache's hit rate, and a `TRAP?` flag when the gap to the
  ceiling is under −3pp. Run it from the repo root (or set `CAF_TREE`).
- **The `reactive` arm is a third anchor, not just an ablation.** LRU says "better than doing
  nothing"; the static-window ceiling says "how much is on the table"; the reactive arm says
  **"is the density machine earning its complexity on this row"** — which is the only one of the
  three that can retire code. These families were constructed to attack the *density* signal, so
  most of them are not traps for the hit-rate law at all and "far above LRU" is a bar that hides
  that. Measured 2026-08-04: on the deterministic families the reactive arm is level or ahead
  (whisper 66.04 vs 66.78, mixture d025@32k 56.46 vs 58.48, mixture d050 long 58.44 vs 58.18),
  and where the machine is clearly better the gain is often a *spread* rather than a level —
  straywall2 reactive 48.12 **±19.84** against 55.07±0.03, demoflood 61.83 **±9.87** against
  68.56±0.05. A single draw on those two reads 54.71 / 68.40, i.e. near-parity, and is wrong;
  **never quote a reactive comparison from one run.**
  Like LRU and the ceiling, the value is a property of the trace instance rather than of the
  change under test, so it is measured once and recorded in the table's `reactive` column — a
  routine change-verification run does not need to re-measure it. Re-measure when the instance is
  regenerated by a new generator revision, or when a change touches shared climber state
  (`Step`, `Sample`, the sample period, the resize path) rather than the density tier alone.
  Refresh it with `gate.py <traces> hybrid,reactive out.csv`, which pairs the arms inside each
  run; it needs the harness worktree, since `reactive` is a harness knob.
- **The static-window anchor is weighted-capable** (2026-08-02; before that date weighted runs
  silently dropped it — "no curve" in under a second): `sketch.WindowTinyLfu` declares WEIGHTED
  and budgets its regions by entry weight, mirroring `BoundedLocalCache`'s candidate/victim
  eviction loop; on unit-weight traces it is bit-for-bit the classic single-step form (verified
  on the bundled lirs cells). Weighted terrain/ceiling scans sweep `percent-main` exactly like
  unweighted ones — but read the right metric: the panel reports the **weighted** (byte) hit
  rate for weighted cells, while the climber's own goal metric is the per-request object rate
  (its sample counters are unweighted), so judge climber terrain on the `Hit Rate` column.
  **A weighted ceiling taken before 2026-08-07 is void.** The policy's admission filter was
  sized once, when the cache first filled, and never re-sized; the cache retracks it on every
  addition. The sketch's reset period scales with its capacity, so a frozen one ages at
  near-zero period and flatters *small* windows, where nearly every admission is filtered.
  On `metaCDN_rprn@4G` that put the reported static-window optimum at a 1% window when it is at
  80%. Nothing recorded was affected (no weighted ceiling had been taken); the filter now
  retracks per addition and unweighted output is unchanged bit-for-bit.
- `run.py <trace> --size N [--anchors] [--runs N] [--variants ...] [--dump PREFIX]` runs one
  cell (LRU + static-window anchors, N repeats, mean ± spread), and `gate.py <traces-dir>
  [variants] [out.csv]` runs this table's whole battery at the table's per-cell N — the
  runnable form of the gate; update the two together. `gate.py` **rotates its arms inside each
  run** rather than running them in blocks, so a cell's arms share machine state and basin draws
  (it ran in blocks until 2026-08-02, which contradicted the pairing rule below).
- **Characterizing a holdout: pass an EMPTY `--variants`.** `run.py --anchors` and `probe.py`
  both used to loop a variant list that was never allowed to be empty, so *every* anchor run also
  fired one `product.Caffeine` pass. §6 selects a holdout by **LRU-only** characterization and a
  cell is spent once the product has touched it, so the tool silently burned the cell it was
  characterizing — measured 2026-08-02, cost `arc/P1@65536`. Both now accept `--variants ''` and
  skip the product entirely; verify with the printed output (an anchors-only run prints the
  `LRU=… ceiling=…` line and nothing else).
- **`-Dcaffeine.climber.seed=<n>` (harness) makes a run deterministic.** `BoundedLocalCache.admit`'s
  1-in-128 HashDoS draw is the simulator's only live nondeterminism (the policy runs
  `.executor(Runnable::run)`), so seeding it makes a cell reproduce **bit for bit** and a lottery
  basin is adjudicated in ONE paired run instead of N=10 draw counting. Added 2026-08-03, where it
  settled two contested rows immediately: a −5.77 on `phases_d050` was pure basin draw (arms
  bit-identical on all 8 seeds) while a −2.12 on `crashnoise_a12` was real (−1.43 on 7 of 8).
  Prefer it for any single-cell adjudication. It does NOT replace the unseeded N≥8 policy for
  claims about the *distribution* of basins, and a seeded sweep is only as broad as its seed list —
  use 8 seeds, not one.
- **`harness.py` wires in the adversarial-round instrumentation** — `harness.py apply <worktree>`
  (also `verify` and `strip`), distilled from rounds 2–4 so each round stops rebuilding it. NEVER
  commit the result: it prints to stderr and carries variant knobs, and ErrorProne flags the
  `SystemOut` by design. It adds `-Dcaffeine.climber.debug=true` (one mode-labeled stderr line per
  density sample — the trajectory instrument that found every behavioral defect to date),
  `-Dcaffeine.climber.seed=<n>` (a seeded admission tiebreak), `-Dcaffeine.climber.auditbar=<f>`
  (the audit crash bar's fraction of the rate frozen at arm; **0 restores the pre-fix absolute
  5pp**), and `-Dcaffeine.climber.variant=` with ablation arms: `noaudit` (audit layer off),
  `reactive` (hit-rate tier at every size), `nocal` (no cold-start calibration), `hardreset` /
  `starvwrite` / `prefix` (restore the pre-round-3 clock reset, the pre-round-3 starvation
  schedule write, or both), `absprobe` (the pre-adv3 absolute walk-interior bar for starvation
  probes), `precrash` (the pre-crash-semantics machine: shared crash ledger, escalated crashes
  double the audit clock, one-sample audit aborts), `flatroom` (the pre-2026-08-03 room rule,
  measuring the flat restart magnitude while the walk strode up to 4× it), and `staleclaim` (the
  pre-2026-08-03 stand-down, which left the goal metric smoothing across a regime shift) — the A/B
  arms for landed fixes without checking out history. One arm is a candidate rather than history:
  `parkbound` (end an audit's park with its shield instead of holding to the next audit — battery
  mean +0.08 and real-corpus neutral). It was recorded as the live lead on the R4-F1 give-back,
  worth "+1.3..2.0 uniformly on all three `shieldtrap` seeds". **That does not reproduce under
  seeded paired runs and the lead is withdrawn** (2026-08-04, N=8 admission seeds 1–8, arms
  rotated inside each run): s7 78.06 → **76.92**, s11 77.19 → 77.60, s13 77.44 → 77.83 — mean
  −0.11, not +1.3..2.0, and it closes none of the 1.37pp the reactive arm leads this family by
  (78.93). What it actually does is **collapse the basin structure to a fixed ~77.6**: on s11 its
  spread is 0.13 against `hybrid`'s 2.94, so it gains where hybrid draws low and gives back where
  hybrid draws high. On s7 that trade is bad — two of eight seeds fall to 74.37/74.68 against
  hybrid's 79.01/79.00, a −4.6 tail the unseeded mean hid. `saw_p40` (the family's other
  sentinel) is +0.49, which does not pay for it. Re-open only with a mechanism for the s7 tail.
- **It is snippets, not a diff, and that is load-bearing.** It was `experiment-harness.patch` until
  2026-08-04, when it broke three times in one day: a unified diff encodes *the source it was cut
  from*, carrying javadoc as context, so an unrelated comment reword breaks it — and **both failure
  modes are silent**. `git apply` is all-or-nothing per file, so one stale hunk refuses **every**
  hunk for that file and yields a build with no instrumentation that still prints plausible numbers
  (an ablation arm then measures the shipped machine). A fuzzy `patch` lands the rest and reverts
  whatever the stale context encodes — twice reverting a landed fix inside `densityClimb`.
  Both harnesses assert their edit tables are safe before touching a file: presence of the applied
  form is the idempotency test, the verify test *and* the strip target, so two edits whose applied
  forms are equal — or where one contains the other — make the second invisible. Apply skips it as
  already wired, verify passes, and the instrumentation is silently partial while still printing
  plausible numbers. That is not hypothetical: the admission harness hit it on its first run
  (two edits inserting the same counter line at different anchors) and lost 276,764 of 558,186 hits.
  `harness.py` anchors on **code only**, so doc edits cannot move it; a moved anchor names itself
  and stops, applying is idempotent, and `strip` round-trips to pristine. If a variant arm reads
  suspiciously like the baseline, run `harness.py verify` before believing it is a finding.
  It earned this on its first use: `verify` reported **5 of 27 not wired** in a study that had
  applied the old patch with `--fuzz`, and two of the five were the admission-seeding pair — so
  every "seeded, bit-reproducible" adjudication in that study would have been fiction. The
  study reset both files, re-applied, and then proved seeding empirically (one cell, one seed,
  run twice, bit-identical) rather than reasoning past the warning. Do that check whenever
  `verify` is not clean.
  Point `run.py`/`gate.py` at the worktree via `CAF_TREE`.
- **A probe you add yourself must print `climb `-prefixed lines, and must assert its own
  denominator.** `run.py` keeps only stderr lines starting with `"climb "`, so an ad-hoc
  `System.err.println("MYCOUNTER ...")` is discarded before it reaches the `--dump` file and the
  count reads **zero** — from a probe that compiled in and ran on every sample. Measured
  2026-08-09, where it turned 3 phantom anchor plants into a "no measured exposure" conclusion
  that was about to be written up. The line must also carry `win=` and `mode=`, since
  `summarize` parses both out of every dumped line. The check that catches it is free: pair the
  new counter against a quantity the harness already counts (drain evaluations must equal
  `mode=undo` samples) and refuse the numerator until the denominator matches. Same family as the
  `verify` incident above — a silent probe and a wired probe produce identical-looking output.
- `exposure.py` (harness-dependent) answers "can this trace ever audit?": stillness fraction,
  longest run vs the wait, audits/probes armed — the instrument behind the corda blind-hold
  and w097 at-the-bar findings. `blindlock.py` (harness-dependent) answers the neighbouring
  question, "how much exploration is the blind-corner branch *refusing*?" — it reads a `--dump`
  trajectory and counts blind-corner samples (labelled `hold`/`ARM*`) whose stillness run has
  already reached `auditWait`. It is what found the 2026-08-04 lockout: metronome refused 116 due
  re-tests, its longest unbroken run being 65, and four other cells 29 apiece. **Its columns
  changed meaning when `holdOrAudit` shipped** — a due clock now pre-empts the refractory hold, so
  the count is starvation probes outranking an ordered audit and no longer includes holds; read
  its docstring before comparing against a pre-2026-08-06 number.
- **The tier gate moves the law and the cadence together, and the 2×2 separates them.** Above
  4096 the climber switches steering law *and* sample period (10× maximum → 4×), so neither can be
  attributed alone. `harness.py` carries all four corners: `reactive` / `density` force a tier at
  every size, and `react4x` / `dens10x` are the cross arms (hit-rate law on the short cadence, and
  density law on the long one). The 2026-08-04 D2 study needed this — the dominant term flips with
  terrain, so a single `isDense` switch attributes a tier cliff to the wrong half.
- **`byworkload.py` counts workloads, not cells; `pair.py` compares seeds, not spreads.** Both
  encode a mistake that is easy to make with these corpora. Epoch slices of one trace are *not*
  independent evidence — six agreeing epochs are replication within one workload, and pooling them
  inflates the base of a reachability claim (D2's "8 movers" were 3 workloads until it was widened
  to 9). And a seeded sweep is not a repeated measurement of one basin: each seed is its own
  deterministic draw, so arms are compared **seed by seed** and an arm's own column spread says
  nothing about whether a difference is real (`phases_d050` spreads 12.9pp across eight seeds with
  the code held fixed).
- `lcs2lirs.py` projects a libCacheSim oracleGeneral trace to unit-weight LIRS epochs. The tier
  boundary is 4096 in the maximum's **native units**, so on a byte-weighted trace it means 4096
  *bytes*; projecting to unit weight is what makes such a trace usable at the density tier at all.
- **`run.py --seeds 1,2,..,8` runs one pass per admission seed** instead of `--runs` repeats, so a
  contested cell is adjudicated bit-for-bit rather than by draw counting. Before 2026-08-04 no
  committed tool accepted `-Dcaffeine.climber.seed`, and three workspaces had each hand-rolled
  their own; use this. It is what showed a −6.32 `slowswap_step`, a −2.60 `phases_d050` and a
  −0.59 `bandtrap2` were all basin draws (bit-identical on all eight seeds).
- `real.py` sweeps the real corpus (ten cloud-physics cells plus three ARC) and `floors.py` the
  thin-signal floor cells (w50@123038, S1/S2/S3, DS1@1051635) — the runnable form of the gate's
  `thin-signal floors` row, and the cost side of anything that touches the refractory or the
  probe machine. Both skip the frozen merge-gate holdout and `arc/P3`. **The ARC cells declare
  the `arc` reader**: they were `lirs` until 2026-08-04, which yields nothing silently, so every
  ARC row written before then was blank and the "real corpus 10/10 ties" bar on record is the ten
  cloud-physics cells alone.
- `marginal.py` answers "**where does a steering signal rest, versus
  where does the hit rate peak?**" — signal anatomy with no controller involved. Wire a worktree
  with `harness.py apply` (NEVER commit it: it adds region-attributed hit counters and an
  LRU-tail band to the *static-window anchor*, maintained by an O(1) midpoint marker), point
  `CAF_TREE` at it, and sweep. **The tail band catches only a small share of window hits**
  (~0.4% on `attack_whisper@8192`), so on a small or short cell it rounds to zero and the
  marginal error goes epsilon-driven: `cs@512` reads `ht=0`/`hq=0` at every window while
  `attack_whisper@8192` reads `ht=2009`/`hq=2.18M`. Confirm `ht`/`hq` are non-zero on the cell
  you are measuring before trusting a marginal number from it. It reports, per cell, the
  peak window and the zero-crossing of
  both the average-value error `ln((H_w/C_w)/(H_m/C_m))` — what the density arm steers on — and
  the marginal-value error `ln((H_tail/C_tail)/(H_prob/C_prob))`. This is the instrument that
  measured the density arm's give-back to its cause in 2026-08-02 (average rest point above the
  peak on 7/7 crossing cells, losing 0.71pp mean vs the marginal form's 0.09pp); `TAIL=<delta>`
  sweeps the band fraction to check an answer is not an artifact of it. Its window list stops at
  0.80 because that is the window's reachable ceiling (`increaseWindow` donates only the protected
  allocation), which is the right range for a rest-point question; set `WINDOWS=0.9,0.95,...` when
  the question is instead where the hit rate *peaks*, since six of twenty-one cells measured
  2026-08-08 peak above the ceiling and a sweep stopping at 0.80 reports the wrong peak for them.
- `admission_harness.py` + `admission.py` answer "**how often is an admission right, and how much
  does it earn when it is?**" — the measure taken from Merlin's Figure 20, which prices admission
  decisions directly instead of inferring their quality from the end hit rate. Same worktree
  convention (`admission_harness.py apply <worktree>`, never commit), then
  `CAF_TREE=<wt> admission.py <out.csv> <manifest>` sweeps static windows and reports, per region,
  `precision` (share of admissions ever hit) and `yield` (mean hits when hit). It exists because
  `density = precision x yield x (entries per capacity)` and the steering signal sees only the
  product: at `P3@152508`'s rest point the two regions look comparable by density (15.4 vs 12.3)
  while the window is right **1.1%** of the time for 1.03 hits against main's **59.2%** for 10.78 —
  a 1% window's turnover carries a region almost nothing is hit in. **Every row is
  conservation-checked** (window hits + main hits must equal the reported hit count) and a row that
  fails is refused, which is not decoration: the harness's first version dropped every
  protected-region hit and still printed plausible precisions.
  **Diagnostic only — do not re-derive equalization.** Precision- and yield-equalization were both
  checked against the peak on four cells: precision ratio spans 0.01–2.55 and yield ratio
  0.03–0.26, against density's 0.58–0.95.
- Noise: unseeded admission gives ±0.1–0.8pp run to run. Gate verdicts are coarse (an escape vs
  a ~28pp pin), so 1–2 runs suffice; take N≥5 before claiming anything under 2.5pp, and pair
  candidate-vs-reference arms in the same sweep (interleaved runs, append+resume CSVs) rather
  than comparing across sweeps.

## The gate (§3 families — the must-always-re-run set)

Generate (seed 7 is canonical; add `--seed 11`/`13` when a verdict is contested):

```
S=<scratch>; G=.claude/skills/climber-gate
python3 $G/gen.py mixture   --max 8192  --dfrac 0.10 --out $S/mixture_8192_d010.lirs
python3 $G/gen.py mixture   --max 8192  --dfrac 0.25 --out $S/mixture_8192_d025.lirs
python3 $G/gen.py mixture   --max 32768 --dfrac 0.25 --out $S/mixture_32768_d025.lirs
python3 $G/gen.py mixture   --max 8192  --dfrac 0.50 --out $S/mixture_8192_d050.lirs
python3 $G/gen.py mixture   --max 8192  --dfrac 0.50 --lengthmult 576 --out $S/mixture_8192_d050_long.lirs
python3 $G/gen.py mixture   --max 8192  --dfrac 0.10 --lengthmult 640 --out $S/mixture_8192_d010_long.lirs
python3 $G/gen.py mixture   --max 8192  --dfrac 0.25 --lengthmult 640 --out $S/mixture_8192_d025_long.lirs
python3 $G/gen.py mixture   --max 32768 --dfrac 0.25 --lengthmult 640 --out $S/mixture_32768_d025_long.lirs
python3 $G/gen.py phases    --max 8192  --dfrac 0.50 --out $S/phases_8192_d050.lirs
python3 $G/gen.py phases    --max 32768 --dfrac 0.50 --out $S/phases_32768_d050.lirs
python3 $G/gen.py deadphase --max 8192  --out $S/deadphase_8192.lirs
python3 $G/gen.py widepin   --max 8192  --out $S/widepin_8192.lirs
python3 $G/gen2.py straywall2 --max 8192  --dfrac 0.50 --out $S/straywall2_8192_d050.lirs
python3 $G/gen2.py straywall2 --max 16384 --dfrac 0.50 --out $S/straywall2_16384_d050.lirs
python3 $G/demoflood.py --max 8192 --out $S/demoflood_8192.lirs
python3 $G/gen_attacks.py $S          # trickle s7/s11/s13 + lowmix gate rows
python3 $G/blind_gen.py $S            # blind_balloonflip + blind_nullchurn gate rows (seed 41)
python3 $G/blind_gen.py $S v2         # blind_bandtrap2 gate row
(cd $S && python3 $G/whisper.py attack && python3 $G/whisper.py quarter)   # whisper gate rows
# F1-era rows (the goal-metric layer's own dose instruments and sentinels):
python3 $G/whisper_mod.py --amp 0.08 --period 12 --out $S/whisper_a0.08_p12.lirs
python3 $G/whisper_mod.py --amp 0.08 --period 6  --out $S/whisper_a0.08_p6.lirs
python3 $G/whisper_mod.py --amp 0.12 --period 12 --out $S/whisper_a0.12_p12.lirs
python3 $G/gen_adv.py mixmod --max 32768 --dfrac 0.25 --lengthmult 400 --amp 0.00 --out $S/mixmod_32768_a000.lirs
python3 $G/gen_adv.py mixmod --max 32768 --dfrac 0.25 --lengthmult 400 --amp 0.10 --period 6 --out $S/mixmod_32768_a010.lirs
python3 $G/gen_adv.py metronome --max 8192 --ratio 1 --out $S/metronome_8192_r1.lirs
python3 $G/gen_adv.py regimeramp --max 8192 --out $S/regimeramp_8192.lirs
python3 $G/escgen.py jam --max 8192 --out $S/esc_jam.lirs
python3 $G/a1_tenant.py --max 8192 --share 0.10 --dist 400 --out $S/tenant_s10.lirs
# Round-3 rows (the position-jam family; whisper base, dose-matched modulation):
python3 $G/gen_jam.py --mode flat --out $S/posjam_flat_8192.lirs
python3 $G/gen_jam.py --mode jam  --jitter 0.5 --out $S/jam_j50.lirs
python3 $G/gen_jam.py --mode jam  --period-req 81920 --out $S/jam_d25.lirs
python3 $G/gen_jam.py --mode jam  --out $S/jam_d0.lirs
# Round-2 instruments, promoted to rows by round 4 (the audit-amplification watch):
python3 $G/gen_adv.py shieldtrap --max 8192 --out $S/shieldtrap_8192.lirs
python3 $G/gen_adv.py shieldtrap --max 8192 --seed 11 --out $S/shieldtrap_s11.lirs
python3 $G/gen_adv.py shieldtrap --max 8192 --seed 13 --out $S/shieldtrap_s13.lirs
python3 $G/gen_adv.py loopcliff  --max 8192 --out $S/loopcliff_8192.lirs
python3 $G/gen_adv.py climbtrend --max 8192 --out $S/climbtrend_8192.lirs
python3 $G/gen_adv.py climbtrend --max 8192 --direction down --out $S/climbtrend_dn_8192.lirs
python3 $G/gen_adv.py climbtrend --max 8192 --hot-lo 0.55 --hot-hi 0.55 --modamp 0.12 --modperiod 40 --out $S/saw_p40.lirs
# adv3 rows (the walk-interior exit bar; whisper/mixture bases, amplitude-dosed):
python3 $G/crashnoise.py --shape flat --amp 0.00 --out $S/cn_flat.lirs
python3 $G/crashnoise.py --shape sine --amp 0.12 --period 12 --out $S/cn_sine_a12.lirs
python3 $G/mixnoise.py --max 8192 --shape flat --out $S/mn8_flat.lirs
python3 $G/mixnoise.py --max 8192 --shape sine --amp 0.10 --out $S/mn8_sine_a10.lirs
# crash-semantics rows (Terra H4-C1 pulse train + adv4 moat terrain; audit crash pricing):
python3 $G/gen_h4c1.py --phase 4 --order high-low --samples 260 --out $S/h4c1_p4_attack_long.lirs
python3 $G/gen_h4c1.py --phase 4 --order low-high --samples 260 --out $S/h4c1_p4_control_long.lirs
python3 $G/gen_moat.py --hotn 7800 --bandd 4000 --n 12000000 --out $S/moat_h7800_long.lirs
python3 $G/gen_moat.py --hotn 3000 --bandd 4000 --out $S/moat_h3000_b4000.lirs
python3 $G/gen_moat.py --hotn 4000 --bandd 4000 --out $S/moat_h4000_b4000.lirs
python3 $G/gen_moat.py --hotn 5000 --bandd 4000 --out $S/moat_h5000_b4000.lirs
# 2026-08-03 rows (the audit's room rule and the stale away-anchor claim):
python3 $G/slowswap.py --ramp 1  --p3 139 --out $S/slowswap_r1.lirs
python3 $G/slowswap.py --ramp 20 --p3 120 --out $S/slowswap_r20.lirs
# 2026-08-04 rows (the blind-corner lockout; one terrain, the rider flips only hasBlindCorner):
python3 $G/gen_blindlock.py --max 8192 --whisper 0     --out $S/blindlock_blind.lirs
python3 $G/gen_blindlock.py --max 8192 --whisper 0.004 --out $S/blindlock_sighted.lirs
# 2026-08-04 rows (the D2 tier straddle; run the PAIR at 4096 and 4097):
python3 $G/gen_straddle.py --max 4096 --period 8 --out $S/strad_p8.lirs
python3 $G/gen_straddle.py --max 4096 --period 8 --lo 0.325 --hi 0.325 --out $S/strad_stat.lirs
```

**Standing rule:** every adversarial round's attack instruments become gate rows in the same
change that lands its fix — an instrument without a row is not a regression test (round 4's
finding: the round-2 generators had no rows, so the round-3 fix was never measured against
them and shipped a −1..−2.1 give-back unmeasured).

Two kinds of rows: a **pass bar** must hold or the change is rejected; a **sentinel** is a
known-fail frontier cell whose bar is "no NEW drift beyond the recorded value ±noise". Recorded
values are the 2026-07-31 baseline at the full adversary-round stack — F1 streak confirm +
fresh-park shield, F3 calibration audit, the parkFreshLeft latch fix, round 2's
`auditBeatBase` gate, and round 3's audit-clock decay + audit-owned schedule, plus round 5's
audit-confirm zero-step and crash-cadence clock (2026-08-01; per-cell CSVs in the
local climber-adv2 workspace, the round-5 sweep as `*_confirmzero.csv`; rows
re-based by rounds 3/5 say so inline), plus the 2026-08-02 crash-semantics stack — per-layer
crash ledgers, crash-never-doubles-the-audit-clock, escalated time persistence with the
tolerated walk holding direction, and the bridge writes (local
climber-crash-semantics workspace, full-battery CSV `gate_esc.csv`; rows
re-based by it say so inline, and it added the h4c1 and moat rows). The adv3 round's records (the walk-interior bar
family, its candidate table, and the whisper_mod a0.12 re-base) are in the
local climber-adv3 workspace, with the same-day pricing study's screens, battery
(`gate_devprobecap.csv`), widepin draws, and spent-holdout scoring beside them; the rows
re-based by the starvation-probe pricing (mixnoise a10, metronome's trajectory signature)
say so inline. The round-2-era per-cell CSV is the local
climber-adversary workspace's `gate_final.csv`, with `gate_f3b.csv` /
`gate_f3.csv` / `gate_f1.csv` / `gate_f4.csv` / `gate_auditroom.csv` beside it as the earlier
records; the prior shipped-design record is the
climber-failure-modes workspace's `gate_v3dev_port.csv`. All values are on
these generators' instances; average-verdict ablation values are kept in parentheses where the
two verdict forms differ. **Bimodal families (widepin, phases, straywall2@8192's rare low draw, and
crashnoise_a12 — added 2026-08-02, previously recorded as deterministic on N=2)
adjudicate on an N=8 mean** — three separate rounds have now caught a single-run or N=3 "improvement" or
"regression" that was basin luck; when a bar fails on a code change, run the paired reference
binary before believing it.

**How a bar must be stated (2026-08-05 audit of all 52 rows, which found defects in 37).** Four
distinct defects had each been found by accident rather than by looking, so every row was
re-measured seeded at N=8 against the LRU/ceiling anchors. The rules that came out of it:

1. **A bar must be able to fail for the reason the row exists.** A level under LRU cannot —
   `trickle_s7`'s ≥66 sat 7.8pp below the do-nothing baseline, `blindlock_blind`'s ≥48 by 11.0,
   `phases_d050`'s ≥50 by 22.2. Where the machine clears LRU, state the bar **as** LRU
   ("above LRU on every seed") and record the measured margin.
2. **Where the machine is below LRU, an above-LRU bar is unreachable**, so bar the row against
   *itself*: "no drift below `mean − 2sd`", with the LRU gap stated in the same breath because
   that gap is the thing the row tracks. Do not leave a level that permits pp of silent decay
   (the old ≥48 on `mixture_d050` allowed 2.7 on top of an 8.3pp deficit).
3. **A bar inside the row's own seeded spread is a coin flip.** `moat_h7800`'s ≥45 sat inside
   draws of 44.32–46.23 and the row **fails it on 3 of 8 seeds today**; `crashnoise_a12`'s ≥61.2
   sat inside 60.75–63.63. Bimodal rows take a bar on the N=8 *mean*, never on a draw.
4. **Levels rot; margins do not.** Five recorded values no longer reproduced (`balloonflip`
   79.8 → **78.04**, and its recorded 79.5–83.0 range no longer contains the value at all;
   `mixture_d010` 61.9 → **63.00**; `regimeramp` 53.5 → **54.03**; `trickle_s11` 73.0 → 72.46;
   `mixture_d025@32k` 58.0 → 58.48). Prefer "above LRU", "within noise of the ceiling", or
   "no drift below X" over a bare number.
5. **Check the row has enough decisions to bar at all** — see the trace-length table below.

| Family | Cell | Recorded | Bar |
|---|---|---|---|
| corda + 5×loop + corda (bundled real) | 512..8192 incl. 4097 | near static ceiling | pass: no tier-boundary cliffs |
| mixture d010 | 8192 | **63.00 ± 0.02 at N=8** (2026-08-05 re-measure; the recorded 61.9 had rotted 1.1 low; LRU 59.83) | pass: **above LRU on every seed** (LRU 59.83; N=8 min 62.98, margin +3.15) — escaped |
| mixture d010 `--lengthmult 640` | 8192 | **63.58 ± 0.01 at N=8** (2026-08-05, 159 density samples against the parent's 47; LRU 59.85, ceiling 65.98 @10%, reactive 61.77) | pass: **above LRU on every seed** (margin +3.71 at the N=8 min). Steady-state companion to the 47-sample parent, which resolves only warmup. Trajectory **oscillates** between the optimum and a high excursion (window by sixth 25/15/44/15/43/44% against a 10% optimum) at a flat 63–65% hit rate, so the level error is real but costs little in-run |
| mixture d025 | 8192 | 59.67 ± 0.10 at N=6 (LRU 59.58 on the instance; was 60.5 pre-round-3) | pass: N≥6 MEAN above LRU — the margin sits at the noise floor (+0.09), so a single below-LRU run is noise, only a below-LRU mean is real, and a fall toward the ~35–40 floor pin is the unmistakable regression. The ~0.9 give-back is the calibration audit newly reaching the family (a starvation confirm no longer cancels it) and spending two failed-audit excursions on a 47-sample trace; don't "fix" it by re-suppressing the audit. **2026-08-05: this row prices warmup** — its final third reads 62.78 against LRU 59.58, so the noise-floor margin is a convergence artifact; the `--lengthmult 640` companion above is the quality number |
| mixture d025 `--lengthmult 640` | 8192 | **61.69 ± 0.01 at N=8** (2026-08-05, 159 samples; LRU 59.60, ceiling 65.85 @20%, reactive 61.24) | pass: **above LRU on every seed** (margin +2.07 at the N=8 min). **This row is why the parent's +0.09 margin is not a result**: the parent's whole-trace 59.67 is its own first third (59.83), and steady state is 62.5, i.e. +2.9 over LRU. Oscillates in a 51–68% band against a 20% optimum |
| mixture d050 | 8192 | 50.8 (2026-08-04 re-base of 34.7 by the blind-corner fix; seeded N=8 34.71 → 50.78, per-seed +16.01..+16.14; LRU 59.10, ceiling 64.17 @40%) | sentinel: **no drift below 50.4** (N=8 50.78 ± 0.02); **8.32pp below LRU 59.10**, so an above-LRU bar is unreachable and that gap is what the row tracks. The old ≥48 allowed a further 2.7pp of silent decay — the dip-length trace used to end before the ladder's ~round-3 escape, and the audit now escapes it instead. **The 8.3pp below LRU is warmup, not a pin** (2026-08-05): the final third reads 62.85 against LRU 59.10, i.e. **+3.75 above**, and the `--lengthmult 576` companion's steady state is 62–63. Read this row as convergence cost; a fall toward 34.7 means the blind-corner ordering regressed |
| mixture d050 `--lengthmult 576` | 8192 | 58.2 (2026-08-04 re-base of 52.9 by the same fix, +5.00; LRU 59.1) | sentinel: **no drift below 57.8** (N=8 58.18 ± 0.01); **0.95pp below LRU 59.13**. The old ≥56 allowed 2.2pp of silent decay — the ladder-escalation escape, now completed by the audit rather than by the ladder alone |
| mixture d025 | 32768 | 58.0 (parent reactive 56.4; LRU 59.9) | sentinel: **no drift below 58.1** (N=8 58.48 ± 0.01, re-based from the recorded 58.0); **1.37pp below LRU 59.85**. The old ≥55 allowed 3.5pp of silent decay — the F4-class flagship, closed: the room rule un-walled the first audit (31.2 → 39.3) and the cold-start calibration audit removed the pinned prefix (39.3 → 58.0, above the parent arm). The `--lengthmult 640` variant reaches 61.0 (parent 60.8) |
| mixture d025 `--lengthmult 640` | 32768 | **61.37 ± 0.00 at N=8** (2026-08-05, 159 samples; LRU 59.88, ceiling 65.77 @20%, reactive 60.89) | pass: **above LRU on every seed** (margin +1.48 at the N=8 min). The parent reads 1.37 *below* LRU and its final third reads 64.85, i.e. +5.0 *above* — the parent is a convergence-cost row |
| phases d050 | 8192 | 51.9–58.6 batch means, range 45.0–60.5 (N=8; the 58.6 batch is the round-3 clock at N=8) | sentinel: **no drift of the N=8 mean below 51.5** (N=8 57.17 ± 2.86, draws 50.14–60.08 — bimodal, adjudicate the mean, never a draw); **15.02pp below LRU 72.19**, and **this is the group's one genuine pin**: its final third still reads 64.16, 8.03pp under LRU, where every other short row reaches parity or better given the samples (2026-08-05 thirds sweep). The old mean ≥50 sat at the low draw — basin lottery; the earlier ≥55 bar was an N=3 high-draw calibration, restated 2026-07-31 against a paired reference build |
| phases d050 | 32768 | 47.9 mean (N=5) | sentinel: the sample-aligned defeat persists at this scale; cadence family, adjacent to F2/F3 |
| deadphase | 8192 | 49.1 ≈ ceiling | pass: at the ceiling (dead-scan exploration is ~free) |
| widepin | 8192 | **seeded (`--seeds 1,2,..,8`): 56.2 / 56.3 / 49.3 / 42.9 / 43.1 / 56.7 / 48.6 / 43.5, mean 49.58.** LRU 71.8. Re-derived 2026-08-05 over 24 unseeded runs: true mean **50.63 ± 5.25**, range 42.5–56.3, basins **12/24 high (>52) and 12/24 low — a 50/50 coin**, with N=8 batch means reading 52.04 / 49.52 / 50.34. The former record (52.4–54.9 batch means, bar "mean ≥50") was an unrepresentative high sample: reaching 52.4 needs 6+ high draws in 8, and the ≥50 bar sat **at the distribution's own mean**, so a random batch failed it about half the time and any verdict taken from it was a coin flip. **Adjudicate this family seeded only**, as `slowswap` already is | pass: **no per-seed drift below the recorded values −noise**, seeds 1–8, arms rotated inside each seed. Never an unseeded batch mean. Limits family softened by the marginal verdict and the anchor; the rest needs a lag-free signal |
| straywall2 d050 | 8192, 16384 | 55.1 attractor (2026-08-04 re-base by the blind-corner fix, +9.2 seeded N=8 from 45.89; battery N=4 reads 55.5; the pre-fix record was 46.1 with one 35.1 draw in 8) / **54.99 ± 0.21 @16384** (2026-08-07 seeded N=8 re-base from the stale pre-fix 45.7; draws 54.62–55.13; LRU 57.58, ceiling 64.70 @40%) | sentinel: **no drift below 54.8 on the attractor at 8192** (N=8 55.12 ± 0.15) and **below 54.5 at 16384**; **2.39 / 2.59pp below LRU 57.51 / 57.58** — the same audit-completed escape geometry at both sizes (floor start, ~50% window landing, 2 audits 1 confirm). The old ≥53 allowed 2.1pp of silent decay — the rung-scaled stride escape, now completed by the audit |
| blind_balloonflip | 8192 | **78.04 ± 0.14 at N=8** (2026-08-05 re-measure: the recorded 79.5–83.0 scatter / ~79.8 mean no longer contains the value, which is now **tight rather than scattered** (sd 0.14 across 8 seeds, range 77.85–78.30) — so the row's bimodality claim is rotted too and it has been dropped from the bimodal list above; treat the old range as rot, not as noise; LRU 52.1; **ceiling 86.57 @1% window, reactive arm 87.01** — the layer is 7–8pp behind BOTH, see below) | pass: far above LRU on an N=8 mean — but read that bar knowing it is 27pp slack: the 2026-08-04 anchor priced the real gap. The trajectory is the ε-asymmetry balloon (`hill-climber.md` §7) doing exactly what it is designed to do — 34 of 68 samples have main earning zero, the window balloons 7.3% → 80.2% in three samples and holds, mean window 40.8% against a 1% optimum, and the probe machinery does not recover it (1 probe, 2 audits, 0 confirms). Not a regression to chase; the cell that **prices** the zero-main prior, and the row to re-run if the ε-asymmetry is ever revisited — the family went spready (R4-F1 class), so the parkFreshLeft-latch signature (a fall to ~79.2 from a starvation confirm's stale shield inherited by an early veto park, recovered by the latch fix) is no longer readable from a single draw; the calibration audit itself costs ~nothing here |
| blind_nullchurn | 8192 | 2.48 ≈ LRU | pass: perpetual probing is harmless at equilibrium |
| blind_bandtrap2 | 8192 | 72.6 (ablation 69.1; LRU 76.5) | sentinel: **no drift below 71.5** (N=8 72.10 ± 0.31, re-based from the recorded 72.6); **4.43pp below LRU 76.53**. The old ≥70 allowed 2.1pp of silent decay — the B1 discard geometry is repaired |
| trickle (s7/s11/s13) | 8192 | 69.9–72.2 / 73.0 / 72.5–73.1 (ablation 56.1; LRU 73.8) | sentinel: **no per-seed drift below 68.0 (s7) / 72.2 (s11)** (N=8 70.70 ± 1.26, draws 69.40–73.03 / 72.46 ± 0.01); **3.09 / 1.35pp below LRU 73.79**, so the old ≥66 sat 7.8pp under the do-nothing baseline and could not fail for the reason the row exists — the F3 prize, captured |
| lowmix (s7/s11/s13) | 16384 | **s7 5.94** (2026-08-04 re-base by the blind-corner fix, +3.17 seeded N=8) / s11 2.89 / s13 2.94 — s11 and s13 not re-measured (pre-fix s7 2.75; round-3 re-base; pre-round-3 3.11 / 3.23 / 3.11; average-verdict ablation 6.94 / 2.03 / 6.96; LRU 7.55) | sentinel: the marginal verdict's NAMED TRADE — a bistable 2–7%-HR family where the frozen baseline false-vetoes an LRU-ward escape; bar = no drift below the recorded values −noise. The round-3 re-base is one calibration audit now reaching the family (decay clock + preserved schedule) and landing the bistable low basin — same excursion class as zigzag's −0.7 |
| demoflood | 8192 | 68.6 (2026-08-04 re-base by the blind-corner fix, +2.23 seeded N=8 from 66.36; LRU 16.7) | pass: **no drift below 68.0 with confirms** (N=8 68.58 ± 0.02; LRU 16.66, so an above-LRU bar is 52pp of slack and the row must be barred against itself). The old ≥66 allowed 2.5pp of silent decay — the freeze-earned construct; a fall toward ~59-with-zero-confirms means the frozen baseline broke (that is the live-adjudication pin) |
| whisper (attack) | 8192, 16384 | 66.8 / 66.6 (LRU 64.6) | pass: **above LRU on every seed** (LRU 64.57; N=8 66.78 ± 0.00, margin +2.21). The old ≥64 sat 0.57 *below* LRU and could not fail for the reason the row exists — the sharpest F4 repro, 0.17% of requests just above the starvation bar keeps the window "sighted" so no starvation probe arms; **owned and repaired by the equilibrium audit**, and the calibration audit removed its pinned prefix (64.1 → 66.8, now clear of LRU) — a fall toward the old 55.5 pin means the audit clock or its retry floor broke |
| whisper (quarter) | 8192 | 66.9 (LRU 64.5; average-verdict ablation 55.6) | pass: **above LRU on every seed** (LRU 64.48; N=8 66.82 ± 0.00, margin +2.33; the old ≥64 sat below LRU) — the same trace with the whisper dose below the bar: the probe arms and the marginal verdict confirms the escape the average form fails |
| whisper + modulation a0.08/p12 | 8192 | 65.3 (pre-streak 60.5; LRU 64.5) | pass: **above LRU on every seed** (LRU 64.50; N=8 65.15 ± 0.00, margin +0.64; the old ≥63 sat 1.5 below LRU) — the F1 dose repair: window-irrelevant ±8pp rate modulation must not turn the audit off; the streak confirm holds LRU parity through it |
| whisper + modulation a0.08/p6 | 8192 | 64.4 (crash-semantics re-base: escalated persistence owns −1.5 — post-crash audit retries tolerate the period-6 dips two samples longer and the retry cadence de-phases from the modulation; was 66.0 after the round-5 zero-step's −1.15; pre-streak 56.4; parent reactive 58.1) | sentinel: **no drift below 64.3** (N=8 64.48 ± 0.03), which is **LRU parity −0.06** (LRU 64.54). The old ≥58 allowed 6.5pp of silent decay — above the reactive arm inside the lag-limit band; the study's journaled trade row |
| whisper + modulation a0.12/p12 | 8192 | 64.0 (crash-semantics re-base of 62.2: escalated TIME persistence lets post-crash audit retries survive the dose and confirm; parent 64.7; LRU 64.4) | sentinel: **no drift below 63.7** (N=8 64.00 ± 0.12); **0.37pp below LRU 64.37**. The old ≥62 sat 2.4 under LRU and the −noise clause carried the row alone — formerly the AUDIT-side walk-interior sentinel (adv3 F1's open half), closed 2026-08-02: the depth-priced counterfactual's 66.75 remains unreachable without the holdout-fatal pricing trade (the R4-F1 dial), and the persistence heal banks +1.8 of it. Park retention remains the open thread for the w097 weather family, where audits DO confirm |
| mixmod a010 / a000 | 32768 | 56.6 dosed / 58.8 undosed | pass: dosed **above LRU on every seed** (LRU 55.32; N=8 56.61 ± 0.02, margin +1.25; the old ≥55 sat 0.3 below LRU) — the F1 dose instrument; a fall toward 48 means a deviation-priced confirm came back (the ~2pp dose cost is the modulation slowing the early escape, not the audit dying) |
| posjam flat / j50 / d25 | 8192 | 66.9 / 66.4 / 66.5 (LRU 64.9; ceiling 68.1; pre-round-3 the jams pinned at 56.0 = the audit-free value, −8.9 below LRU) | pass: **above LRU on every seed, all three** (LRU 64.93/64.90/64.93; N=8 66.92 ± 0.00 / 66.40 ± 0.01 / 66.53 ± 0.01, margins +1.99/+1.49/+1.59; the old ≥64 sat 0.9 below LRU) — the round-3 position-jam repair. j50 (±50% jitter) needs the audit-owned schedule; d25 (period 2.5) needs the decay clock; a fall toward 56 means one of them broke. flat is the dose-matched control |
| posjam d0 | 8192 | 56.08 ± 0.05 seeded N=8 (**reactive arm 65.37 ± 0.20** — the layer is 9.29pp behind the climber it replaced here, and below this cell's LRU 64.9 where the reactive arm is above it; the dose-matched flat control inverts, 66.92 ± 0.01 vs reactive 64.61 ± **10.71**, so the machine is better AND deterministic on the same traffic without the jam) | sentinel: the sample-aligned every-sample jam — starves even the decayed clock, needs ±¼-sample grid alignment (D4 exposure class); the standing "non-consecutive stillness" study, whose warrant is the 9.29pp above rather than a forgone increment; bar = no drift below 56 −noise. Class boundary, verified negative (don't re-derive): the analytic starvation bound is ≥½-motion, but 50%/67%-motion cadences (`--period 4 --duty 0.25` / `--period 3`) do NOT jam — audits arm and `noaudit` outscores the layer there (inert, not suppressed); every-sample motion is the only realizable regime |
| shieldtrap (s7/s11/s13) | 8192 | **78.84 ± 0.27 / 78.94 ± 0.22 / 78.62 ± 0.83 at N=8** (2026-08-05 re-base by the audit-bar split, +0.79/+1.75/+1.17 over the pre-split 78.06 ± 0.61 / 77.19 ± 0.80 / 77.44 ± 1.41; LRU 81.3; ceiling 83.1 @40%) | sentinel: **R4-F1, the audit-amplification give-back** — the round-3 clock repairs take audits 2 → 7-8 and the layer's run share 6% → 43% (park 32% + walk 12%) on a regime-alternating family already below LRU, with nothing confirming usefully, and turn a deterministic family bimodal. Bar = no drift below the recorded means −noise, N=8 mandatory. The calibration audit itself is worth +9.6 here (round 2), so the row does not say "fewer audits = better" — a change that recovers the give-back without re-opening the posjam rows is the welcome shape, and the audit-bar split is one: part of the give-back was `AUDIT_BAR_FRACTION` pricing the reversal below the noise, not only audit reachability. The prior entry recorded 77.9 / 78.9 / 79.0 from the 2026-08-04 re-base, above where the arm actually measured at N=8 on s11/s13 (77.19 / 77.44, reproduced in two independent sessions) — a stale bar of exactly the kind §8's process note names, so re-measure this row rather than trusting a recorded mean |
| saw_p40 | 8192 | 54.7 (round-5 re-base: the audit-confirm zero-step turns the fall-through-labeled confirms into clean parks, +0.56, crashes 3 → 0; pre-round-5 54.1 ± 0.03; pre-round-3 55.1; `noaudit` 55.5; LRU 48.7) | sentinel: R4-F1's deterministic instance — a 40-sample window-irrelevant wave on a floor-optimal base; the gap to `noaudit` is bounded audit-excursion duty. Criterion restated round 5 — the old "`confirms` must stay 0" was an exact-label artifact (the baseline already took 3 fall-through-labeled confirms): HR holds ≥54.1 −noise, and under the debug harness confirms stay a small parking band (~3–6, crashes 0) — a confirm explosion or a fall toward LRU means the misconfirm gate broke |
| loopcliff | 8192 | 98.3 (LRU = ceiling = 98.4) | pass: **no drift below 98.3** (N=8 98.36 ± 0.01), which is **LRU parity −0.06** on flat terrain (LRU = ceiling = 98.42) — the no-cliff invariant at the structural misconfirm landing (~⅓ of max; round 2 R9): W-TinyLFU serves the loops flat across every static window, so any material fall means a confirmed park manufactured a cliff that does not exist in the terrain |
| climbtrend up / down | 8192 | 55.29 ± 0.01 / 54.64 ± 0.05 (ceilings 55.4 / 55.6 @1%; LRU 49.4) | pass: **no drift below 55.0 (up) / 54.6 (down)**, both above LRU 49.4 on every seed (N=8 55.16 ± 0.03 / 54.80 ± 0.02). The old ≥54 carried ~1pp of slack on a row whose whole claim is that the mechanism costs ~nothing — the trend-driven misconfirm family: the mechanism fires (round 2 confirmed a 36% window on a +7pp trend) but must keep costing ~nothing; a fall toward LRU means trend confirms started parking wrong |
| crashnoise flat / sine a0.12 | 8192 | 66.8 (±0.03) / **BIMODAL 60.8 or 63.6**, high basin ~70–80% of draws (26/32 and 22/32 on two paired arms, 2026-08-02 — the row's "deterministic" record was an N=2 artifact; adjudicate on an N≥8 mean and read the basin count, never a single draw); crash-semantics re-base of 61.2–61.5; LRU 64.6 / 64.1; ceilings 67.7 @20% / 67.6 @30%) | flat: pass **above LRU on every seed** (LRU 64.57; N=8 66.78 ± 0.00, margin +2.21; the old ≥64 sat below LRU) — the dose-matched zero control. a12: pass **no drift of the N=8 mean below 62.3** (N=8 63.25 ± 0.94, draws 60.75–63.63; **0.80pp below LRU 64.05**, so above-LRU is unreachable). The old ≥61.2 sat *inside* the seed spread, so a single draw decided it — formerly the AUDIT-side walk-interior sentinel: the dose's scatter crossed the audit's absolute 5pp bar and killed audits mid-walk (−2.8 below LRU). Closed 2026-08-02 by escalated TIME persistence (the retry of a crashing equilibrium tolerates two below-bar samples, holding direction), which banks +2.1 of the depth-priced counterfactual's +5.4 without its holdout-fatal trade (the 66.93 audit-bar form was REJECTED at a fresh holdout — P8 basin-kill −2.5, w097 −1.1; the absolute DEPTH bar is load-bearing on real traces; don't re-run pricing variants, see `hill-climber.md` §7 for the dead-candidate journal) |
| mixnoise flat / sine a0.10 | 8192 | 59.8 / 60.7 (crash-semantics re-base of 59.4 / 59.8; LRU 54.8 / 55.1; ceilings 62.4 / 62.6 @20%; a10 was 51.6 before the probe-side pricing) | flat: pass **above LRU on every seed** (LRU 54.76; N=8 59.76 ± 0.01, margin +4.99). a10: pass **above LRU on every seed and no drift below 60.4** (LRU 55.06; N=8 60.70 ± 0.02, margin +5.61; the old ≥58 carried 2.7pp of slack) — **the probe-side walk-interior pricing's prize row** (adv3 study): the dose's wave crash-cycled every starvation up-probe one stride off the floor (arm → crash → 16/32-sample hold → repeat), severing the mixture trap's only escape; the priced-capped bar walks through the weather and the escape confirms by sample ~5. A fall toward 51.6 means the probe bar's pricing or its 3×RESTART cap broke. This row killed every escalated-DEPTH audit-bar candidate (escbar −2.48, intrinsic); TIME persistence instead lifts it +0.9 |
| h4c1 attack / reverse | 8192 | 66.4 / 65.5 (LRU 64.56; ceiling 67.77 @40%; pre-fix the attack pinned at 58.55, −6.0 below LRU, the reverse control at 65.41) | pass: **above LRU on every seed, both arms** (LRU 64.56 both; N=8 66.36 ± 0.00 / 65.54 ± 0.00, margins +1.79/+0.97; the old ≥64.5 sat 0.06 *below* LRU, i.e. at it) — **the H4-C1 crash-ratchet repair** (Terra's round, 2026-08-02). Three token-multiset-preserving high→low pulses each killed one audit walk; the shared crash streak adjudicated crashes 2–3 as failures (rung 16→32→64) and the deepest-rung branch doubled the wait to 128 — a 130-sample floor pin. The fix: per-layer crash ledgers, crash-never-doubles-the-clock, and escalated time persistence absorbing the 1-sample pulses. The reverse order is the dose-matched control; contest a verdict with the full 5-phase × 2-order lattice (`gen_h4c1.py --phase 3..7 --order high-low\|low-high`, 4M short form) — pre-fix the machine trapped 5 of 10 arms at ~55.5, post-fix the worst arm is 63.2. A fall toward 58.5 with `auditWait` ratcheting past the ladder in the trajectory means the crash/failure distinction or the ledger separation broke |
| moat h7800 / h3000 | 8192 | **45.28 ± 0.93 at N=8, draws 44.32–46.23** (2026-08-06 seeded re-base; the recorded 46.2 was an **N=2 unseeded** reading near the top of the distribution, which is what put the old ≥45 bar inside the spread; 12M requests; LRU 37.92; ceiling 49.58 @40%; `noaudit` 43.16; pre-fix 41.97 with 0% of 366 samples in the prize band and `auditWait` decaying to 256) / 58.7 ± 0.9 (LRU 56.42) | h7800: pass **above LRU on every seed** (LRU 37.95; N=8 45.28 ± 0.93, draws 44.32–46.23, margin +6.37) **and above `noaudit` 43.16**. The old ≥45 sat *inside* the seed spread and the row fails it on 3 of 8 seeds today — a bar nobody noticed was already red — **F1-adv4, the terrain moat**: a hit-rate valley deeper than the audit's 5pp bar between the density rest and the prize was absorbing at every rung (the abort fired at the −bar contour, one stride short of the far bank); the crash-streak retry's two-sample tolerance crosses it and parks in the prize band. h3000: pass ≥55 — the dose-matched zero control (identical traffic, monotone approach; the audit layer is worth +13 here), a fall means the escapes the layer already makes broke. Real-corpus static scan: 0/22 cells show moat terrain (constructed-only); mid-dose h6500 pays +0.2 vs pre-fix — journaled, not rowed |
| moat h4000 / h5000 | 8192 | **57.91 ± 0.05 / 57.77 ± 0.17** (N=8 unseeded; LRU 51.14 / 46.53, ceiling 62.46 @40% / 62.03 @30%). Rowed 2026-08-09; h5000 was journaled at **−2.0 vs pre-fix** by the crash-semantics round, which is the drift this row now watches | pass **above LRU** on both (+6.77 / +11.24). These are the **guard rail's only behavioral coverage**: the rail is the sole mechanism that recovers the window at these doses (§7's attribution entry: removal costs +2.44 / +3.36, 8 of 8 seeds), and it is measured firing here — 1 veto per cell at seed 7, against **0 on the deep `moat_h7800`** and 4 across the other 56 cells combined. Rowed because an adversarial audit re-derived "the rail has no coverage" from the three-cell JUnit subset; the gap was never coverage of the *mechanism* but of the *doses where it pays*. A fall means the rail stopped engaging |
| slowswap step / ramp | 8192 | seeded (`-Dcaffeine.climber.seed=1..8`): **r1** 40.34/40.27/40.22/**40.85**/40.59/40.13/40.60/40.44 (LRU 36.79, ceiling 43.12 @50%, `noaudit` 27.6; `staleclaim` seed 4 = 29.21, `flatroom` seed 4 = 27.32); **r20** 42.14–42.24 on all eight (LRU 36.53) | **pass ≥40 on every seed, both arms** (above LRU 36.79/36.53; N=8 40.43 ± 0.23, draws 40.12–40.88 / 42.19 ± 0.04). **The step arm's bar sits 0.12 under its own lowest draw, inside one sd** — a single red here is one draw's worth, so re-run at N=8 before believing it, and treat a mean below 40.2 as the real signal.** r1 is the stale-away-anchor sentinel, closed 2026-08-03: a regime step discards the anchor, and before the fix the goal metric smoothed across the shift, so the claim re-planted from it was ~80% the old regime's rate and froze the moment density steered away — on seed 4 the audit walk reached the ceiling, earned +35pp for fourteen samples and was rejected against a 0.4415 bar, landing on the audit-free value (27.6 pre-room-rule, 9.5pp below LRU; 29.21 with the room rule fixed, 7.6 below). A drift toward 29 on seed 4 means the discarding stand-down stopped re-seeding `Rates`, and toward 27.3 means the rung-scaled room rule broke with it (that is what the two A/B arms separate). r20 is the dose-matched control (same shares, reuse distances and request count; only the transition length differs) and is deterministic, so any spread there means the trap leaked into the control — it is also the row that killed symmetric claim aging, which reads 30.3 on every seed. Adjudicate this family **seeded only**: unseeded it is bimodal on which draw lands in the trap |
| cp_w097 (real, cloud-physics corpus) | 16384 | 46.9 ± 1.9 at N=8 (the cell has ~2pp run-to-run variance — adjudicate on an N≥8 mean, single runs read 45.5–47.3; round-3 fix vs pre-fix is +0.47, unresolvable; pre-streak 43.8; parent 50.1; best static 50.9 @10% window) | sentinel: the density arm's setpoint family — no drift below 45 on an N≥8 mean; the robust signal here is the audit layer's own worth, +3.3 vs `noaudit` (43.59 ± 0.04). Skip and say so when the corpus is absent |
| metronome r1 | 8192 | 40.0–40.2 (re-based 2026-08-04 from 40.3–40.6 by the blind-corner audit: the run trades 14 probes for 4 probes + 4 audits and the window roams further, mean 3.6% → 15.0%, which is bounded excursion duty on flat terrain rather than the wedge this row guards); window at/above the 2% floor after the first refractory hold | sentinel: the all-blind wedge class — a run stuck at 1% of maximum means the hold's below-floor lift broke. Under the priced-capped probe bar the window roams more than it used to (@floor ~92% → ~14%, mean ~10%) at a tied hit rate — roaming here is not a regression (flat terrain; the cap is what re-aborts deep damage; uncapped pricing measured −0.6) |
| esc_jam | 8192 | 24.9 | sentinel: rate-swing jam family with the fresh-park shield and calibration audit present — must tie the pre-F1 value |
| regimeramp | 8192 | **54.03 ± 0.01 at N=8** (2026-08-05 re-measure; the recorded 53.5 had rotted 0.5 low; pre-calibration 54.8; LRU 50.11; ceiling 55.9) | sentinel: **no drift below 54.0**, above LRU 50.11 on every seed — the calibration audit's priced cost (~−1.3 after round 2's `auditBeatBase` gate recovered +0.6 of it) — a steady rise clears any raw streak, so the early confirm can park wrong for ~a shield before the next audit re-tracks; a fall toward 48 means the park stopped releasing (the persistence failure class). Also the behavioral sentinel for the cold-start misconfirm class: its stationary variant is pinned by the two `auditBeatBase` unit tests (the archived round-2 `flatctl`/`coldstart` instances are workspace-only; a discriminating stationary generator was attempted and measured inert — adversary-ledger row 27) |
| tenant_s10 | 8192 | 92.6 | sentinel: co-tenant class — must tie the pre-F1 value |
| blindlock blind / sighted | 8192 | 50.7 / 55.9 (LRU 59.05 / 58.97; ceiling 64.15 / 63.93, both @40%; pre-fix the blind arm read **34.9**) | sentinel: blind **no drift below 50.2** (N=8 50.79 ± 0.24); **8.26pp below LRU 59.05**, so an above-LRU bar is unreachable. The old ≥48 allowed 2.6pp of silent decay — **the blind-corner lockout row** (2026-08-04). One terrain; the arms differ only by a window-irrelevant whisper rider (0.28% of requests) that lifts the window's sample hits over the starvation bar, so `hasBlindCorner()` is false on the sighted arm. `densityClimb` ranked the blind-corner branch above `auditClock.isDue()`, and `refractoryLeft` is armed by every `undoProbe` but decremented only in `holdInRefractory`, so a corner that never clears served its whole 16/32/64-sample backoff motionless while the clock was permanently due. **Check the anchors before the arms**: the rider replaces a token rather than inserting one, so the terrains match to ~0.1pp rather than exactly, and that match is what makes the ~5pp arm gap attributable to the router. A fall toward 34.9 with the sighted arm unmoved means the ordering regressed. **The lockout is a convergence cost, and no long companion is kept** (2026-08-05): at `--lengthmult 640` the arms converge to the *same* rest, final thirds 62.13 blind against 61.74 sighted — the gap reverses and lands inside noise, and the blind arm reaches LRU parity (58.59 against 59.11). Both long instances were generated and measured, then dropped rather than added, since a row whose phenomenon dissolves has been retired rather than improved. The short pair keeps the phenomenon and is the instrument. Run it with `floors.py` — the fix's cost side is the thin-signal floors |
| strad_p8 @4096 / @4097 | 4096, 4097 | 82.4 / **74.8** (LRU 82.21 both; ceiling 86.39 / 86.42) | sentinel: **the D2 tier cliff, open** — one entry changes the answer by −7.58pp while the terrain does not move. Both pure laws are continuous across the boundary (`reactive` 82.41 → 82.42, `density` 74.79 → 74.83) and LRU steps 0.00, so the discontinuity is the policy switch, not capacity. The `strad_stat` arm is the dose-matched stationary control (+0.69: the alternation is load-bearing). Bar = no drift beyond the recorded values ±noise; **a fix must move the pair together**. Note the gate's `corda + 5×loop + corda` row already claims "no tier-boundary cliffs" and passes while this exists — it is not a sufficient instrument |
| thin-signal floors (real: w50@123038, S1/S2/S3, DS1) | local corpus | per-cell references (2026-08-07 gate run, N=3, spreads ≤0.13): **w50@123038 48.51, S1 5.16, S2 7.23, S3 7.15, DS1@1051635 14.24**. w50's old 59.85 is **dead** — the 08-07 read is the fourth independent 48.5 (after two `floors.py` sweeps and a separate study on 2026-08-04); it was likely taken at another size or artifact. The study-era re-base was attributed to the refractory-hold floor lift (−0.5pp, the enforced 2% floor's documented price; siblings unmoved) | pass: within noise of the per-cell references |

### Trace length: how many decisions a row actually contains (2026-08-05 audit)

The density sample period is `4 × maximum`, so a row's *length in requests* sets how many
decisions the climber gets. One audit cycle is `AUDIT_WAIT_INITIAL` 32 plus a walk of up to 17,
about **49 samples**, so a trace under ~50 samples can hold **at most one** — its number prices
convergence, not steady-state quality, and re-barring it just re-prices warmup more precisely.
Measured per row (min over 8 seeds, counted from the harness trace):

| Density samples | Rows | Reading |
|---|---|---|
| **7** | `resphase_k1_s7` | **Cannot be lengthened without a generator change** (2026-08-05): `gen_attacks.py` hardcodes `gen_resphase(8192, 1, 4, seed)` and exposes no flag, and `gen_zigzag`/`gen_trickle`/`gen_lowmix` have no length concept at all. Seven decisions cannot contain one audit cycle, so its −21.31 against LRU prices trace length rather than the machine, and its final third is still ascending. Exposing `length_mult` is a generator revision that re-bases the whole `gen_attacks` family |
| **159** | `mixture_d010_long`, `mixture_d025_long`, `mixture_d025@32k_long` | Added 2026-08-05 at `--lengthmult 640` as steady-state companions; the short parents are kept, since a short instance can test a transient the long one washes out |
| 39–49 | `zigzag_s7` 39; `mixture_d010`/`d025`/`d025@32k`/`d050`, `phases_d050`, `deadphase`, `blindlock_blind`/`sighted` 47; `widepin`, `trickle_s7`/`s11`, `lowmix_s7`, `nullchurn`, `tenant_s10` 49 | One audit cycle at most. Read these as convergence-cost rows; a bar on the whole-trace mean here is a bar on warmup. `widepin` is the worked example — it ends at 77.9% against an 80% optimum and pays its whole −22 deficit getting there |
| 63–99 | `straywall2` 63, `balloonflip` 68, `demoflood` 79, `mixnoise_*`/`mixmod_a010` 99 | Two cycles; usable for steady state with the caveat stated |
| 122+ | everything else (`slowswap_*` and `moat_h7800` reach 303/366) | Steady state resolved |

Regenerating a short row changes its recorded value, so do it as its own step with a re-base, not
inside another change's gate run.

**What the short rows were actually measuring (2026-08-05 thirds sweep, seeds 1–3).** Every target
was split into thirds and its final third compared against LRU. **Twelve of fifteen were pricing
warmup**, and the reversals are large enough to change what the row appears to say:

| row | recorded (whole trace) | final third | vs LRU, whole → final | reading |
|---|---|---|---|---|
| `mixture_d050` | 50.78 | **62.85** | −8.35 → **+3.75** | warmup |
| `blindlock_blind` | 50.79 | **62.82** | −8.39 → **+3.77** | warmup |
| `mixture_d025@32k` | 58.48 | **64.85** | −1.39 → **+5.00** | warmup |
| `blindlock_sighted` | 55.87 | 62.75 | −3.12 → +3.78 | warmup |
| `widepin` | 49.58 | 68.12 | −28.86 → −3.68 | warmup (converges to 77.9% against an 80% optimum) |
| `trickle_s7` / `s11` | 70.70 / 72.46 | 76.22 / 75.71 | −4.39 / −1.35 → **+2.43 / +1.90** | warmup |
| `zigzag_s7` | 83.60 | 87.67 | −4.13 → −0.04 | warmup, reaches parity |
| `lowmix_s7` | 5.95 | 7.58 | −1.61 → +0.03 | warmup, reaches parity |
| `mixture_d025` | 59.67 | 62.78 | +0.09 → **+3.20** | warmup |
| `mixture_d010` | 63.00 | 65.57 | +3.15 → +5.74 | converges *to* the optimum (15.4% against 10%) |
| `deadphase`, `tenant_s10` | 49.16 / 92.75 | 49.25 / 93.15 | flat | converged, nothing hidden |
| **`phases_d050`** | 57.17 | **64.16** | −22.05 → **−8.03** | **the one genuine pin in the group** |
| `resphase_k1_s7` | 56.73 | 61.53 | −21.31 → −16.36 | **unclassifiable** — 7 samples, still ascending when the trace ends |

So the group hid exactly one `bandtrap2`-shaped pin (`phases_d050`) and one row that cannot be
read at all (`resphase_k1_s7`). Everything else pays its deficit getting there. **Read a
below-LRU number on any 39–49-sample row as convergence cost until its final third says
otherwise.**

### The reactive anchor (is the machine earning its complexity, per row)

Paired `hybrid,reactive` runs at the table's per-cell N, arms rotated inside each run
(`gate.py <traces> hybrid,reactive out.csv` in a harness worktree). Positive Δ = the density
machine ahead of the hit-rate law it replaced. Refresh on a generator revision or a
shared-climber-state change, not on every gate run — see the Harness section for why this is an
anchor rather than an ablation.

| Cell | N | hybrid | reactive | Δ |
|---|---|---|---|---|
| `zigzag_s7` | 2 | 83.59 | 55.46 | **+28.13** |
| `straywall2` | 4 | 55.16 | 37.69 | **+17.47** |
| `trickle_s11` | 2 | 72.47 | 57.40 | **+15.07** |
| `slowswap_ramp` | 2 | 42.14 | 28.89 | **+13.25** |
| `slowswap_step` | 4 | 40.36 | 31.06 | **+9.30** |
| `widepin` | 8 | 52.36 | 43.85 | **+8.51** |
| `moat_h3000` | 2 | 59.34 | 52.73 | **+6.61** |
| `phases_d050` | 8 | 52.55 | 46.96 | **+5.59** |
| `demoflood` | 2 | 68.58 | 63.25 | **+5.33** |
| `whisper_mod_p6` | 2 | 64.49 | 59.42 | **+5.07** |
| `blindlock_sighted` | 2 | 55.86 | 50.95 | **+4.91** |
| `mixture_d010` | 2 | 63.00 | 58.39 | **+4.61** |
| `mixnoise_flat` | 2 | 59.77 | 56.08 | **+3.69** |
| `mixnoise_a10` | 2 | 60.69 | 57.03 | **+3.66** |
| `bandtrap2` | 2 | 71.81 | 68.20 | **+3.61** |
| `mixture_d025` | 6 | 59.67 | 56.32 | **+3.35** |
| `resphase_k1_s7` | 2 | 56.63 | 54.13 | **+2.50** |
| `mixture_d025@32k` | 2 | 58.48 | 56.53 | **+1.95** |
| `tenant_s10` | 2 | 92.70 | 91.02 | **+1.68** |
| `posjam_j50` | 2 | 66.44 | 64.83 | **+1.61** |
| `rungflip_s7` | 2 | 98.79 | 97.52 | **+1.27** |
| `posjam_flat` | 2 | 66.92 | 65.83 | **+1.09** |
| `lowmix_s7` | 4 | 5.38 | 4.32 | **+1.06** |
| `climbtrend_up` | 3 | 55.18 | 54.20 | +0.98 |
| `saw_p40` | 5 | 54.68 | 53.74 | +0.94 |
| `whisper` | 2 | 66.78 | 66.04 | +0.74 |
| `crashnoise_flat` | 2 | 66.78 | 66.04 | +0.74 |
| `whisper_mod_p12` | 2 | 65.15 | 64.44 | +0.71 |
| `crashnoise_a12` | 2 | 63.59 | 62.96 | +0.63 |
| `whisper_quarter` | 2 | 66.82 | 66.21 | +0.61 |
| `metronome` | 2 | 40.17 | 39.73 | +0.44 |
| `posjam_d25` | 2 | 66.53 | 66.33 | +0.20 |
| `nullchurn` | 2 | 2.49 | 2.49 | +0.00 |
| `mixture_d050_long` | 2 | 58.21 | 58.23 | −0.02 |
| `blindlock_blind` | 2 | 51.03 | 51.05 | −0.02 |
| `loopcliff` | 2 | 98.35 | 98.37 | −0.02 |
| `esc_jam` | 2 | 24.88 | 24.91 | −0.03 |
| `mixture_d050` | 2 | 50.80 | 51.15 | −0.35 |
| `deadphase` | 2 | 49.16 | 49.68 | −0.52 |
| `regimeramp` | 3 | 54.02 | 54.55 | −0.53 |
| `whisper_mod_a12` | 2 | 64.11 | 64.71 | −0.60 |
| `h4c1_attack` | 2 | 66.35 | 66.96 | −0.61 |
| `trickle_s7` | 2 | 70.56 | 71.20 | −0.64 |
| `climbtrend_dn` | 3 | 54.83 | 55.56 | −0.73 |
| `h4c1_reverse` | 2 | 65.54 | 66.70 | **−1.16** |
| `shieldtrap_s7` | 8 | 77.58 | 78.94 | **−1.36** |
| `shieldtrap_s11` | 8 | 77.26 | 78.73 | **−1.47** |
| `mixmod_a010` | 2 | 56.62 | 59.00 | **−2.38** |
| `shieldtrap_s13` | 8 | 76.43 | 79.61 | **−3.18** |
| `balloonflip` | 8 | 79.36 | 86.42 | **−7.06** |
| `posjam_d0` | 2 | 56.05 | 65.35 | **−9.30** |
| `moat_h7800` | | | | not run — 12M-request instance omitted from this sweep |

**The reactive arm is ahead on 18 of the 51 rows, and the machine is worth under a point on 28
of 51.** On six rows the reactive arm's margin exceeds a point:

- `posjam_d0` **−9.30**. The aligned position jam is a density-specific failure the hit-rate law
  does not have — the reactive arm reads 65.35, *above* this cell's LRU (64.9), where the machine
  sits at its audit-free value. §11's framing ("the cost is the audit layer's value on the
  affected shape") understates it: the machine is 9pp behind the law it replaced here, not merely
  missing an increment.
- `balloonflip` **−7.06** at N=8. The recorded bar is "far above LRU on an N=8 mean" (LRU 52.1),
  which both arms clear comfortably — and which is exactly how an LRU-only bar hides a 7-point
  regression against the incumbent.
- The whole `shieldtrap` family, **−1.36 / −1.47 / −3.18** at N=8 on all three seeds. This is the
  R4-F1 audit-amplification give-back the table already flags; against the reactive arm it is not
  a give-back off a win, it is a net loss.
- `mixmod_a010` **−2.38**, the F1 dose instrument, and `h4c1_reverse` **−1.16** — the
  dose-matched *control* of the crash-ratchet pair, where the attack arm is −0.61. Both h4c1 rows
  favour the reactive law, so that family's bar ("≥64.5 both, above LRU") is satisfied by the
  climber the machine replaced.

Read the rest with three cautions. **(1) Near-parity is the common case.** Ten more rows sit
within +1pp, so on 28 of 51 the machine is worth under a point. Its job on those families is to
*recover* to parity, which is a weaker claim than "the trap is defended". **(2) Where Δ is large
it is sometimes a spread, not a level.** The reactive arm is bimodal on `straywall2` (±19.8
across three seeds) and `demoflood` (±9.9) where `hybrid` holds ±0.03 and ±0.05; a single draw on
either reads near-parity and is wrong. That variance reduction is real value and is invisible at
N=1. **(3) The two-run rows are two runs.** Treat anything under ~2.5pp on an N=2 row as
unresolved — `mixmod_a010` and `posjam_d0` in particular deserve N=8 before being acted on.

Where the machine is unambiguously earning it: `zigzag_s7` +28.13, `straywall2` +17.47,
`trickle_s11` +15.07, `slowswap_step` +9.30 and `slowswap_ramp` +13.25, `widepin` +8.51,
`moat_h3000` +6.61, `phases_d050` +5.59. Those eight rows are the load-bearing evidence for the
density tier on this battery, and any weaning-down exercise should start by asking which
mechanism each of them needs.

This sweep independently caught two stale bars: `mixture_d050` reading 50.80 against a recorded
34.7 sentinel and `mixture_d050_long` 58.21 against 52.9, with `mixture_d025` reproducing at 59.67
exactly on the same build. **Resolved — the second hypothesis was right**: both are the
2026-08-04 blind-corner fix's two largest gains (+16.07 seeded at N=8, and +5.00), landed without
re-basing the rows they moved. Both rows are corrected above. The generalizable lesson is the one
that made this detectable: a *third anchor* catches a stale bar that a pass/fail threshold cannot,
because the threshold was satisfied the whole time.

Bundled real traces live in the simulator resources under
`simulator/src/main/resources/com/github/benmanes/caffeine/cache/simulator/parser/` —
`corda:.../corda/trace_vaultservice_large.gz` and `lirs:.../lirs/loop.trace.gz`. The thin-signal
floor traces come from the local research corpus (`~/Documents/traces`,
`~/projects/merlin-traces`); when that corpus is absent, skip the row and say so in the report.

Instance caveat: the fable-era archive (the local hill-climber-fable workspace's
adversarial instances) holds trap instances from an older generator revision; `mixture_8192_*` regenerate
bit-identically but `phases_*` and `mixture_32768_*` do not, and the study's phases record (~66)
attaches to the archived unaligned instance. This table's values are for the CURRENT generators —
the canonical, reproducible gate.

## Frontier sentinels (regression watch, not pass bars)

The 2026-07 study's open findings each have a deterministic repro. When touching probe or verdict
logic, re-run the relevant ones and compare against the study's recorded values (raw record: the
local hill-climber-study workspace; narrative: the committed
`.claude/docs/adaptive-window.html`; the retired research record is archived in the
local climber-failure-modes workspace):

```
python3 $G/gen_attacks.py $S          # resphase/rungflip/zigzag + weighted, seeds 7,11,13
python3 $G/blind_gen.py $S            # blind bandtrap/balloonflip/scrambler/nullchurn, seed 41
python3 $G/gen.py mixture --max 65536 --dfrac 0.25 --lengthmult 400 --out $S/mixture_65536_d025_long.lirs   # F4
```

- `resphase_k1_s7` holds **7 density samples** and `zigzag_s7` 39 (2026-08-05 audit): both are
  too short to contain an audit cycle, so their recorded values price convergence. Regenerate
  with `--lengthmult` and re-base before reading either as a quality number. `zigzag_s7` has also
  drifted 83.2 → **83.60 ± 0.02** at N=8.
- `zigzag`/`resphase`/`rungflip@8192` — cadence attacks (clean; identical under both
  verdict forms; zigzag re-based 83.9 → 83.2 by the calibration audit's early excursion,
  N=5-verified); `blind_scrambler@8192` — B2 walk-interior exit (53.80 both arms; 53.79 re-verified after
  the adv3 probe-side pricing, which does not move it — the remaining exposure is the
  AUDIT-side bar, `hill-climber.md` §7);
  `mixture_65536` long — the F4 sighted false equilibrium, now the audit-escape row
  (31.95 pre-audit with zero probes → 39.6–40.0 with the equilibrium audit → 51.7 with the
  audit-direction room rule → **60.2 at the round-3 clock stack**, the round-5 re-measure:
  the escape completes to LRU-60.0 parity — the bar is "the escape holds at ~LRU, no drift
  back toward 32"; the first REAL-trace candidate remains msr proj3@1M/@4M from the holdout-3
  gate, uncharacterized). Former residents `trickle`, `bandtrap2`, and `lowmix` moved into
  the gate table above with the marginal verdict; `whisper` moved there with the audit.
- **`P3@152508` and `fiu_webmail@195466` — the non-convex window response (2026-08-08).** Two REAL
  cells, not generated, from the Merlin matrix: the hit rate dips as the window grows off 1% and
  only pays past 40%, and the density law's error crosses zero on the near side of that trough.
  Screen a steering candidate on the **rest point**, not the hit rate — `marginal.py` reports it
  directly, and the shipped law's recorded values are `P3` **rest w1.4 against a w80 peak, 3.59pp
  lost** and `fiu_webmail` **rest w6.9 against w90, 4.55pp**. `OLTP@8192` is the paired control and
  the reason those two are readable: it is unimodal and the same law rests there for **0.00pp**, so
  a candidate that degrades it is trading, not fixing. Recorded for `ln(d_tail/d_prob)`: 1.76 /
  0.75 residual-to-Merlin on the two, 0.25pp cost on the control. Do not screen these on the audit
  or probe layers — the equilibrium audit is measured **inert** on this class (+0.054pp over 22
  cells, `hill-climber.md` §7).
- These are accepted residue: the bar is "no NEW regression beyond the recorded values", not zero.

Weighted traps (`.lcs.csv`, simulator format `lcs-trace`): use the byte capacity the generator
prints as `maximum-size`, and read the `Weighted Hit Rate` column of the CSV report (same
`simulator:run` invocation; no separate task needed).

## Reporting

Emit a per-cell table — family, cell, cache HR, LRU, ceiling, gap, verdict — and call out any
gate row that fails its criterion with the trajectory summary from `probe.py`. The design context
for interpreting a failure is `.claude/docs/hill-climber.md` (§3 for the family's mechanism, §4
for the machine that must defeat it).