Climber Step Minimization

Climber minimization

The other climber skills ask whether a change is good. This one asks whether a step should exist. It removes one algorithmic step at a time and reports what the machine loses, so a mechanism that has stopped paying for itself can be found rather than waited for.

It exists because the machine grows by repair. Every round adds a rule that fixes a workload, and nothing in the process asks the older rules to re-justify themselves. Two things follow, and both have been observed: a step's recorded price goes stale as later repairs change the terrain it acted on (the guard rail's veto was 11:1 in 2026-08-18 and 1.86:1 on that same cell set in 2026-08-23), and a step can become inert without anyone noticing, because nothing fails when a branch stops mattering.

Its usual output is "priced, kept", not a deletion. Pricing a mechanism is the point; removing one is the rare case. Run it before a release, or after the machine has taken several repairs in a row.

How to run

The arms live in climber-gate/harness.py, so a wired worktree is required:

git worktree add --detach <wt> <commit>
python3 .claude/skills/climber-gate/harness.py apply <wt>
CAF_TREE=<wt> python3 ablate.py <traces-dir> all quick 1 data/quick.csv       # smoke, ~130 runs
CAF_TREE=<wt> python3 ablate.py <traces-dir> all standard 1,2 data/std.csv    # the decision pass
CAF_TREE=<wt> python3 ablate.py <traces-dir> all full 1,2 data/full.csv       # hours

standard is the preset a keep-or-prune decision needs: the constructed families plus the whole real corpus. Traces come from climber-gate/SKILL.md's generation block. Arms are rotated inside each seed, so every arm sees the same machine state and the same admission draws.

The arms

Each is a single disable at the step's own site. noaudit and the tier arms predate this skill; most of the rest were wired 2026-08-18, noreturncover and nowidecover in 2026-08.

Add an arm whenever a step lands: a rule that arrives without one cannot be re-priced later, which is how the set decayed to two before 2026-08-18. harness.py's FLAGS block and the table above are the two places to edit.

Reading the result, and the trap in it

Never adjudicate on a battery mean. The mean is the one summary that hides what makes a mechanism worth keeping: a step that buys a great deal on a few workloads and costs a little on many is insurance, and insurance always looks bad on average. ablate.py reports the asymmetry instead — total gain across the cells an arm helps, total cost across the cells it hurts, the worst single row, and how many cells the arm leaves bit-identical. The audit layer's own case is the worked example: +268pp across the rows it helps against −13pp across the rows it hurts, about 21:1, on a mean of +4.91 that says much less (hill-climber.md §5).

The verdicts:

• LOAD-BEARING — gains nowhere, losses somewhere. Keep, and update the recorded price.
• PRICED — a trade. Report the ratio and the worst row. Most steps land here, and "priced; it stays" is a complete answer. A ratio under 1:1 is a candidate, not a verdict: the guard rail's veto reads 0.3:1 on the battery and buys 6.4pp on a planted cell.
• NEGATIVE — removing the step helps everywhere. That is a defect report, not a simplification. Hand it to /audit-adaptivity.
• INERT — bit-identical on every cell. This is the interesting one, and it is not a licence to delete.

Where the battery is blind: the start. Every cell in it starts the cache where the product does, at 1%. A step that defends a window the machine has been driven away from therefore has almost nothing to act on, and its ratio collapses without the mechanism changing. Before treating a sub-1:1 ratio as a candidate, re-run the step's own cells with the window planted (CAF_EXTRA=-Dcaffeine.climber.startwin=0.55, or climber-gate/startwin.py for the sweep). The guard rail's veto is the worked case: 0.3:1 on the battery, +6.4pp on mainsat planted at 55%.

Why inert is not dead. The corpus is a sample of workloads that were interesting enough for someone to capture, plus constructions aimed at defects already imagined. A step that changes nothing on that sample may still be the only thing standing between a real deployment and a 5pp hole, and nobody would ever file that bug, because a user cannot see a hit rate they did not get. So an inert arm earns a second pass, not a patch:

1. Count the firings, then prove the state unreachable. ablate.py does the counting for you: it runs ship once per cell with -Dcaffeine.climber.counts, which dumps STEPFIRE <step>=<n> at exit, and folds the totals into the verdict. A branch that executes and changes no outcome is inert, which is weak; a branch that never executes on a narrow set is unexercised, which is weaker still, and the tool says so. norepeat never fires on demoflood and is worth 18.61 on absolve_p8, which is why the DEAD verdict is gated on the full preset and everything short of it prints PROVISIONAL.

   A zero count on the full set is still a fact about a sample, though, and a delete needs a fact about the machine. Close that gap with an argument from the gates themselves: read the conditions that guard the site and show they cannot hold together, or probe the machine's own readings for the state rather than the cells for the outcome. The worked example is external — the WaveCounter port's ADR-0055 rejected an input by probing 15,693 governor readings for the target state, finding it zero times, and then showing its two gates mutually exclusive by construction. The probe alone would have licensed the same delete on much thinner evidence.

2. Name the shape it was for. hill-climber.md §3 lists every family and what defeats it. A step whose family is still in the list and still passes is doing its job on a cell that the preset skipped; widen the cells before concluding anything.

3. Check the graveyard. §5 records what a step replaced. A step that is inert because a later rule subsumed it is a genuine prune; a step that is inert because its trap was retired is a prune plus a note that the trap should come back.

4. Spend a holdout on the prune, not on the decision. The battery is what the decision was made on, so it cannot also verify it. climber-gate/SKILL.md records which holdouts are unspent.

One more asymmetry worth stating. A wrong keep costs complexity, which is visible and recoverable. A wrong prune costs hit rate on a workload nobody is measuring, which is neither. The bar for removing a step should be higher than the bar for keeping one, and this skill is built to be run often and to delete rarely.