Extract ponder move and check it against PV

robertnurnberg · robertnurnberg · commit b3e0cc619dd0 · 2026-05-14T21:36:29.000+02:00
diff --git a/app/src/cli/cli.cpp b/app/src/cli/cli.cpp
@@ -673,6 +673,8 @@ void parseAffinity(const std::vector<std::string>& params, ArgumentData& argumen
 
 void parseMatePvs(ArgumentData& argument_data) { argument_data.tournament_config.check_mate_pvs = true; }
 
+void parsePonderPvShort(ArgumentData& argument_data) { argument_data.tournament_config.warn_ponder_pv_short = true; }
+
 void parseLatency(ArgumentData& argument_data) { argument_data.tournament_config.show_latency = true; }
 
 void parseDebug(ArgumentData&) {
@@ -764,6 +766,7 @@ void OptionsParser::registerOptions() {
     addOption<ParamStyle::KeyValue>("quick", parseQuick);
     addOption("use-affinity", parseAffinity);
     addOption<ParamStyle::None>("check-mate-pvs", parseMatePvs);
+    addOption<ParamStyle::None>("warn-ponder-pv-short", parsePonderPvShort);
     addOption<ParamStyle::None>("show-latency", parseLatency);
     addOption<ParamStyle::None>("debug", parseDebug);
     addOption<ParamStyle::None>("testEnv", parseTestEnv);
diff --git a/app/src/cli/man.hpp b/app/src/cli/man.hpp
diff --git a/app/src/engine/compliance.hpp b/app/src/engine/compliance.hpp
@@ -67,7 +67,7 @@ inline bool compliant(int argc, char const* argv[]) {
             return false;
         }
 
-        std::cout << "\r" << "\033[1;32m Passed\033[0m Step " << step << ": " << description << std::endl;
+        std::cout << "\r\033[1;32m Passed\033[0m Step " << step << ": " << description << std::endl;
 
         return true;
     };
@@ -137,7 +137,7 @@ inline bool compliant(int argc, char const* argv[]) {
         {"Read bestmove after go wtime 100 btime 100",
          [&uci_engine] {
              return uci_engine.readEngine("bestmove").code == process::Status::OK &&
-                    uci_engine.bestmove() != std::nullopt;
+                    uci_engine.bestmove().first != std::nullopt;
          }},
         {"Verify info line format is valid after go wtime 100 btime 100",
          [&uci_engine] { return isValidInfoLine(uci_engine.lastInfoLine()); }},
@@ -147,7 +147,7 @@ inline bool compliant(int argc, char const* argv[]) {
         {"Read bestmove after position startpos moves e2e4 e7e5",
          [&uci_engine] {
              return uci_engine.readEngine("bestmove").code == process::Status::OK &&
-                    uci_engine.bestmove() != std::nullopt;
+                    uci_engine.bestmove().first != std::nullopt;
          }},
         {"Verify info line format is valid after position startpos moves e2e4 e7e5",
          [&uci_engine] { return isValidInfoLine(uci_engine.lastInfoLine()); }}};
diff --git a/app/src/engine/uci_engine.cpp b/app/src/engine/uci_engine.cpp
@@ -439,7 +439,7 @@ bool UciEngine::writeEngine(const std::string& input) {
     return process_.writeInput(input + "\n").code == process::Status::OK;
 }
 
-std::optional<std::string> UciEngine::bestmove(bool warn_on_error) const {
+std::pair<std::optional<std::string>, std::optional<std::string>> UciEngine::bestmove(bool warn_on_error) const {
     const auto warn = [&](std::string_view reason, std::string_view last_line = {}) {
         if (!warn_on_error) {
             return;
@@ -457,24 +457,27 @@ std::optional<std::string> UciEngine::bestmove(bool warn_on_error) const {
 
     if (lines.empty()) {
         warn("No output");
-        return std::nullopt;
+        return {std::nullopt, std::nullopt};
     }
 
     const auto& last_line = lines.back()->line;
 
     if (last_line.rfind("bestmove", 0) != 0) {
         warn("Line does not start with 'bestmove'", last_line);
-        return std::nullopt;
+        return {std::nullopt, std::nullopt};
     }
 
-    const auto bm = str_utils::findElement<std::string>(str_utils::splitString(last_line, ' '), "bestmove");
+    const auto last_info = str_utils::splitString(last_line, ' ');
+    const auto bm = str_utils::findElement<std::string>(last_info, "bestmove");
 
     if (!bm.has_value()) {
         warn(bm.error(), last_line);
-        return std::nullopt;
+        return {std::nullopt, std::nullopt};
     }
 
-    return *bm;
+    const auto pm = str_utils::findElement<std::string>(last_info, "ponder");
+
+    return {bm.value(), pm.has_value() ? std::optional<std::string>{pm.value()} : std::nullopt};
 }
 
 std::chrono::milliseconds UciEngine::lastTime() const {
diff --git a/app/src/engine/uci_engine.hpp b/app/src/engine/uci_engine.hpp
@@ -3,6 +3,7 @@
 #include <chrono>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <chess.hpp>
@@ -107,8 +108,8 @@ class UciEngine {
             "Warning; Failed to set CPU affinity for the engine process to {}. Please restart.", cpu_str);
     }
 
-    // Get the bestmove from the last output.
-    [[nodiscard]] std::optional<std::string> bestmove(bool warn_on_error = true) const;
+    // Get the bestmove (and possibly ponder move) from the last output.
+    [[nodiscard]] std::pair<std::optional<std::string>, std::optional<std::string>> bestmove(bool warn_on_error = true) const;
 
     // Get the last info line from the last output.
     [[nodiscard]] std::string lastInfoLine() const;
diff --git a/app/src/matchmaking/match/match.cpp b/app/src/matchmaking/match/match.cpp
@@ -152,11 +152,12 @@ std::string Match::convertScoreToString(engine::Score score) {
     return "ERR";
 }
 
-void Match::addMoveData(const Player& player, const std::string& move, int64_t measured_time_ms, int64_t latency,
+void Match::addMoveData(const Player& player, const std::string& move, const std::string& ponder, int64_t measured_time_ms, int64_t latency,
                         int64_t timeleft, bool legal) {
     MoveData move_data;
 
     move_data.move           = move;
+    move_data.ponder         = ponder;
     move_data.score_string   = "0.00";
     move_data.elapsed_millis = measured_time_ms;
     move_data.legal          = legal;
@@ -211,7 +212,8 @@ void Match::addMoveData(const Player& player, const std::string& move, int64_t m
         }
     }
 
-    verifyPvLines(player, legal ? move : "");
+    // only warn on PV/bestmove mismatch if the move is legal
+    verifyPvLines(player, legal ? move : "", ponder);
 
     data_.moves.push_back(move_data);
 }
@@ -400,15 +402,17 @@ bool Match::playMove(Player& us, Player& them) {
         LOG_INFO_THREAD("Engine {} latency: {}ms (elapsed: {}, reported: {})", name, latency, elapsed_ms, last_time);
     }
 
-    const auto best_move = us.engine.bestmove(status.code == engine::process::Status::OK);
+    const auto bestmove  = us.engine.bestmove(status.code == engine::process::Status::OK);
+    const auto best_move = bestmove.first;
     const auto move      = best_move && uci::isUciMove(*best_move) ? uci::uciToMove(board_, *best_move) : Move::NO_MOVE;
     const auto legal     = isLegal(move);
 
     const auto timeout  = us.hasTimeControl() ? !us.getTimeControl().updateTime(elapsed_ms) : false;
     const auto timeleft = us.hasTimeControl() ? us.getTimeControl().getTimeLeft() : 0;
 
     if (best_move) {
-        addMoveData(us, *best_move, elapsed_ms, latency, timeleft, legal);
+        const auto ponder = bestmove.second;
+        addMoveData(us, *best_move, ponder ? *ponder : "", elapsed_ms, latency, timeleft, legal);
     }
 
     // there are two reasons why best_move could be empty
@@ -577,7 +581,7 @@ void Match::setEngineIllegalMoveStatus(Player& loser, Player& winner, const std:
     Logger::print<Logger::Level::WARN>("Warning; Illegal move {} played by {}", best_move.value_or("<none>"), name);
 }
 
-void Match::verifyPvLines(const Player& us, const std::string& best_move) {
+void Match::verifyPvLines(const Player& us, const std::string& best_move, const std::string& ponder_move) {
     const static auto verifyPv = [](Board board, const std::string& startpos,
                                     const std::vector<std::string_view>& uci_moves, const std::string& info,
                                     std::string_view name) {
@@ -685,7 +689,7 @@ void Match::verifyPvLines(const Player& us, const std::string& best_move) {
         verifyPv(board_, start_position_, data_.getMoves(), *info, us.engine.getConfig().name);
     }
 
-    // finally check if the final PV matches bestmove
+    // finally check if the final PV matches bestmove (and possibly ponder move)
     if (best_move.empty()) {
         return;
     }
@@ -706,17 +710,36 @@ void Match::verifyPvLines(const Player& us, const std::string& best_move) {
         return;
     }
 
-    if (best_move != (*pv)[0]) {
-        auto warning   = "Warning; Bestmove does not match beginning of last PV - move {} from {}";
+    for (unsigned int i = 0; i < 2; i++) {
+        if (i && (ponder_move.empty() || (!config::TournamentConfig->warn_ponder_pv_short && pv->size() < 2))) {
+            break;
+        }
+
+        const auto &value = i ? ponder_move : best_move;
+        if (i < pv->size() && value == (*pv)[i]) {
+            continue;
+        }
+
+        std::string warning;
+        if (i && pv->size() == 1) {
+            warning = "Warning; PV has length 1 despite ponder move output - move {} from {}";
+        } else {
+            warning =
+                "Warning; "s + (i ? "Ponder" : "Best") + "move does not match beginning of last PV - move {} from {}";
+        }
+
         auto start_pos = start_position_ == "startpos" ? "startpos" : ("fen " + start_position_);
-        auto out       = fmt::format(fmt::runtime(warning), best_move, us.engine.getConfig().name);
+        auto out       = fmt::format(fmt::runtime(warning), value, us.engine.getConfig().name);
         auto uci_info  = fmt::format("Info; {}", info);
         auto position  = fmt::format("Position; {}", start_pos);
         auto ucimoves  = fmt::format("Moves; {}", str_utils::join(data_.getMoves(), " "));
 
         auto separator = config::TournamentConfig->test_env ? " :: " : "\n";
 
         Logger::print<Logger::Level::WARN>("{1}{0}{2}{0}{3}{0}{4}", separator, out, uci_info, position, ucimoves);
+
+        // Do not emit ponder move warning if already the bestmove does not match PV
+        break;
     }
 }
 
diff --git a/app/src/matchmaking/match/match.hpp b/app/src/matchmaking/match/match.hpp
@@ -170,10 +170,10 @@ class Match {
     void setEngineTimeoutStatus(Player& loser, Player& winner, const std::optional<std::string>& best_move);
     void setEngineIllegalMoveStatus(Player& loser, Player& winner, const std::optional<std::string>& best_move);
 
-    void verifyPvLines(const Player& us, const std::string& best_move);
+    void verifyPvLines(const Player& us, const std::string& best_move, const std::string& ponder_move);
 
     // append the move data to the match data
-    void addMoveData(const Player& player, const std::string& move, int64_t measured_time_ms, int64_t latency,
+    void addMoveData(const Player& player, const std::string& move, const std::string& ponder, int64_t measured_time_ms, int64_t latency,
                      int64_t timeleft, bool legal);
 
     // returns false if the next move could not be played
diff --git a/app/src/types/match_data.hpp b/app/src/types/match_data.hpp
@@ -17,9 +17,10 @@ namespace fastchess {
 struct MoveData {
     MoveData() = default;
     explicit MoveData(std::string _move) : move(std::move(_move)) {}
-    MoveData(std::string _move, std::string _score_string, int64_t _elapsed_millis, int _depth, int _seldepth,
+    MoveData(std::string _move, std::string _ponder, std::string _score_string, int64_t _elapsed_millis, int _depth, int _seldepth,
              int _score, int _nodes, bool _legal = true, bool _book = false, std::string _pv = "")
         : move(std::move(_move)),
+          ponder(std::move(_ponder)),
           score_string(std::move(_score_string)),
           pv(_pv),
           nodes(_nodes),
@@ -29,9 +30,23 @@ struct MoveData {
           score(_score),
           legal(_legal),
           book(_book) {}
-
-    std::vector<std::string> additional_lines;
+    MoveData(std::string _move, std::string _score_string, int64_t _elapsed_millis, int _depth, int _seldepth,
+             int _score, int _nodes, bool _legal = true, bool _book = false, std::string _pv = "")
+        : MoveData(std::move(_move), 
+                   "",
+                   std::move(_score_string), 
+                   _elapsed_millis, 
+                   _depth, 
+                   _seldepth, 
+                   _score, 
+                   _nodes, 
+                   _legal, 
+                   _book, 
+                   std::move(_pv)) {} 
+    
+   std::vector<std::string> additional_lines;
     std::string move;
+    std::string ponder;
     std::string score_string;
     std::string pv = "";
 
diff --git a/app/src/types/tournament.hpp b/app/src/types/tournament.hpp
@@ -65,13 +65,14 @@ struct Tournament {
     uint32_t wait          = 0;
     bool force_concurrency = false;
 
-    bool noswap         = false;
-    bool reverse        = false;
-    bool recover        = false;
-    bool affinity       = false;
-    bool check_mate_pvs = false;
-    bool show_latency   = false;
-    bool test_env       = false;
+    bool noswap               = false;
+    bool reverse              = false;
+    bool recover              = false;
+    bool affinity             = false;
+    bool check_mate_pvs       = false;
+    bool warn_ponder_pv_short = false;
+    bool show_latency         = false;
+    bool test_env             = false;
 
     std::chrono::milliseconds startup_time    = std::chrono::seconds(10);
     std::chrono::milliseconds ucinewgame_time = std::chrono::seconds(60);
@@ -84,6 +85,7 @@ struct Tournament {
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Tournament, resign, draw, maxmoves, tb_adjudication, opening, pgn, epd, sprt,
                                    config_name, output, seed, variant, type, gauntlet_seeds, ratinginterval,
                                    scoreinterval, wait, autosaveinterval, games, rounds, concurrency, force_concurrency,
-                                   recover, noswap, reverse, report_penta, affinity, check_mate_pvs, show_latency, log)
+                                   recover, noswap, reverse, report_penta, affinity, check_mate_pvs, warn_ponder_pv_short,
+                                   show_latency, log)
 
 }  // namespace fastchess::config
diff --git a/app/tests/cli_test.cpp b/app/tests/cli_test.cpp
@@ -557,6 +557,7 @@ TEST_SUITE("Option Parsing Tests") {
         const auto config = parser.getTournamentConfig();
         CHECK(config.rounds == 5);
         CHECK(config.check_mate_pvs);
+        CHECK(config.warn_ponder_pv_short);
         CHECK(config.show_latency);
         CHECK(config.log.realtime);
         CHECK(config.config_name == "custom.json");
diff --git a/app/tests/configs/config.json b/app/tests/configs/config.json
@@ -78,6 +78,7 @@
   "report_penta": true,
   "affinity": false,
   "check_mate_pvs": true,
+  "warn_ponder_pv_short": true,
   "show_latency": true,
   "log": {
     "file": "",
diff --git a/app/tests/mock/engine/dummy_engine.cpp b/app/tests/mock/engine/dummy_engine.cpp
@@ -10,7 +10,7 @@ using namespace std;
 
 int main(int argc, char const *argv[]) {
     std::vector<std::string> moves = {"f2f3", "e7e5", "g2g4", "d8h4"};
-    int moveIndex                  = 0;
+    unsigned int moveIndex         = 0;
 
     if (argc > 1) {
         for (int i = 1; i < argc; i++) {
@@ -74,19 +74,22 @@ int main(int argc, char const *argv[]) {
 
             cout << "done" << endl;
         } else if (contains(cmd, "position")) {
-            for (int i = moves.size() - 1; i >= 0; i--) {
+            for (int i = moves.size() - 2; i >= 0; i--) {
                 if (contains(cmd, moves[i])) {
                     moveIndex = i + 1;
                     break;
                 }
             }
         } else if (contains(cmd, "go")) {
-            std::cout << "bestmove " << moves[moveIndex] << std::endl;
+            std::cout << "bestmove " << moves[moveIndex];
+            if (moveIndex + 1 < moves.size())
+                std::cout << " ponder " << moves[moveIndex + 1];
+            std::cout << std::endl;
         } else if (contains(cmd, "setoption")) {
             // Simulate setting an option
             std::cout << "option set: " << cmd << std::endl;
         }
     }
 
     return 0;
-}
+}
diff --git a/app/tests/uci_engine_test.cpp b/app/tests/uci_engine_test.cpp
@@ -121,6 +121,25 @@ TEST_SUITE("Uci Engine Communication Tests") {
         CHECK(res2.code == engine::process::Status::OK);
         CHECK(uci_engine.getStdoutLines().size() == 1);
         CHECK(uci_engine.getStdoutLines()[0]->line == "done");
+
+        // check if ponder move is parsed correctly
+        CHECK(uci_engine.writeEngine("go depth 1"));
+        const auto res3 = uci_engine.readEngine("bestmove");
+        CHECK(res3.code == engine::process::Status::OK);
+        CHECK(uci_engine.getStdoutLines().size());
+        const auto bestmove3 = uci_engine.bestmove();
+        CHECK(bestmove3.first.has_value());
+        CHECK(bestmove3.second.has_value());
+
+        // check if missing ponder move is parsed correctly
+        CHECK(uci_engine.writeEngine("position startpos moves f2f3 e7e5 g2g4"));
+        CHECK(uci_engine.writeEngine("go depth 1"));
+        const auto res4 = uci_engine.readEngine("bestmove");
+        CHECK(res4.code == engine::process::Status::OK);
+        CHECK(uci_engine.getStdoutLines().size());
+        const auto bestmove4 = uci_engine.bestmove();
+        CHECK(bestmove4.first.has_value());
+        CHECK(!bestmove4.second.has_value());
     }
 
     TEST_CASE("Testing the EngineProcess class with lower level class functions") {
diff --git a/man.md b/man.md
@@ -218,6 +218,9 @@ The default values are the first value in parentheses.
 - `-check-mate-pvs`
     Check that PVs for mate scores have the correct length and end in checkmate.
 
+- `-warn-ponder-pv-short`
+    Emit a warning if the engine shows a ponder move despite the final PV having length 1 and being for an exact score.
+
 - `-show-latency`  
     Show the "think" latency (difference between measured and reported time) for each engine.
     Note that a lot of engines add 1ms to the time they report, so the latency will be 1ms higher than the actual latency.
