dgb(#82): run-loop spine — io_context + graceful signal_set shutdown (--run)

Stand up the run-loop spine in main_dgb.cpp behind a new --run flag: a
boost::asio::io_context plus an explicit graceful shutdown driven from
signal_set(SIGINT, SIGTERM), mirroring main_btc.cpp s teardown contract.

This is the lifecycle every node subsystem (sharechain peer dgb::Node,
embedded digibyted P2P, Stratum acceptor) and the #82 won-block dispatch
handler hangs off. Standing the spine up first keeps the next increments
(node/Config construction over LevelDB, P2P listen, Stratum, and the
m_on_block_found -> reconstruct_won_block -> broadcast_won_block binding
landed across #163/#166/#167/#173/#174/#176/#177/#179) build-verifiable
rather than landing a large unverified port in one step.

--selftest / bare invocation unchanged (live ShareTracker::score() path).
External digibyted RPC fallback posture preserved.

Build: c2pool-dgb links EXIT=0 (-DCOIN_DGB=ON). Smoke: --selftest OK
(block_period=75s SSOT); --run spine up, SIGINT -> clean shutdown exit 0.

Author: frstrtr

src/c2pool/main_dgb.cpp

@@ -2,26 +2,32 @@
 //
 // Wires the real dgb sharechain/pool TU (pool pillars + score path, ported from
 // LTC under impl/dgb/ across PRs #112/#113/#115/#121/#129/#131/#132/#134) into
-// the c2pool-dgb executable. This is the exe-wire slice: it replaces the
-// slice-#4 skeleton entry (dgb::run_skeleton/network_summary, removed when #134
-// dropped the real node.cpp in) and drives the LIVE chain-score path at
-// startup, so the coin smoke gate exercises share_tracker::score() rather than
-// merely linking it. node.cpp (the concrete dgb::NodeImpl) is compiled into the
-// target so the real node TU links; its full run-loop (NodeBridge over the
-// embedded digibyted P2P + Stratum) is a later Phase B slice — dgb::NodeImpl is
-// abstract (ICommunicator::handle is supplied by the NodeBridge wrapper), so a
-// bare node is not stood up here. The score path lives on dgb::ShareTracker,
-// which we drive directly (header-only, no network / no LevelDB).
+// the c2pool-dgb executable. Two entry paths:
+//
+//   --selftest / bare : drive the LIVE dgb::ShareTracker::score() path so the
+//                       coin smoke gate exercises real consensus code, then exit.
+//   --run             : stand up the run-loop SPINE (this slice) — io_context +
+//                       graceful SIGINT/SIGTERM shutdown. The node/stratum/P2P
+//                       subsystems and the won-block dispatch binding
+//                       (m_on_block_found -> reconstruct_won_block ->
+//                       broadcast_won_block, #82 connecting tissue landed across
+//                       PRs #163/#166/#167/#173/#174/#176/#177/#179) bind onto
+//                       this io_context in the NEXT stacked slice. Standing the
+//                       spine up first gives those subsystems the lifecycle they
+//                       hang off and keeps each increment build-verifiable.
 //
 // V36 scope: Scrypt blocks validated; the other 4 DGB algos (SHA256d, Skein,
 // Qubit, Odocrypt) are accept-by-continuity / ignored — full 5-algo support is
 // V37. Conformance oracle: frstrtr/p2pool-dgb-scrypt (DGB-Scrypt standalone
 // parent; merged-v36 byte-compat WAIVED for DGB per operator 2026-06-17).
 // CoinParams are oracle-sourced via dgb::make_coin_params (no hardcoded bytes).
-// Mirrors src/c2pool/main_btc.cpp's target shape.
+// External digibyted RPC stays as a fallback alongside the embedded path.
+// Mirrors src/c2pool/main_btc.cpp s target shape.
 
 #include <impl/dgb/node.hpp>
 
+#include <boost/asio.hpp>
+
 #include <cstdint>
 #include <cstring>
 #include <iostream>
@@ -31,6 +37,8 @@
 #define C2POOL_VERSION "dev"
 #endif
 
+namespace io = boost::asio;
+
 namespace {
 
 // Live network summary sourced from the oracle-populated CoinParams
@@ -49,10 +57,11 @@ void print_banner(const char* argv0, const core::CoinParams& p)
 {
     std::cout
         << "c2pool-dgb " << C2POOL_VERSION << " — DigiByte Scrypt-only (V36)\n\n"
-        << "Usage: " << argv0 << " [--version] [--help] [--selftest]\n\n"
-        << "Status: pool/sharechain pillars live (Phase B). The embedded-daemon\n"
-        << "        run-loop (digibyted P2P + Stratum) lands in a later slice;\n"
-        << "        external digibyted RPC stays as a fallback.\n"
+        << "Usage: " << argv0 << " [--version] [--help] [--selftest] [--run]\n\n"
+        << "Status: pool/sharechain pillars live (Phase B); run-loop spine up\n"
+        << "        (--run: io_context + graceful shutdown). Node/stratum/P2P +\n"
+        << "        won-block dispatch binding land in the next slice; external\n"
+        << "        digibyted RPC stays as a fallback.\n"
         << "Network: " << network_summary(p) << "\n";
 }
 
@@ -84,19 +93,69 @@ int run_selftest(const core::CoinParams& params)
     return 0;
 }
 
+// Run-loop SPINE. Stands up the io_context that every node subsystem
+// (sharechain peer dgb::Node, embedded digibyted P2P, Stratum acceptor) and
+// the #82 won-block dispatch handler will hang off, plus an explicit graceful
+// shutdown driven from boost::asio::signal_set.
+//
+// Why signal_set and not std::signal: std::signal handlers run in the
+// async-signal-only delivery context; io_context::stop is thread-safe but not
+// documented signal-safe. signal_set delivers SIGINT/SIGTERM as an ordinary
+// async callback on the io_context thread, so the shutdown path can do real
+// work (stop the stratum acceptor, close sessions) before ioc.stop() drains
+// the rest — mirrors main_btc.cpp s teardown contract.
+//
+// SEAM (next stacked slice): construct dgb::Config + dgb::Node(&ioc, &config),
+// listen on the sharechain P2P port, stand up the Stratum work source, and
+// bind make_on_block_found(reconstruct_won_block, p2p_sink) into
+// m_on_block_found so a won share reaches the network (closes #82). Those
+// subsystems open LevelDB + bind sockets, so they land as their own
+// build-verified increment rather than inline here.
+int run_node(const core::CoinParams& params)
+{
+    io::io_context ioc;
+
+    bool shutdown_initiated = false;
+    io::signal_set signals(ioc, SIGINT, SIGTERM);
+    signals.async_wait(
+        [&ioc, &shutdown_initiated](const boost::system::error_code& ec, int signo) {
+            if (ec) return;
+            if (shutdown_initiated) return;
+            shutdown_initiated = true;
+
+            std::cout << "[DGB] received signal " << signo
+                      << " — initiating graceful shutdown" << std::endl;
+            // Next slice: stop stratum acceptor + close sessions here BEFORE
+            // ioc.stop(), so their pending async ops cancel cleanly.
+            ioc.stop();
+        });
+
+    std::cout << "[DGB] run-loop spine up: " << network_summary(params) << "\n";
+    std::cout << "[DGB] io_context running. Ctrl-C to stop. "
+              << "(node/stratum/P2P + won-block dispatch bind in the next slice)"
+              << std::endl;
+
+    ioc.run();
+
+    std::cout << "[DGB] io_context stopped — clean exit" << std::endl;
+    return 0;
+}
+
 } // namespace
 
 int main(int argc, char** argv)
 {
     bool want_help = false;
     bool want_selftest = false;
+    bool want_run = false;
     for (int i = 1; i < argc; ++i) {
         if (std::strcmp(argv[i], "--version") == 0) {
             std::cout << "c2pool-dgb " << C2POOL_VERSION << "\n";
             return 0;
         }
         if (std::strcmp(argv[i], "--help") == 0)     want_help = true;
         if (std::strcmp(argv[i], "--selftest") == 0) want_selftest = true;
+        if (std::strcmp(argv[i], "--run") == 0)      want_run = true;
     }
 
     const core::CoinParams params = dgb::make_coin_params(/*testnet=*/false);
@@ -105,8 +164,12 @@ int main(int argc, char** argv)
     if (want_help)
         return 0;
 
-    // --selftest, or a bare invocation (no run-loop yet): drive the live score
-    // path so the binary exercises real consensus code, then exit cleanly.
+    // --run: stand up the run-loop spine (io_context + graceful shutdown).
+    if (want_run)
+        return run_node(params);
+
+    // --selftest, or a bare invocation: drive the live score path so the
+    // binary exercises real consensus code, then exit cleanly.
     (void)want_selftest;
     return run_selftest(params);
 }