Dynamic move ordering overhaul: continuation-history, evidence-gated

countermove promotion, retired hung-piece-escape and NumLeftoverMovesToSelect.

Full session was built on a "measure the pick, not the game" methodology:
aggregate solve counts on curated suites are too noisy to tune move-ordering
knobs against, so most decisions here came from per-move fail-high/alpha-raise
rates at much larger sample sizes (leftover FH% instrumentation, a zero-
selection-budget diagnostic that isolates a single best-of-remaining pick,
and evidence-bucket calibration), not solve-count deltas alone. See
CLAUDE.md's "Dynamic move ordering experiments" section for the reusable
methodology and generate.c's _ScoreAllMoves comment for the resulting
ordering hierarchy.

Changes:
- Added g_ContinuationHistory: same growth/decay math as the existing
  g_HistoryCounters butterfly table, additionally keyed by the previous
  move, so its magnitude is self-calibrated rather than a hand-picked
  constant. Flat, sufficient response across a 256x scale sweep.
- Countermove-table matches now get a real GOOD_MOVE-tier promotion
  (previously the table was write-only, tracked for stats but never read
  for ordering), but only when the match's own accumulated
  history+continuation evidence clears COUNTERMOVE_EVIDENCE_THRESHOLD
  (10,000) -- a raw match with no track record was shown to perform
  identically to an ordinary leftover (~0.6-0.85% FH), so promoting on
  match alone would have repeated hung-piece-escape's mistake below.
