From fa484071cdea62d398c334cc4e7c4d407043af79 Mon Sep 17 00:00:00 2001 From: slaguru666 <111923774+slaguru666@users.noreply.github.com> Date: Sun, 13 Sep 2026 14:34:10 +0100 Subject: [PATCH] R-281: a ratchet, because "helps in all of them" survives the advice decaying R-280 left the claim satisfiable by a gain of 0.2. The artifact now records how many measurable packs clear their own noise -- reliable: {aboveNoise: 36, of: 38} -- and the check refuses if that share falls. It may rise freely. A ratchet rather than a threshold: any threshold here would be a number I chose, and choosing one just under the current value is what produced MEASURABLE = [15,85]. A share rather than a count, so widening admission cannot pay it off. Proved three ways in worktrees: making focus fire actively bad fires the drift check first, which is correct; making it unreliable and re-recording fires the older claim at 37 of 38; and claiming a better past, 38 of 38, is refused by the ratchet itself. The ratchet bites exactly where the old claim does not -- between "still helps everywhere" and "helps as reliably as it did", which is where a slow degradation lives. Co-Authored-By: Claude Opus 5 --- docs/REVIEW_LOG.md | 34 ++++++++++++++++++++++++++++++++++ tools/check-focus.mjs | 32 ++++++++++++++++++++++++++++++-- tools/focus-baseline.json | 4 ++++ 3 files changed, 68 insertions(+), 2 deletions(-) diff --git a/docs/REVIEW_LOG.md b/docs/REVIEW_LOG.md index be80855..cbe8553 100644 --- a/docs/REVIEW_LOG.md +++ b/docs/REVIEW_LOG.md @@ -6539,3 +6539,37 @@ measurable pack — is satisfied by gains of 0.2, so it is a weaker sentence tha the band admitted only contested fights. If it should be a stronger claim, the place to strengthen it is the claim, not the admission rule; tightening admission to protect a claim is how the band got here. + +## R-281 — a ratchet, because "helps in all of them" survives the advice becoming useless + +R-280 left check-focus asserting that focus fire helps in every measurable pack, and that +sentence is now satisfied by a gain of **0.2**. True, and thin: the advice could decay to +nothing everywhere it is not already decisive and the guard would still pass. + +**The strengthening is a ratchet rather than a threshold.** The artifact records how many +measurable packs showed a gain clearing their own noise — `reliable: { aboveNoise: 36, of: +38 }` — and the check refuses if that SHARE falls. It may rise freely. + +A threshold here would be a number I chose, and choosing one to sit just under the current +value is the move that produced `MEASURABLE = [15, 85]` in the first place. A ratchet has no +chosen number in it: the bar is the measurement, and it moves only when the game does. + +**It is a share and not a count**, so it cannot be satisfied by admitting more packs — which +matters, because R-280 just widened admission from 31 to 38 and a count-based ratchet would +have been paid off by the widening. + +**Proved by trying it three ways**, in throwaway worktrees: + +- *Make focus fire actively bad* — target the healthiest enemy instead of the most hurt. + The drift check fires first and names four creatures, which is correct: any movement is + drift before it is anything else. +- *Make it unreliable and re-record* — concentrate only half the time, then `--update`. + The older claim fires: focus fire now helps in 37 of 38, so the page's flat assertion is + already false and the ratchet is never reached. +- *Leave the game alone and claim a better past* — set the recorded share to 38 of 38. The + ratchet refuses: *"clears its own noise in 36 of 38, down from 38 of 38 ... that is a + change in the game, not a baseline to refresh."* + +The middle case is the useful one to understand: **the ratchet only bites where the existing +claim does not**, in the band between "still helps everywhere" and "helps as reliably as it +did". That band is exactly where a slow degradation lives, and it was unguarded until now. diff --git a/tools/check-focus.mjs b/tools/check-focus.mjs index 1490d9d..559cb57 100644 --- a/tools/check-focus.mjs +++ b/tools/check-focus.mjs @@ -131,7 +131,7 @@ const pickSize = spec => { if (UPDATE) { const creatures = {}; - let measurableCount = 0; + let measurableCount = 0, aboveNoiseCount = 0; for (const spec of NPCS) { const pick = pickSize(spec); /* Measured first, then admitted or not: the noise this test needs is a product of the @@ -143,11 +143,17 @@ if (UPDATE) { } creatures[spec.key] = row; measurableCount++; + if (row.gain > row.noise) aboveNoiseCount++; } await writeFile(BASELINE, JSON.stringify({ note: "Generated by tools/check-focus.mjs --update. Do not edit by hand.", party: PARTY_KEYS, runs: RUNS, seeds: SEEDS, seedMode: SEED_MODE, - admission: "spread clear of 0 and 100 by more than its own noise", creatures + admission: "spread clear of 0 and 100 by more than its own noise", + /* R-281. The ratchet the claim check holds to: how many of the measurable packs + showed a gain clearing their own noise when this was recorded. Focus fire may + get more reliable and may not quietly get less. */ + reliable: { aboveNoise: aboveNoiseCount, of: measurableCount }, + creatures }, null, 2) + "\n", "utf8"); console.log(`check-focus: baseline recorded — ${measurableCount} of ${NPCS.length} creatures measurable, ` + `${RUNS} runs x ${SEEDS.length} seeds, seed ${SEEDS[0]} ${SEED_MODE}`); @@ -226,5 +232,27 @@ if (helped !== checked) { process.exit(1); } +/* R-281. "Helps in all of them" is satisfied by a gain of 0.2, which is true and thin: it + survives the advice becoming useless everywhere it is not already decisive. So the + RELIABILITY is recorded and ratcheted — the share of measurable packs where the gain + clears its own noise may rise and may not quietly fall. + + A ratchet rather than a threshold, because any threshold here would be a number I chose. + This one is the measurement itself, and it fails only on a real change in the game. Note + the direction: this cannot be satisfied by admitting more packs, since it is a share. */ +const wasReliable = base.reliable; +if (wasReliable && wasReliable.of > 0) { + const wasShare = wasReliable.aboveNoise / wasReliable.of; + const nowShare = aboveNoise / Math.max(checked, 1); + if (nowShare < wasShare) { + console.error(`check-focus: FAILED — focus fire clears its own noise in ${aboveNoise} of ` + + `${checked} packs, down from ${wasReliable.aboveNoise} of ${wasReliable.of}. The advice ` + + `still helps everywhere, and it has become less reliably worth taking than when it was ` + + `recorded. That is a change in the game, not a baseline to refresh: find what moved ` + + `before re-recording, and rewrite the page if the advice is now weaker than it reads.`); + process.exit(1); + } +} + console.log(`check-focus: OK — focus fire measured against ${checked} packs, helps in all of them` + `, ${aboveNoise} of them by more than their own noise`); diff --git a/tools/focus-baseline.json b/tools/focus-baseline.json index 38248cd..864bdd0 100644 --- a/tools/focus-baseline.json +++ b/tools/focus-baseline.json @@ -14,6 +14,10 @@ ], "seedMode": "per-creature", "admission": "spread clear of 0 and 100 by more than its own noise", + "reliable": { + "aboveNoise": 36, + "of": 38 + }, "creatures": { "quiet_neighbours_npc": { "n": 6,