This is stable implementation from eleeye

src/position.h

@@ -159,6 +159,7 @@ class Position {
     bool     rule_judge(Value& result, int ply = 0);
     int      rule60_count() const;
     uint16_t chased(Color c);
+    int      possible_repetition() const;
     Value    major_material(Color c) const;
     Value    major_material() const;
 
@@ -284,6 +285,8 @@ inline Key Position::minor_piece_key() const { return st->minorPieceKey; }
 
 inline Key Position::non_pawn_key(Color c) const { return st->nonPawnKey[c]; }
 
+inline int Position::possible_repetition() const { return filter[st->key]; }
+
 inline Value Position::major_material(Color c) const { return st->majorMaterial[c]; }
 
 inline Value Position::major_material() const {

src/search.cpp

@@ -583,6 +583,7 @@ Value Search::Worker::search(
     excludedMove                   = ss->excludedMove;
     posKey                         = pos.key();
     auto [ttHit, ttData, ttWriter] = tt.probe(posKey);
+    ttHit &= tt.stable(pos);
     // Need further processing of the saved data
     ss->ttHit    = ttHit;
     ttData.move  = rootNode ? thisThread->rootMoves[thisThread->pvIdx].pv[0]
@@ -1422,6 +1423,7 @@ Value Search::Worker::qsearch(Position& pos, Stack* ss, Value alpha, Value beta)
     // Step 3. Transposition table lookup
     posKey                         = pos.key();
     auto [ttHit, ttData, ttWriter] = tt.probe(posKey);
+    ttHit &= tt.stable(pos);
     // Need further processing of the saved data
     ss->ttHit    = ttHit;
     ttData.move  = ttHit ? ttData.move : Move::none();

src/tt.cpp

@@ -228,7 +228,6 @@ uint8_t TranspositionTable::generation() const { return generation8; }
 // minus 8 times its relative age. TTEntry t1 is considered more valuable than
 // TTEntry t2 if its replace value is greater than that of t2.
 std::tuple<bool, TTData, TTWriter> TranspositionTable::probe(const Key key) const {
-
     TTEntry* const tte   = first_entry(key);
     const uint16_t key16 = uint16_t(key);  // Use the low 16 bits as key inside the cluster
 
@@ -248,6 +247,20 @@ std::tuple<bool, TTData, TTWriter> TranspositionTable::probe(const Key key) cons
     return {false, TTData(), TTWriter(replace)};
 }
 
+bool TranspositionTable::stable(Position& pos) const {
+    auto [ttHit, ttData, ttWriter] = probe(pos.key());
+
+    if (ttData.move == Move::none() || !pos.pseudo_legal(ttData.move) || !pos.legal(ttData.move)
+        || pos.capture(ttData.move))
+        return true;
+
+    StateInfo st;
+    pos.do_move(ttData.move, st);
+    bool result = pos.possible_repetition() ? false : stable(pos);
+    pos.undo_move(ttData.move);
+    return result;
+}
+
 
 TTEntry* TranspositionTable::first_entry(const Key key) const {
     return &table[mul_hi64(key, clusterCount)].entry[0];

src/tt.h

@@ -25,6 +25,7 @@
 
 #include "memory.h"
 #include "types.h"
+#include "position.h"
 
 namespace Stockfish {
 
@@ -81,6 +82,7 @@ class TranspositionTable {
     uint8_t generation() const;  // The current age, used when writing new data to the TT
     std::tuple<bool, TTData, TTWriter>
     probe(const Key key) const;  // The main method, whose retvals separate local vs global objects
+    bool     stable(Position& pos) const;
     TTEntry* first_entry(const Key key)
       const;  // This is the hash function; its only external use is memory prefetching.