- Retired hung-piece-escape's unconditional GOOD_MOVE-tier promotion.
  Evidence-calibration showed the overwhelming majority of triggers (a
  zero-evidence population 250-1000x larger than countermove's) performed
  at the plain-leftover baseline -- the promotion was mostly free tier-
  escape treatment for moves that hadn't earned it. Replaced with
  FLEE_BONUS, a flat same-tier nudge inside SelectBestWithHistory (never
  escapes GOOD_MOVE/leftover classification, unlike a generation-time
  promotion) at the magnitude found to plateau a same-tier-nudge sweep.
- Retired NumLeftoverMovesToSelect (the depth-indexed budget on how many
  leftover moves got a full selection scan before falling back to
  unsorted order). search.c's main move loop now always fully selects --
  the leftover pool was shown to contain real, findable signal a bailout
  budget was discarding for a node-count savings that didn't hold up net-
  net once measured by solve counts and fail-high rates rather than raw
  node counts (noisy on small suites independent of this change).
- Collapsed leftover-move instrumentation from sorted/raw pairs down to a
  single set now that "raw" (unsorted fallback) is structurally
  impossible; kept the countermove evidence-bucket calibration counters
  (ongoing check that COUNTERMOVE_EVIDENCE_THRESHOLD stays well-
  calibrated); removed the contested-node A/B harness and hung-piece
  evidence calibration now that the decisions they were built to inform
  are made.

Net effect on the three curated suites (sd 10): solve counts wash (tied,
+1, -1 across ringers/confident/hard), leftover fail-high rate improved
consistently on all three (the intended, directly-measured target of this
work). Not yet validated beyond sd 10 -- an sn-based run or
eval_tune/match_play.py head-to-head gate is the natural next check before
leaning on this as a proven strength gain rather than a directionally-
sound, sd-10-clean change.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_014XePz6Sk4qQsTaP2jVJWJu

1 files changed, 44 insertions, 1 deletions

diff --git a/src/script.c b/src/script.c
index 142b42c..0bc09e4 100755
--- a/src/script.c
+++ b/src/script.c
@@ -59,6 +59,11 @@ typedef struct _SUITE_COUNTERS
     UINT64 u64TotalBetaCutoffsOnFirstMove;
     UINT64 u64TotalCounterMoveTries;
     UINT64 u64TotalCounterMoveHits;
+    UINT64 u64TotalLeftoverTries;
+    UINT64 u64TotalLeftoverAlpha;
+    UINT64 u64TotalLeftoverFH;
+    UINT64 u64TotalCMEvidenceTries[CM_EVIDENCE_BUCKETS];
+    UINT64 u64TotalCMEvidenceFH[CM_EVIDENCE_BUCKETS];
     double dSigmaEBF;             // sum of per-problem nodes^(1/depth)
     ULONG uEBFCount;              // number of problems with depth > 0
     double dAverageTimeToSolution;
@@ -420,6 +425,19 @@ Return value:
                     g_Options.u64CounterMoveTries;
                 g_SuiteCounters.u64TotalCounterMoveHits +=
                     g_Options.u64CounterMoveHits;
+                g_SuiteCounters.u64TotalLeftoverTries +=
+                    g_Options.u64LeftoverTries;
+                g_SuiteCounters.u64TotalLeftoverAlpha +=
+                    g_Options.u64LeftoverAlpha;
+                g_SuiteCounters.u64TotalLeftoverFH +=
+                    g_Options.u64LeftoverFH;
+                for (v = 0; v < CM_EVIDENCE_BUCKETS; v++)
+                {
+                    g_SuiteCounters.u64TotalCMEvidenceTries[v] +=
+                        g_Options.u64CMEvidenceTries[v];
+                    g_SuiteCounters.u64TotalCMEvidenceFH[v] +=
+                        g_Options.u64CMEvidenceFH[v];
+                }
             }
             else
             {
@@ -448,6 +466,8 @@ Return value:
               "    avg. eff. branching : %5.3f\n"
               "    counter move hit %% : %5.2f percent (%"
                    COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n"
+              "    leftover            : %5.2f%% alpha, %5.2f%% FH (%"
+                   COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n"
               "    script time         : %6.1f sec\n\n",
               g_SuiteCounters.uCorrect,
               g_SuiteCounters.uIncorrect,
@@ -467,8 +487,31 @@ Return value:
               (100.0 * (double)g_SuiteCounters.u64TotalCounterMoveHits /
                ((double)g_SuiteCounters.u64TotalCounterMoveTries + 1.0)),
               g_SuiteCounters.u64TotalCounterMoveTries,
+              (100.0 * (double)g_SuiteCounters.u64TotalLeftoverAlpha /
+               ((double)g_SuiteCounters.u64TotalLeftoverTries + 1.0)),
+              (100.0 * (double)g_SuiteCounters.u64TotalLeftoverFH /
+               ((double)g_SuiteCounters.u64TotalLeftoverTries + 1.0)),
+              g_SuiteCounters.u64TotalLeftoverTries,
               (SystemTimeStamp() - dSuiteStart));
-        
+
+        // Countermove evidence calibration -- FH% per evidence bucket,
+        // an ongoing check that COUNTERMOVE_EVIDENCE_THRESHOLD (chess.h)
+        // is still well-calibrated as the engine/data evolve.
+        {
+            static const ULONG uCMEvidenceFloors[CM_EVIDENCE_BUCKETS] =
+                { 0, 1, 100, 1000, 10000, 100000, 1000000 };
+            Trace("\ncountermove evidence calibration:\n");
+            for (v = 0; v < CM_EVIDENCE_BUCKETS; v++)
+            {
+                Trace("    evidence >= %8lu : %5.2f%% FH (%"
+                      COMPILER_LONGLONG_UNSIGNED_FORMAT " tries)\n",
+                      uCMEvidenceFloors[v],
+                      (100.0 * (double)g_SuiteCounters.u64TotalCMEvidenceFH[v] /
+                       ((double)g_SuiteCounters.u64TotalCMEvidenceTries[v] + 1.0)),
+                      g_SuiteCounters.u64TotalCMEvidenceTries[v]);
+            }
+        }
+
         // Histogram stuff
         if (g_SuiteCounters.uTotal > 0) {
             uMax = g_SuiteCounters.uHistogram[0];