cli: xchplot2 parity-check subcommand

Globs every *_parity binary in ./build/tools/parity (overridable via
--dir), execs each in turn, and summarizes PASS/FAIL with per-test
wall time. Captures stdout/stderr to /tmp/xchplot2-parity-<name>.log
for failed tests so the user can grep the log after.

Verified on main: 10/10 PASS (aes, aes_bs, xs, sycl_sort, sycl_g_x,
sycl_bucket_offsets, t1, t2, t3, plot_file).

Branch-agnostic by design — glob picks up whatever *_parity was
built, so cuda-only will see its subset automatically.

Author: Abraham Sewill

README.md

@@ -431,10 +431,11 @@ runs a live k=22 plot across `--devices 0,1`.
 ### Lower-level subcommands
 
 ```bash
-xchplot2 test   <k> <plot-id-hex> [strength] ...    # single plot, raw inputs
-xchplot2 batch  <manifest.tsv> [-v] [--skip-existing] [--continue-on-error]
-                                    [--devices <SPEC>]
-xchplot2 verify <file.plot2> [--trials N]           # run N random challenges
+xchplot2 test          <k> <plot-id-hex> [strength] ...    # single plot, raw inputs
+xchplot2 batch         <manifest.tsv> [-v] [--skip-existing] [--continue-on-error]
+                                             [--devices <SPEC>]
+xchplot2 verify        <file.plot2> [--trials N]           # run N random challenges
+xchplot2 parity-check  [--dir PATH]                        # CPU↔GPU regression screen
 ```
 
 `verify` opens a `.plot2` through pos2-chip's CPU prover and runs N
@@ -456,6 +457,8 @@ batch — not a replacement for `chia plots check`.
 | `ACPP_GFX=gfxXXXX`            | AMD only — required at **build** time; sets AOT target for amdgcn ISA. |
 | `ACPP_TARGETS=...`            | Override AdaptiveCpp target selection (defaults: NVIDIA `generic`, AMD `hip:$ACPP_GFX`). |
 | `CUDA_ARCHITECTURES=sm_XX`    | Override the CUDA arch autodetected from `nvidia-smi`.                  |
+| `CUDA_PATH=/path/to/cuda`     | Override the CUDA Toolkit root for linking (default: `/opt/cuda`, `/usr/local/cuda`). Useful on JetPack / non-standard installs. |
+| `CUDA_HOME=/path/to/cuda`     | Fallback for `CUDA_PATH` — same effect.                                 |
 | `POS2_CHIP_DIR=/path`         | Build-time: point at a local pos2-chip checkout instead of FetchContent.|
 | `XCHPLOT2_TEST_GPU_COUNT=N`   | Override `scripts/test-multi-gpu.sh`'s auto-detected GPU count (forces run / skip without consulting `nvidia-smi`). |
 

tools/xchplot2/cli.cpp

@@ -14,10 +14,12 @@
 
 #include <algorithm>
 #include <cerrno>
+#include <chrono>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <stdexcept>
@@ -76,6 +78,11 @@ void print_usage(char const* prog)
         << "    Open <plotfile> and run N random challenges through the CPU prover.\n"
         << "    Zero proofs across a sensible sample (>=100) strongly indicates a\n"
         << "    corrupt plot. Default N=100.\n"
+        << "  " << prog << " parity-check [--dir PATH]\n"
+        << "    Run every *_parity binary in PATH and summarize PASS/FAIL.\n"
+        << "    Default PATH is ./build/tools/parity. Build the tests with\n"
+        << "    `cmake --build <build-dir>` first. Useful for post-refactor\n"
+        << "    regression screening.\n"
         << "\n"
         << "  test-mode positional args:\n"
         << "    <k>            : even integer in [18, 32]\n"
@@ -305,6 +312,80 @@ extern "C" int xchplot2_main(int argc, char* argv[])
         }
     }
 
+    if (mode == "parity-check") {
+        std::string dir = "./build/tools/parity";
+        for (int i = 2; i < argc; ++i) {
+            std::string a = argv[i];
+            if ((a == "--dir" || a == "-d") && i + 1 < argc) {
+                dir = argv[++i];
+            } else {
+                std::cerr << "Error: unknown argument: " << a << "\n";
+                print_usage(argv[0]);
+                return 1;
+            }
+        }
+
+        // Glob every *_parity binary in `dir`. Same code path works for
+        // both branches — main ships sycl_*_parity extras that cuda-only
+        // doesn't, and the wildcard picks up whichever actually exists.
+        std::vector<std::filesystem::path> tests;
+        std::error_code ec;
+        if (std::filesystem::is_directory(dir, ec)) {
+            for (auto const& entry :
+                 std::filesystem::directory_iterator(dir, ec))
+            {
+                auto const name = entry.path().filename().string();
+                constexpr char const kSuffix[] = "_parity";
+                constexpr size_t kLen = sizeof(kSuffix) - 1;
+                bool const ends =
+                    name.size() >= kLen &&
+                    name.compare(name.size() - kLen, kLen, kSuffix) == 0;
+                if (ends && entry.is_regular_file(ec)) {
+                    tests.push_back(entry.path());
+                }
+            }
+        }
+        if (tests.empty()) {
+            std::cerr << "No `*_parity` binaries found under " << dir << ".\n"
+                         "Build them first:\n"
+                         "  cmake -B build -S . -DCMAKE_BUILD_TYPE=Release\n"
+                         "  cmake --build build --parallel\n"
+                         "Then re-run from the repo root, or pass --dir <path>.\n";
+            return 2;
+        }
+        std::sort(tests.begin(), tests.end());
+
+        int pass = 0, fail = 0;
+        std::cerr << "==> parity tests (" << tests.size() << " found in "
+                  << dir << ")\n";
+        for (auto const& test : tests) {
+            auto const name = test.filename().string();
+            std::string const log_path =
+                "/tmp/xchplot2-parity-" + name + ".log";
+            // Redirecting through the shell: `test` is a path we
+            // generated ourselves from a directory listing — no user-
+            // controlled shell metachars reach this string.
+            std::string const cmd =
+                test.string() + " >" + log_path + " 2>&1";
+            auto const t0 = std::chrono::steady_clock::now();
+            int const rc = std::system(cmd.c_str());
+            auto const ms = std::chrono::duration<double, std::milli>(
+                                std::chrono::steady_clock::now() - t0).count();
+            if (rc == 0) {
+                std::fprintf(stderr, "  PASS  %-32s  (%.1f ms)\n",
+                             name.c_str(), ms);
+                ++pass;
+            } else {
+                std::fprintf(stderr,
+                             "  FAIL  %-32s  (exit %d; log: %s)\n",
+                             name.c_str(), rc, log_path.c_str());
+                ++fail;
+            }
+        }
+        std::fprintf(stderr, "\n==> %d passed, %d failed\n", pass, fail);
+        return fail > 0 ? 1 : 0;
+    }
+
     if (mode == "plot") {
         // Standalone farmable-plot path: derive plot_id + memo internally.
         int k = 28;