diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e974409..3919c0d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -43,13 +43,13 @@ jobs:
           dotnet-version: 10.0.x
 
       - name: Restore app
-        run: dotnet restore boot_portal/boot_portal.csproj
+        run: dotnet restore boot_portal/boot_portal.csproj --locked-mode
 
       - name: Build app
         run: dotnet build boot_portal/boot_portal.csproj --configuration Release --no-restore
 
       - name: Restore tests
-        run: dotnet restore boot.tests/boot.tests.csproj
+        run: dotnet restore boot.tests/boot.tests.csproj --locked-mode
 
       - name: Build tests
         run: dotnet build boot.tests/boot.tests.csproj --configuration Release --no-restore
@@ -57,12 +57,39 @@ jobs:
       - name: Run tests
         run: dotnet test boot.tests/boot.tests.csproj --configuration Release --no-build
 
+      - name: Dependency advisory report
+        run: dotnet list boot_portal/boot_portal.csproj package --vulnerable --include-transitive
+
+      - name: Filesystem vulnerability scan
+        uses: aquasecurity/trivy-action@v0.36.0
+        with:
+          scan-type: fs
+          scan-ref: .
+          severity: CRITICAL,HIGH
+          ignore-unfixed: true
+          exit-code: '1'
+
+  secrets:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Scan repository history for secrets
+        run: >-
+          docker run --rm -v "$PWD:/repo"
+          ghcr.io/gitleaks/gitleaks@sha256:c00b6bd0aeb3071cbcb79009cb16a60dd9e0a7c60e2be9ab65d25e6bc8abbb7f
+          detect --source=/repo --redact --no-banner
+
   docker:
     runs-on: ubuntu-latest
     needs: dotnet
     permissions:
       contents: read
       packages: write
+      id-token: write
+      attestations: write
 
     steps:
       - name: Checkout
@@ -105,5 +132,7 @@ jobs:
           labels: ${{ steps.meta.outputs.labels }}
           build-args: |
             GRIDPOOL_RELEASE_VERSION=${{ github.ref_name }}+${{ github.sha }}
+          sbom: true
+          provenance: mode=max
           cache-from: type=gha
           cache-to: type=gha,mode=max
diff --git a/.gitleaksignore b/.gitleaksignore
new file mode 100644
index 0000000..5407cef
--- /dev/null
+++ b/.gitleaksignore
@@ -0,0 +1,9 @@
+# Audited historical fixtures and retired prototype identities.
+7ded520203d0c6859e1de70892651e12be8605c0:scripts/main-beta-status.sh:curl-auth-user:36
+428a84391ec4bc119cb32391ce933cfd318ca8e4:boot.tests/PoolConfigValidatorTests.cs:generic-api-key:142
+a636ac92f856e35fff3c7438d5d3acbfdf24b7d4:boot_portal/boot_portal_config.json:generic-api-key:3
+07f8da37b297264cbc349ecc695c705e59392f6a:boot_portal/boot_portal_config.json:generic-api-key:2
+07f8da37b297264cbc349ecc695c705e59392f6a:boot_portal/boot_portal_config.json:generic-api-key:3
+2df39a9959680f42455d178d661912af37a627ac:boot_portal/boot_portal_config.json:generic-api-key:3
+f8d788e4b771aea87f39a9b6ba9b19e86eb90dd3:boot_portal/boot_portal_config.json:generic-api-key:3
+f8d788e4b771aea87f39a9b6ba9b19e86eb90dd3:boot_portal/boot_portal_config.json:generic-api-key:2
diff --git a/Dockerfile b/Dockerfile
index bce2fa8..f37278a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,23 +1,23 @@
 ARG GRIDPOOL_RELEASE_VERSION=dev
 
-FROM node:24-bookworm-slim AS dashboard-build
+FROM node:24-bookworm-slim@sha256:ba849c60be29959425b8734d57b8b4b7d56f98edd9504c9af091d5281095a71e AS dashboard-build
 WORKDIR /src/boot_portal/ui
 COPY boot_portal/ui/package.json boot_portal/ui/package-lock.json ./
 RUN npm ci
 COPY boot_portal/ui/ ./
 RUN npm run build
 
-FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:10.0@sha256:4ea6fe75dd36706bb6d8c3c293d4c4315840f5d76ea28ac97def77e3ec487fa5 AS build
 WORKDIR /src
 
 COPY boot_portal/boot_portal.csproj boot_portal/
-RUN dotnet restore boot_portal/boot_portal.csproj
+RUN dotnet restore boot_portal/boot_portal.csproj --locked-mode
 
 COPY . .
 COPY --from=dashboard-build /src/boot_portal/wwwroot/dashboard boot_portal/wwwroot/dashboard
 RUN dotnet publish boot_portal/boot_portal.csproj -c Release -o /app/publish /p:UseAppHost=false
 
-FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble AS runtime
+FROM mcr.microsoft.com/dotnet/aspnet:10.0-noble@sha256:1fe86375600b62e6566b465da9553eef0621f13c67f40fe764cd8dbb1dee1497 AS runtime
 RUN apt-get update \
     && apt-get install -y --no-install-recommends libsodium23 ca-certificates curl \
     && rm -rf /var/lib/apt/lists/* \
diff --git a/boot.tests/BitcoinHashesTests.cs b/boot.tests/BitcoinHashesTests.cs
new file mode 100644
index 0000000..f508c67
--- /dev/null
+++ b/boot.tests/BitcoinHashesTests.cs
@@ -0,0 +1,35 @@
+using boot_portal.Utils;
+
+namespace boot.tests;
+
+[TestClass]
+public sealed class BitcoinHashesTests
+{
+    private const string RegtestGenesisHeader =
+        "01000000" +
+        "0000000000000000000000000000000000000000000000000000000000000000" +
+        "3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a" +
+        "dae5494d" +
+        "ffff7f20" +
+        "02000000";
+
+    [TestMethod]
+    public void RegtestPowLimitAcceptsRegtestGenesisAndMainnetRejectsIt()
+    {
+        BitcoinHeaderEvaluation regtest = BitcoinHashes.EvaluateHeader(
+            RegtestGenesisHeader,
+            DateTime.UtcNow,
+            BitcoinScript.Regtest);
+        BitcoinHeaderEvaluation mainnet = BitcoinHashes.EvaluateHeader(
+            RegtestGenesisHeader,
+            DateTime.UtcNow,
+            BitcoinScript.Mainnet);
+
+        Assert.IsTrue(regtest.IsValid, regtest.RejectionReason);
+        Assert.AreEqual(
+            "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
+            regtest.BlockHash);
+        Assert.IsFalse(mainnet.IsValid);
+        StringAssert.Contains(mainnet.RejectionReason, "proof-of-work limit");
+    }
+}
diff --git a/boot.tests/BitcoinRpcClientTests.cs b/boot.tests/BitcoinRpcClientTests.cs
index 911f564..a655f4c 100644
--- a/boot.tests/BitcoinRpcClientTests.cs
+++ b/boot.tests/BitcoinRpcClientTests.cs
@@ -23,7 +23,7 @@ public async Task ClientParsesBlockchainAndZmqResponsesWithoutEmbeddingCredentia
             string result = method switch
             {
                 "getblockchaininfo" => """
-                    {"blocks":100,"headers":100,"bestblockhash":"block-100","initialblockdownload":false,"verificationprogress":1.0}
+                    {"chain":"regtest","blocks":100,"headers":100,"bestblockhash":"block-100","initialblockdownload":false,"verificationprogress":1.0}
                     """,
                 "getzmqnotifications" => """
                     [{"type":"pubhashblock","address":"tcp://0.0.0.0:28332"},{"type":"pubrawblock","address":"tcp://0.0.0.0:28333"}]
@@ -46,6 +46,7 @@ public async Task ClientParsesBlockchainAndZmqResponsesWithoutEmbeddingCredentia
 
         Assert.AreEqual(100L, info.Blocks);
         Assert.AreEqual("block-100", info.BestBlockHash);
+        Assert.AreEqual("regtest", info.Chain);
         CollectionAssert.AreEquivalent(
             new[] { "pubhashblock", "pubrawblock" },
             topics.Select(topic => topic.Topic).ToArray());
diff --git a/boot.tests/BitcoinRpcRecoveryPlannerTests.cs b/boot.tests/BitcoinRpcRecoveryPlannerTests.cs
index db12be7..3fb8c13 100644
--- a/boot.tests/BitcoinRpcRecoveryPlannerTests.cs
+++ b/boot.tests/BitcoinRpcRecoveryPlannerTests.cs
@@ -42,12 +42,12 @@ public void SameHeightReplacementUsesReorganizationPath()
             100,
             "new-block-100");
 
-        CollectionAssert.AreEqual(new long[] { 100 }, plan.Heights.ToArray());
+        CollectionAssert.AreEqual(new long[] { 99, 100 }, plan.Heights.ToArray());
         Assert.IsTrue(plan.Reorganization);
     }
 
     [TestMethod]
-    public void LowerRpcHeightPausesUntilReplacementChainCatchesUp()
+    public void LowerRpcHeightReplaysReplacementTipAndParent()
     {
         BitcoinRpcRecoveryPlan plan = BitcoinRpcRecoveryPlanner.Build(
             101,
@@ -55,7 +55,7 @@ public void LowerRpcHeightPausesUntilReplacementChainCatchesUp()
             100,
             "replacement-block-100");
 
-        Assert.AreEqual(0, plan.Heights.Count);
+        CollectionAssert.AreEqual(new long[] { 99, 100 }, plan.Heights.ToArray());
         Assert.IsTrue(plan.Reorganization);
     }
 
diff --git a/boot.tests/BitcoinZmqNotificationTests.cs b/boot.tests/BitcoinZmqNotificationTests.cs
index 461d680..6004672 100644
--- a/boot.tests/BitcoinZmqNotificationTests.cs
+++ b/boot.tests/BitcoinZmqNotificationTests.cs
@@ -128,7 +128,7 @@ public void AttachedNodeRequiresSynchronizedRpcAndRedactsErrors()
             BitcoinRpcUrl = "http://bitcoin:8332",
             BitcoinRpcLagGraceSeconds = 1
         });
-        DateTime nowUtc = DateTime.UtcNow;
+        DateTime nowUtc = DateTime.UtcNow.AddSeconds(2);
         health.RecordRpcFailure(
             "failed http://alice:secret@bitcoin:8332/wallet/private?token=secret",
             nowUtc.AddSeconds(-2));
@@ -188,4 +188,22 @@ public void BitcoinPeerTelemetryUsesStableProcessLocalVisualIds()
         Assert.AreNotEqual(7L, first);
         Assert.AreEqual(first, second);
     }
+
+    [TestMethod]
+    public void RepeatedRpcFailuresCannotRenewMiningSafetyGracePeriod()
+    {
+        var health = new BitcoinNotificationHealth(new PoolConfig
+        {
+            BitcoinNotificationMode = BitcoinNotificationModes.AttachedNode,
+            BitcoinRpcUrl = "http://bitcoin:8332",
+            BitcoinRpcLagGraceSeconds = 1
+        });
+        DateTime afterGrace = DateTime.UtcNow.AddSeconds(2);
+
+        health.RecordRpcFailure("warmup", afterGrace.AddMilliseconds(-500));
+        health.RecordRpcFailure("still warming up", afterGrace);
+
+        Assert.IsFalse(health.IsMiningSafe(afterGrace, out string reason));
+        StringAssert.Contains(reason, "unreachable");
+    }
 }
diff --git a/boot.tests/PoolConfigValidatorTests.cs b/boot.tests/PoolConfigValidatorTests.cs
index 3e8f0dd..42e69c2 100644
--- a/boot.tests/PoolConfigValidatorTests.cs
+++ b/boot.tests/PoolConfigValidatorTests.cs
@@ -7,13 +7,20 @@ namespace boot.tests;
 [TestClass]
 public sealed class PoolConfigValidatorTests
 {
+    private const string MainnetPayoutAddress = "bc1qd9m04z95mglaxd9e9accmhyjdlmkfmzjprkq4p";
+
     [TestMethod]
-    public void DefaultCoinbaseTagIsGridPool()
+    public void SetupUiMayStartWithoutPayoutButHeadlessModeCannot()
     {
         var config = new PoolConfig();
 
         Assert.AreEqual("Grid Pool", config.CoinbaseTag);
-        CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
+        Assert.IsFalse(PoolConfigValidator.Validate(config).Any(error =>
+            error.Contains("pool_payout_script", StringComparison.OrdinalIgnoreCase)));
+
+        config.EnableWebUi = false;
+        Assert.IsTrue(PoolConfigValidator.Validate(config).Any(error =>
+            error.Contains("pool_payout_script", StringComparison.OrdinalIgnoreCase)));
     }
 
     [TestMethod]
@@ -130,7 +137,9 @@ public void EmptyCoinbaseTagIsAllowed()
     {
         var config = new PoolConfig
         {
-            CoinbaseTag = string.Empty
+            CoinbaseTag = string.Empty,
+            PoolPayoutScript = MainnetPayoutAddress,
+            EnableAdminApi = false
         };
 
         CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
@@ -207,6 +216,7 @@ public void Testnet4AcceptsTestnetPayoutAddressAndRejectsMainnetAddress()
         {
             BitcoinNetwork = BitcoinScript.Testnet4,
             PoolPayoutScript = testnetAddress,
+            EnableAdminApi = false
         };
 
         CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(validConfig));
@@ -222,7 +232,7 @@ public void UnsupportedBitcoinNetworkFailsValidation()
     {
         var config = new PoolConfig
         {
-            BitcoinNetwork = "regtest"
+            BitcoinNetwork = "signet"
         };
 
         List<string> errors = PoolConfigValidator.Validate(config);
@@ -230,6 +240,58 @@ public void UnsupportedBitcoinNetworkFailsValidation()
         Assert.IsTrue(errors.Any(error => error.Contains("bitcoin_network", StringComparison.OrdinalIgnoreCase)));
     }
 
+    [TestMethod]
+    public void RegtestUsesBcrtAddressesAndRejectsMainnetAddresses()
+    {
+        byte[] script = Enumerable.Range(0, 22).Select(i => (byte)i).ToArray();
+        script[0] = 0x00;
+        script[1] = 0x14;
+        string regtestAddress = BitcoinScript.ScriptToAddress(script, BitcoinScript.Regtest);
+        var config = new PoolConfig
+        {
+            BitcoinNetwork = BitcoinScript.Regtest,
+            PoolPayoutScript = regtestAddress,
+            EnableAdminApi = false
+        };
+
+        Assert.IsTrue(regtestAddress.StartsWith("bcrt1", StringComparison.OrdinalIgnoreCase));
+        CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
+
+        config.PoolPayoutScript = "bc1qrwsx8fs0l6z7ugp5cvzy6lhss7jlyru3kg9s8y";
+        Assert.IsTrue(PoolConfigValidator.Validate(config).Any(error =>
+            error.Contains("pool_payout_script", StringComparison.OrdinalIgnoreCase)));
+    }
+
+    [TestMethod]
+    public void EmptySnapshotBootstrapIsRestrictedToNonProductionRegtest()
+    {
+        var regtest = new PoolConfig
+        {
+            BitcoinNetwork = BitcoinScript.Regtest,
+            NodeMode = "development",
+            AllowEmptySnapshotBootstrap = true
+        };
+        var mainnet = new PoolConfig
+        {
+            BitcoinNetwork = BitcoinScript.Mainnet,
+            NodeMode = "development",
+            AllowEmptySnapshotBootstrap = true
+        };
+        var productionRegtest = new PoolConfig
+        {
+            BitcoinNetwork = BitcoinScript.Regtest,
+            NodeMode = "production",
+            AllowEmptySnapshotBootstrap = true
+        };
+
+        Assert.IsFalse(PoolConfigValidator.Validate(regtest).Any(error =>
+            error.Contains("allow_empty_snapshot_bootstrap", StringComparison.OrdinalIgnoreCase)));
+        Assert.IsTrue(PoolConfigValidator.Validate(mainnet).Any(error =>
+            error.Contains("allow_empty_snapshot_bootstrap", StringComparison.OrdinalIgnoreCase)));
+        Assert.IsTrue(PoolConfigValidator.Validate(productionRegtest).Any(error =>
+            error.Contains("allow_empty_snapshot_bootstrap", StringComparison.OrdinalIgnoreCase)));
+    }
+
     [TestMethod]
     public void BadRateLimitFailsValidation()
     {
@@ -250,7 +312,9 @@ public void SovereignModeIsAcceptedForInstallerNodes()
         {
             NodeMode = "sovereign",
             PublicBaseUrl = "http://edge-node.local:5000",
-            DatumPublicHost = "edge-node.local"
+            DatumPublicHost = "edge-node.local",
+            PoolPayoutScript = MainnetPayoutAddress,
+            EnableAdminApi = false
         };
 
         CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
@@ -301,7 +365,8 @@ public void ProductionAcceptsExplicitPublicEndpoints()
             PublicBaseUrl = "https://use1.gridlabs.science",
             DatumPublicHost = "datum-use1.gridlabs.science",
             EnableAdminApi = false,
-            TestingRoundResetMode = "none"
+            TestingRoundResetMode = "none",
+            PoolPayoutScript = MainnetPayoutAddress
         };
 
         CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
@@ -335,7 +400,8 @@ public void ProductionAcceptsStrongAdminKeyWhenAdminApiIsEnabled()
             DatumPublicHost = "datum-use1.gridlabs.science",
             EnableAdminApi = true,
             AdminApiKey = new string('a', 32),
-            TestingRoundResetMode = "none"
+            TestingRoundResetMode = "none",
+            PoolPayoutScript = MainnetPayoutAddress
         };
 
         CollectionAssert.AreEqual(Array.Empty<string>(), PoolConfigValidator.Validate(config));
diff --git a/boot.tests/SecurityHardeningTests.cs b/boot.tests/SecurityHardeningTests.cs
new file mode 100644
index 0000000..6ba03aa
--- /dev/null
+++ b/boot.tests/SecurityHardeningTests.cs
@@ -0,0 +1,95 @@
+using System.Net;
+using boot_portal.Controllers;
+using boot_portal.Models;
+using boot_portal.Services;
+using boot_portal.Utils;
+
+namespace boot.tests;
+
+[TestClass]
+public sealed class SecurityHardeningTests
+{
+    private const string MainnetPayoutAddress = "bc1qd9m04z95mglaxd9e9accmhyjdlmkfmzjprkq4p";
+
+    [TestMethod]
+    public void DatumResourceBoundsAreValidated()
+    {
+        var config = ValidConfig();
+        config.DatumMaxConnections = 0;
+        config.DatumReadTimeoutSeconds = 0;
+
+        List<string> errors = PoolConfigValidator.Validate(config);
+
+        Assert.IsTrue(errors.Any(error => error.Contains("datum_max_connections", StringComparison.OrdinalIgnoreCase)));
+        Assert.IsTrue(errors.Any(error => error.Contains("datum_read_timeout_seconds", StringComparison.OrdinalIgnoreCase)));
+    }
+
+    [TestMethod]
+    public void AdminApiRequiresStrongKeyInSovereignMode()
+    {
+        var config = ValidConfig();
+        config.EnableAdminApi = true;
+        config.AdminApiKey = "change-this-admin-key";
+
+        Assert.IsTrue(PoolConfigValidator.Validate(config).Any(error =>
+            error.Contains("admin_api_key", StringComparison.OrdinalIgnoreCase)));
+    }
+
+    [TestMethod]
+    public void StoredMinerLabelIsBoundedAndMarkupFree()
+    {
+        string normalized = BootShareVerifier.NormalizeUsernameForStorage(
+            "<img src=x onerror=alert(1)>worker/../../" + new string('x', 256),
+            MainnetPayoutAddress);
+
+        Assert.IsTrue(normalized.Length <= 128);
+        Assert.IsFalse(normalized.Contains('<'));
+        Assert.IsFalse(normalized.Contains('>'));
+        Assert.IsFalse(normalized.Contains('/'));
+        Assert.IsTrue(normalized.All(value => char.IsAsciiLetterOrDigit(value) || value is '.' or '_' or '-' or ':'));
+    }
+
+    [DataTestMethod]
+    [DataRow("127.0.0.1")]
+    [DataRow("10.1.2.3")]
+    [DataRow("172.16.0.1")]
+    [DataRow("192.168.1.1")]
+    [DataRow("169.254.1.1")]
+    [DataRow("100.64.0.1")]
+    [DataRow("224.0.0.1")]
+    [DataRow("::1")]
+    [DataRow("fe80::1")]
+    [DataRow("fc00::1")]
+    public void ReachabilityProbeRejectsNonPublicDestinations(string value)
+    {
+        Assert.IsTrue(BootNetworkController.IsNonPublicAddress(IPAddress.Parse(value)));
+    }
+
+    [TestMethod]
+    public void ReachabilityProbeAcceptsPublicUnicastDestination()
+    {
+        Assert.IsFalse(BootNetworkController.IsNonPublicAddress(IPAddress.Parse("1.1.1.1")));
+    }
+
+    [TestMethod]
+    public void PeerBundleFetchLimiterBoundsChangingStateIdsPerPeer()
+    {
+        var limiter = new PeerBundleFetchLimiter(2, TimeSpan.FromMinutes(1));
+        DateTime start = new(2026, 8, 19, 0, 0, 0, DateTimeKind.Utc);
+
+        Assert.IsTrue(limiter.TryAcquire("https://peer.example", start));
+        Assert.IsTrue(limiter.TryAcquire("https://peer.example", start.AddSeconds(1)));
+        Assert.IsFalse(limiter.TryAcquire("https://peer.example", start.AddSeconds(2)));
+        Assert.IsTrue(limiter.TryAcquire("https://other.example", start.AddSeconds(2)));
+        Assert.IsTrue(limiter.TryAcquire("https://peer.example", start.AddMinutes(1).AddSeconds(1)));
+    }
+
+    private static PoolConfig ValidConfig()
+    {
+        return new PoolConfig
+        {
+            PoolPayoutScript = MainnetPayoutAddress,
+            EnableAdminApi = false
+        };
+    }
+}
diff --git a/boot.tests/ShareAttributionTests.cs b/boot.tests/ShareAttributionTests.cs
index 0d17927..bccf308 100644
--- a/boot.tests/ShareAttributionTests.cs
+++ b/boot.tests/ShareAttributionTests.cs
@@ -397,6 +397,38 @@ public async Task LocalBitcoinConfirmationPromotesStoredCandidateExactlyOnceAsyn
         Assert.AreEqual(confirmed.CurrentStateId, duplicate.CurrentStateId);
     }
 
+    [TestMethod]
+    public async Task NotificationFirstExceptionRequiresExactLocallyValidatedActiveChainBlockAsync()
+    {
+        using var harness = TestHarness.Create(currentTipBlockHash: RecentBlockParentHash);
+        harness.Config.BitcoinNotificationMode = BitcoinNotificationModes.AttachedNode;
+        Assert.IsTrue(harness.StateService.ObserveLocalChainTipHeader(
+            RecentBlockHeaderHex,
+            "rpc-reconcile",
+            DateTime.UtcNow,
+            945001));
+        await harness.StateService.ObserveChainTipAsync(RecentBlockHash, "rpc-reconcile", 945001);
+
+        var method = typeof(BootProtocolStateService).GetMethod(
+            "IsLocallyConfirmedCurrentBlockShareNoLock",
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!;
+        bool exactMatch = (bool)method.Invoke(harness.StateService, [new BootShareHeaderEvaluationResult
+        {
+            IsValid = true,
+            IsBlock = true,
+            BlockHash = RecentBlockHash
+        }])!;
+        bool differentHash = (bool)method.Invoke(harness.StateService, [new BootShareHeaderEvaluationResult
+        {
+            IsValid = true,
+            IsBlock = true,
+            BlockHash = "0000000000000000000000000000000000000000000000000000000000000076"
+        }])!;
+
+        Assert.IsTrue(exactMatch);
+        Assert.IsFalse(differentHash);
+    }
+
     [TestMethod]
     public async Task PeerShareWithForgedMinerAddressIsAcceptedAndAttributedToSlotZeroAsync()
     {
@@ -588,23 +620,23 @@ public async Task ProoflessBootstrapCannotInstallRemoteWinnersOrPaidLineageAsync
     [TestMethod]
     public async Task ProofBackedRemoteStateCannotRewriteUnverifiedPaidLineageAsync()
     {
-        using var remoteHarness = TestHarness.Create(currentTipBlockHash: OlderTipBlockHash);
-        ShareRecordingResult shareResult = await remoteHarness.StateService.SubmitShareAsync(
-            new RecordedShareSubmission
-            {
-                MinerAddress = AlternateAddress,
-                Username = string.Empty,
-                HeaderHex = SampleHeaderHex,
-                CoinbaseHex = SampleCoinbaseHex,
-                MerklePath = SampleMerklePath.ToList(),
-                PrevBlockHash = SamplePrevBlockHash,
-                Source = "datum"
-            },
-            "datum-block");
-        Assert.IsTrue(shareResult.Accepted, shareResult.RejectionReason);
+        byte[] header = Convert.FromHexString(SampleHeaderHex);
+        var proofSet = new List<BootShareProof>();
+        for (uint nonce = 0; nonce < 16; nonce++)
+        {
+            BinaryPrimitives.WriteUInt32LittleEndian(header.AsSpan(76, 4), nonce);
+            proofSet.Add(CreateValidatedProof(
+                Convert.ToHexString(header).ToLowerInvariant(),
+                SamplePrevBlockHash,
+                "seed-current"));
+        }
+
+        using var remoteHarness = TestHarness.Create(
+            currentTipBlockHash: SamplePrevBlockHash,
+            onDeckProofs: proofSet);
 
         RoundRotationResult rotation = await remoteHarness.StateService.RotateToNextRoundAsync(
-            SamplePrevBlockHash,
+            OlderTipBlockHash,
             "test-rotation",
             manual: false,
             blockHeight: 945001,
@@ -613,11 +645,11 @@ public async Task ProofBackedRemoteStateCannotRewriteUnverifiedPaidLineageAsync(
         Assert.IsTrue(remoteBundle.WorkSetProofs.Count > 0);
 
         using var localHarness = TestHarness.Create(
-            currentTipBlockHash: SamplePrevBlockHash,
+            currentTipBlockHash: OlderTipBlockHash,
             currentRoundNumber: remoteBundle.CurrentRoundNumber);
         bool adopted = await localHarness.StateService.TryAdoptCurrentStateAsync(
             remoteBundle,
-            SamplePrevBlockHash,
+            OlderTipBlockHash,
             945001,
             "https://peer.example");
 
@@ -628,7 +660,7 @@ public async Task ProofBackedRemoteStateCannotRewriteUnverifiedPaidLineageAsync(
     }
 
     [TestMethod]
-    public async Task DatumShareOnFreshParentIsAcceptedAndLearnsParentWithoutTipAdvanceAsync()
+    public async Task DatumShareCannotTeachNodeAnUnvalidatedFreshParentAsync()
     {
         using var harness = TestHarness.Create(currentTipBlockHash: OlderTipBlockHash);
 
@@ -643,17 +675,17 @@ public async Task DatumShareOnFreshParentIsAcceptedAndLearnsParentWithoutTipAdva
             Source = "datum"
         }, "datum-block");
 
-        Assert.IsTrue(result.Accepted, result.RejectionReason);
-        Assert.AreEqual(SamplePrevBlockHash, result.AcceptedProof?.PrevBlockHash);
+        Assert.IsFalse(result.Accepted);
+        StringAssert.Contains(result.RejectionReason, "outside the active Bitcoin tip");
 
         BootNetworkStatusDto status = harness.StateService.GetNetworkStatus();
         Assert.AreEqual(OlderTipBlockHash, status.CurrentTipBlockHash);
-        Assert.AreEqual(1, harness.StateService.GetOnDeckList().Count);
+        Assert.AreEqual(0, harness.StateService.GetOnDeckList().Count);
 
         Thread.Sleep(1200);
         PoolState persisted = JsonSerializer.Deserialize<PoolState>(File.ReadAllText(harness.StatePath))!;
         CollectionAssert.Contains(persisted.AcceptedParentBlockHashes, OlderTipBlockHash);
-        CollectionAssert.Contains(persisted.AcceptedParentBlockHashes, SamplePrevBlockHash);
+        CollectionAssert.DoesNotContain(persisted.AcceptedParentBlockHashes, SamplePrevBlockHash);
     }
 
     [TestMethod]
@@ -1363,7 +1395,7 @@ await harness.StateService.ObserveChainTipAsync(
             "test");
 
         Assert.IsFalse(result.Accepted);
-        Assert.AreEqual("New previous-parent proof rejected after the local snapshot boundary.", result.RejectionReason);
+        StringAssert.Contains(result.RejectionReason, "outside the active Bitcoin tip");
         Assert.AreEqual(0, harness.StateService.GetNetworkStatus().WorkSetCount);
     }
 
@@ -1431,6 +1463,73 @@ public async Task V22SiblingBoundaryRaceConvergesWithoutBranchVotingAndV21DoesNo
         Assert.AreNotEqual(v21Alice.StateService.GetNetworkStatus().ActiveSnapshotId, v21Bob.StateService.GetNetworkStatus().ActiveSnapshotId);
     }
 
+    [TestMethod]
+    public async Task RegtestSiblingImportAcceptsProofRecordedAgainstExplicitEmptyBootstrapSnapshotAsync()
+    {
+        using var bootstrap = TestHarness.Create(
+            bitcoinNetwork: BitcoinScript.Regtest,
+            allowEmptySnapshotBootstrap: true);
+        var computeStateId = typeof(BootProtocolStateService).GetMethod(
+            "ComputeStateIdNoLock",
+            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!;
+        string emptySnapshotId = (string)computeStateId.Invoke(
+            bootstrap.StateService,
+            [Array.Empty<BootShareProof>(), SamplePrevBlockHash])!;
+        var emptyContext = new BootPayoutSnapshotContext
+        {
+            SnapshotId = emptySnapshotId,
+            CurrentRoundNumber = 1,
+            LockedByBlockHash = SamplePrevBlockHash,
+            LockedByBlockHeight = 945000,
+            CreatedAtUtc = DateTime.UtcNow,
+            SupportFeeEnabled = false,
+            PayoutVariant = "fee-free:shared=299:snapshot=299:reserve=897",
+            ProofIds = [],
+            WinnersList = [],
+            FeeFreeWinnersList = []
+        };
+
+        string emptyPlanCoinbase = BuildCoinbaseWithWinnerPrefix(SampleCoinbaseHex, positiveWinnerCount: 0);
+        string emptyPlanHeader = RewriteHeaderMerkleRoot(SampleHeaderHex, emptyPlanCoinbase);
+        BootShareProof firstProof = CreateValidatedProofForSnapshot(
+            emptyPlanHeader,
+            emptyPlanCoinbase,
+            SamplePrevBlockHash,
+            emptySnapshotId,
+            []);
+        string boundary = "0000000000000000000000000000000000000000000000000000000000b07601";
+
+        using var online = TestHarness.Create(
+            currentStateId: emptySnapshotId,
+            winnersList: [],
+            onDeckProofs: [firstProof],
+            snapshotContexts: [emptyContext],
+            activeSnapshotId: emptySnapshotId,
+            bitcoinNetwork: BitcoinScript.Regtest,
+            allowEmptySnapshotBootstrap: true);
+        using var rejoining = TestHarness.Create(
+            currentStateId: emptySnapshotId,
+            winnersList: [],
+            snapshotContexts: [emptyContext],
+            activeSnapshotId: emptySnapshotId,
+            bitcoinNetwork: BitcoinScript.Regtest,
+            allowEmptySnapshotBootstrap: true);
+
+        await online.StateService.ObserveChainTipAsync(boundary, "local-bitcoin", 945001);
+        await rejoining.StateService.ObserveChainTipAsync(boundary, "local-bitcoin", 945001);
+        BootStateBundle sibling = online.StateService.GetStateBundle(
+            online.StateService.GetNetworkStatus().CurrentStateId)!;
+
+        Assert.IsTrue(await rejoining.StateService.TryAdoptCurrentStateAsync(
+            sibling,
+            boundary,
+            945001,
+            "online-regtest-peer"));
+        Assert.AreEqual(
+            online.StateService.GetNetworkStatus().ActiveSnapshotId,
+            rejoining.StateService.GetNetworkStatus().ActiveSnapshotId);
+    }
+
     [TestMethod]
     public async Task V22HeightActivationUsesV21BelowHeightAndMsrAtAndAboveHeightAsync()
     {
@@ -1588,6 +1687,36 @@ public async Task V22RepeatedOneBlockReorgRoundTripsSnapshotAndCandidateIdsWitho
                 .ToArray());
     }
 
+    [TestMethod]
+    public async Task V22TwoBlockReorgRollsBackRemovedFamiliesBeforeReplacementAsync()
+    {
+        BootShareProof proof = CreateValidatedProof(SampleHeaderHex, SamplePrevBlockHash, "seed-current");
+        BootPayoutSnapshotContext predecessor = CreateSnapshotContext("seed-current", SampleExpectedWinners);
+        using var harness = TestHarness.Create(
+            sharedWinnerSlotCount: 1,
+            onDeckProofs: [proof],
+            snapshotContexts: [predecessor]);
+        string removedFirst = "0000000000000000000000000000000000000000000000000000000000a00601";
+        string removedSecond = "0000000000000000000000000000000000000000000000000000000000a00602";
+        string replacementFirst = "0000000000000000000000000000000000000000000000000000000000b00601";
+
+        await harness.StateService.ObserveChainTipAsync(removedFirst, "local-bitcoin", 945001);
+        BootNetworkStatusDto removed = await harness.StateService.ObserveChainTipAsync(
+            removedSecond,
+            "local-bitcoin",
+            945002);
+        BootNetworkStatusDto replacement = await harness.StateService.ObserveChainTipAsync(
+            replacementFirst,
+            "local-bitcoin-reorg",
+            945001);
+
+        Assert.AreNotEqual(removed.ActiveSnapshotFamilyId, replacement.ActiveSnapshotFamilyId);
+        Assert.AreEqual(replacementFirst, replacement.CurrentTipBlockHash);
+        Assert.AreEqual(945001L, replacement.CurrentTipBlockHeight);
+        Assert.AreEqual(1, replacement.WorkSetCount);
+        Assert.AreEqual(2, replacement.CurrentRoundNumber);
+    }
+
     [TestMethod]
     public async Task V22ReserveOnlySiblingAdditionDoesNotChangeActivePayoutSnapshotAsync()
     {
@@ -3140,7 +3269,9 @@ public static TestHarness Create(
             bool seedUnknownTipHeight = false,
             bool seedUnknownTrustedTip = false,
             bool enablePeerTipStaleProtection = false,
-            int peerTipGraceSeconds = 3)
+            int peerTipGraceSeconds = 3,
+            string bitcoinNetwork = BitcoinScript.Mainnet,
+            bool allowEmptySnapshotBootstrap = false)
         {
             string? previousStatePath = Environment.GetEnvironmentVariable("BOOT_PORTAL_STATE_PATH");
             string? previousHistoryPath = Environment.GetEnvironmentVariable("BOOT_PORTAL_HISTORY_PATH");
@@ -3154,10 +3285,14 @@ public static TestHarness Create(
             var config = new PoolConfig
             {
                 BootNetworkId = "testnet",
+                BitcoinNetwork = bitcoinNetwork,
                 BootProtocolVersion = protocolVersion ?? BootProtocolVersions.ConsensusVersion,
                 V22ActivationBlockHeight = v22ActivationBlockHeight,
                 WinnersListSize = sharedWinnerSlotCount ?? Math.Max(8, SampleExpectedWinners.Count),
-                PoolPayoutScript = SampleSlotZeroAddress,
+                PoolPayoutScript = BitcoinScript.ScriptToAddress(
+                    BitcoinScript.AddressToScriptPubKey(SampleSlotZeroAddress),
+                    bitcoinNetwork),
+                AllowEmptySnapshotBootstrap = allowEmptySnapshotBootstrap,
                 GridLabsSupportFeeEnabled = supportFeeEnabled,
                 WorkSetReserveMultiplier = workSetReserveMultiplier ?? 3,
                 EnablePeerTipStaleProtection = enablePeerTipStaleProtection,
@@ -3198,7 +3333,7 @@ public static TestHarness Create(
             var dashboardVisualization = new DashboardVisualizationJournalService();
             var stateService = new BootProtocolStateService(
                 config,
-                new BootShareVerifier(),
+                new BootShareVerifier(config),
                 new NoOpHubContext(),
                 NullLogger<BootProtocolStateService>.Instance,
                 dashboardVisualization: dashboardVisualization);
diff --git a/boot.tests/boot.tests.csproj b/boot.tests/boot.tests.csproj
index 8427d78..d974ca1 100644
--- a/boot.tests/boot.tests.csproj
+++ b/boot.tests/boot.tests.csproj
@@ -5,6 +5,8 @@
         <LangVersion>latest</LangVersion>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
+        <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+        <RestoreLockedMode Condition="'$(ContinuousIntegrationBuild)' == 'true'">true</RestoreLockedMode>
         <!--
           Displays error on console in addition to the log file. Note that this feature comes with a performance impact.
           For more information, visit https://learn.microsoft.com/dotnet/core/testing/unit-testing-platform-integration-dotnet-test#show-failure-per-test
@@ -14,6 +16,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\boot_portal\boot_portal.csproj" />
+      <PackageReference Include="System.Security.Cryptography.Xml" Version="9.0.19" PrivateAssets="all" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/boot.tests/packages.lock.json b/boot.tests/packages.lock.json
new file mode 100644
index 0000000..3c6eba8
--- /dev/null
+++ b/boot.tests/packages.lock.json
@@ -0,0 +1,231 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[17.11.1, )",
+        "resolved": "17.11.1",
+        "contentHash": "U3Ty4BaGoEu+T2bwSko9tWqWUOU16WzSFkq6U8zve75oRBMSLTBdMAZrVNNz1Tq12aCdDom9fcOcM9QZaFHqFg==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.11.1",
+          "Microsoft.TestPlatform.TestHost": "17.11.1"
+        }
+      },
+      "Microsoft.Testing.Extensions.CodeCoverage": {
+        "type": "Direct",
+        "requested": "[17.13.1, )",
+        "resolved": "17.13.1",
+        "contentHash": "Ok2HWJdOTzErMqLlWQZ/i2Fw05VWmgh1yhUWFYJAtUmCv6uJSgz/qAiriRgpTjZRWaKbb7HDaGfMgKSNcmaVfw==",
+        "dependencies": {
+          "Microsoft.DiaSymReader": "2.0.0",
+          "Microsoft.Extensions.DependencyModel": "6.0.1",
+          "Microsoft.Testing.Platform": "1.4.3",
+          "Newtonsoft.Json": "13.0.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport": {
+        "type": "Direct",
+        "requested": "[1.4.3, )",
+        "resolved": "1.4.3",
+        "contentHash": "JSy1dY8ZpNWV00NZBVAQuqJmC18LOszwRsIz4VSROK06FxoPOz5N19D6FHz9ZKJxn3XieoHWhbvuLFWdz9UJiw==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.4.3",
+          "Microsoft.Testing.Platform": "1.4.3"
+        }
+      },
+      "MSTest.Analyzers": {
+        "type": "Direct",
+        "requested": "[3.6.4, )",
+        "resolved": "3.6.4",
+        "contentHash": "4gU/VdItLebmE2+UkOaqffVmVa/in0VeIF9fmN/fG0tj5AHAasjasJcZa9U2uXBNX03cKCWlgWenlhKLz343NQ=="
+      },
+      "MSTest.TestAdapter": {
+        "type": "Direct",
+        "requested": "[3.6.4, )",
+        "resolved": "3.6.4",
+        "contentHash": "YdwseRA+nDhRqD2oPHjCE4KzLEN5B10A61lOslE3N3OvUwHJ6ezyZZjYWf7mrZ8jckCcx/UlBclTzgWUpMpPQw==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.VSTestBridge": "1.4.3",
+          "Microsoft.Testing.Platform.MSBuild": "1.4.3"
+        }
+      },
+      "MSTest.TestFramework": {
+        "type": "Direct",
+        "requested": "[3.6.4, )",
+        "resolved": "3.6.4",
+        "contentHash": "3nV+2CJluKmiJpCSqQfXu5idCq35+vqFywjScyauTIz0Zk7KJw7Qpzv8gtwow0To7pxIlIvwkq9rbMB+V6eOow=="
+      },
+      "System.Security.Cryptography.Xml": {
+        "type": "Direct",
+        "requested": "[9.0.19, )",
+        "resolved": "9.0.19",
+        "contentHash": "7kS3pe/XSt6dgWO+IZ/Xx4UuBDTxcDWjyTcB/OzZ4Y3SsUai5tHlElM6QFwJQnarrNloEH30l9TcFS+RnbfiLw==",
+        "dependencies": {
+          "System.Security.Cryptography.Pkcs": "9.0.19"
+        }
+      },
+      "AsyncIO": {
+        "type": "Transitive",
+        "resolved": "0.1.69",
+        "contentHash": "xyXJLi+wjy6AtIyWXHXJkPS0gItqVT4lg5w++7bA5YEjugYKdrFMGxCo6KUJ1yYwjriLQJ1g35LDljZs3Q90XQ=="
+      },
+      "BouncyCastle.Cryptography": {
+        "type": "Transitive",
+        "resolved": "2.6.1",
+        "contentHash": "vZsG2YILhthgRqO+ZVgRff4ZFKKTl0v7kqaVBLCtRvpREhfBP33pcWrdA3PRYgWuFL1RxiUFvjMUHTdBZlJcoA=="
+      },
+      "libsodium": {
+        "type": "Transitive",
+        "resolved": "1.0.20.1",
+        "contentHash": "pkiceEqJDQFHjbga3k/oPfTVX9g+GKJZ1VrkuiLhaymt9YNw1Dr7cX9hNuZuNaWcr9WD0moW55k4pMwzQ7JaZQ=="
+      },
+      "LibSodium.Net": {
+        "type": "Transitive",
+        "resolved": "0.16.0-alpha",
+        "contentHash": "uNW5uuT2QEu5zUSDAbNyXM/RPZjnLjMEp88uYMCkH2yr9+jX7LpZsV9JZimdIABKiHivfGqSJAXmj3Bd2tmJUQ==",
+        "dependencies": {
+          "libsodium": "1.0.20.1"
+        }
+      },
+      "Microsoft.ApplicationInsights": {
+        "type": "Transitive",
+        "resolved": "2.22.0",
+        "contentHash": "3AOM9bZtku7RQwHyMEY3tQMrHIgjcfRDa6YQpd/QG2LDGvMydSlL9Di+8LLMt7J2RDdfJ7/2jdYv6yHcMJAnNw=="
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "17.11.1",
+        "contentHash": "nPJqrcA5iX+Y0kqoT3a+pD/8lrW/V7ayqnEJQsTonSoPz59J8bmoQhcSN4G8+UJ64Hkuf0zuxnfuj2lkHOq4cA=="
+      },
+      "Microsoft.DiaSymReader": {
+        "type": "Transitive",
+        "resolved": "2.0.0",
+        "contentHash": "QcZrCETsBJqy/vQpFtJc+jSXQ0K5sucQ6NUFbTNVHD4vfZZOwjZ/3sBzczkC4DityhD3AVO/+K/+9ioLs1AgRA=="
+      },
+      "Microsoft.Extensions.DependencyModel": {
+        "type": "Transitive",
+        "resolved": "6.0.1",
+        "contentHash": "AdvrtrqZpMgW4tIAQ/8gE1LAM/FjFY8JrFdyiolOf9WLEfN3WuFG1Hje6n0jqaOs3ldZFGWhatJQHJRrIOd++w=="
+      },
+      "Microsoft.Extensions.ObjectPool": {
+        "type": "Transitive",
+        "resolved": "8.0.10",
+        "contentHash": "u7gAG7JgxF8VSJUGPSudAcPxOt+ymJKQCSxNRxiuKV+klCQbHljQR75SilpedCTfhPWDhtUwIJpnDVtspr9nMg=="
+      },
+      "Microsoft.Testing.Extensions.Telemetry": {
+        "type": "Transitive",
+        "resolved": "1.4.3",
+        "contentHash": "dh8jnqWikxQXJ4kWy8B82PtSAlQCnvDKh1128arDmSW5OU5xWA84HwruV3TanXi3ZjIHn1wWFCgtMOhcDNwBow==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.Testing.Platform": "1.4.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
+        "type": "Transitive",
+        "resolved": "1.4.3",
+        "contentHash": "16sWznD6ZMok/zgW+vrO6zerCFMD9N+ey9bi1iV/e9xxsQb4V4y/aW6cY/Y7E9jA7pc+aZ6ffZby43yxQOoYZA==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.4.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.VSTestBridge": {
+        "type": "Transitive",
+        "resolved": "1.4.3",
+        "contentHash": "xZ6oyNYh2aM5Wb+HJAy1fj2C4CNRVhINXHCjlWs/2C8hEIpdqVSpP3y6HWUN40KpFqyGD4myHGR1Rflm28UpcQ==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.TestPlatform.ObjectModel": "17.11.1",
+          "Microsoft.Testing.Extensions.Telemetry": "1.4.3",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.4.3",
+          "Microsoft.Testing.Platform": "1.4.3"
+        }
+      },
+      "Microsoft.Testing.Platform": {
+        "type": "Transitive",
+        "resolved": "1.4.3",
+        "contentHash": "NedIbwl1T7+ZMeg7gwk0Db8/RFLf0siyVpeTcRMMOle6Xl/ujaYOM4Aduo8rEfVqNj3kcQ7blegpyT3dHi+0PA=="
+      },
+      "Microsoft.Testing.Platform.MSBuild": {
+        "type": "Transitive",
+        "resolved": "1.4.3",
+        "contentHash": "1gGqgHtiZ6tZn/6Tby+qlKpNe5Ye/5LnxlSsyl4XMZ4m4V+Cu1K1m+gD1zxoxHIvLjgX8mCnQRK95MGBBFuumw==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.4.3"
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "17.11.1",
+        "contentHash": "E2jZqAU6JeWEVsyOEOrSW1o1bpHLgb25ypvKNB/moBXPVsFYBPd/Jwi7OrYahG50J83LfHzezYI+GaEkpAotiA=="
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "17.11.1",
+        "contentHash": "DnG+GOqJXO/CkoqlJWeDFTgPhqD/V6VqUIL3vINizCWZ3X+HshCtbbyDdSHQQEjrc2Sl/K3yaxX6s+5LFEdYuw==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.11.1",
+          "Newtonsoft.Json": "13.0.1"
+        }
+      },
+      "NaCl.Net": {
+        "type": "Transitive",
+        "resolved": "0.1.13",
+        "contentHash": "AVg1455RQnyTy6tiessudruZHvbl70QWRPyx3og2I1Fei17LDNc7Z3DRgqN2+PsySBui/1EDP4A7adhQXydi6g=="
+      },
+      "NetMQ": {
+        "type": "Transitive",
+        "resolved": "4.0.2.2",
+        "contentHash": "G2dNt5Fcv/wdZOwTkUksJBe8RUc4wJn38FTZw8UmH5tcEkPi3KM8ME8igJ1fR+1msNpEKfLzEfgJOA6RpOE1jA==",
+        "dependencies": {
+          "AsyncIO": "0.1.69",
+          "NaCl.Net": "0.1.13",
+          "System.ServiceModel.Primitives": "8.1.2"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "NSec.Cryptography": {
+        "type": "Transitive",
+        "resolved": "25.4.0",
+        "contentHash": "Z3wPpG0xefMLmhn9T+Ka/EzAmMQPT0THL/5E4lf9cXI/N9rbGH0G23ZFpRcPnD0ast2k7ieG6QSVNIjmfPCXBQ==",
+        "dependencies": {
+          "libsodium": "[1.0.20.1, 1.0.21)"
+        }
+      },
+      "System.CommandLine": {
+        "type": "Transitive",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "9.0.19",
+        "contentHash": "/T5xGxh3IT465U8rLzDvZDolVlLGqUqTunZNHSvkkRBkflblFBzvJO4qTzNwjCApygv81KIec8epg46X0h+yIw=="
+      },
+      "System.ServiceModel.Primitives": {
+        "type": "Transitive",
+        "resolved": "8.1.2",
+        "contentHash": "xlJ07FAUSDjPL/GhvVY1/KVPWn2ce056X4nHPwqAa5rkNLiNN5rqh6VcgMUoF6J7ckwhkVJ1vVx/K/47nyyR9g==",
+        "dependencies": {
+          "Microsoft.Extensions.ObjectPool": "8.0.10",
+          "System.Security.Cryptography.Xml": "8.0.2"
+        }
+      },
+      "boot_portal": {
+        "type": "Project",
+        "dependencies": {
+          "BouncyCastle.Cryptography": "[2.6.1, )",
+          "LibSodium.Net": "[0.16.0-alpha, )",
+          "NSec.Cryptography": "[25.4.0, )",
+          "NetMQ": "[4.0.2.2, )",
+          "System.CommandLine": "[2.0.0-beta4.22272.1, )"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/boot_portal/Controllers/BootNetworkController.cs b/boot_portal/Controllers/BootNetworkController.cs
index 3d7f0ca..2751903 100644
--- a/boot_portal/Controllers/BootNetworkController.cs
+++ b/boot_portal/Controllers/BootNetworkController.cs
@@ -2,7 +2,7 @@
 using boot_portal.Models;
 using System.Diagnostics;
 using System.Net;
-using System.Security.Cryptography;
+using System.Net.Sockets;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.RateLimiting;
 using boot_portal.Utils;
@@ -88,14 +88,19 @@ public async Task<IActionResult> RunReachabilityTest([FromBody] BootReachability
             return BadRequest(new { status = "rejected", reason = rejectionReason });
         }
 
+        if (!await IsPublicReachabilityTargetAsync(targetBaseUri, cancellationToken))
+        {
+            return BadRequest(new { status = "rejected", reason = "targetBaseUrl must resolve only to public unicast addresses" });
+        }
+
         var result = new BootReachabilityProbeResult
         {
             TargetBaseUrl = targetBaseUri.ToString().TrimEnd('/'),
             TestedAtUtc = DateTime.UtcNow,
-            ObservedRequesterIp = HttpContext.Connection.RemoteIpAddress?.ToString() ?? string.Empty
+            ObservedRequesterIp = string.Empty
         };
 
-        using HttpClient client = _httpClientFactory.CreateClient("BootPeerClient");
+        using HttpClient client = _httpClientFactory.CreateClient("ReachabilityProbeClient");
         await ProbeHttpAsync(client, new Uri(targetBaseUri, "/health"), cancellationToken, (status, latency, warning) =>
         {
             result.HttpStatusCode = status;
@@ -132,37 +137,8 @@ public async Task<IActionResult> RunReachabilityTest([FromBody] BootReachability
         if (request.IncludeUdpProbe && request.UdpPort is > 0 and <= 65535)
         {
             result.UdpProbeAttempted = true;
-            result.UdpHost = string.IsNullOrWhiteSpace(request.UdpHost)
-                ? targetBaseUri.Host
-                : request.UdpHost.Trim();
             result.UdpPort = request.UdpPort.Value;
-            string nonce = string.IsNullOrWhiteSpace(request.UdpChallengeNonce)
-                ? Convert.ToHexString(RandomNumberGenerator.GetBytes(16)).ToLowerInvariant()
-                : request.UdpChallengeNonce.Trim();
-            result.UdpChallengeNonce = nonce;
-            _udpRelayService.RegisterReachabilityChallenge(nonce, result.TargetBaseUrl);
-            string ackUrl = $"{Request.Scheme}://{Request.Host}/api/network/reachability-ack";
-            result.UdpProbeSent = await _udpRelayService.SendReachabilityProbeAsync(
-                result.UdpHost,
-                request.UdpPort.Value,
-                nonce,
-                ackUrl,
-                result.TargetBaseUrl,
-                cancellationToken);
-            if (result.UdpProbeSent)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(500), cancellationToken);
-                result.UdpChallengeAcknowledged = _udpRelayService.WasReachabilityChallengeAcknowledged(nonce);
-            }
-
-            if (!result.UdpProbeSent)
-            {
-                result.Warnings.Add("UDP probe could not be sent. This does not prove the UDP relay is unreachable.");
-            }
-            else if (!result.UdpChallengeAcknowledged)
-            {
-                result.Warnings.Add("UDP probe was sent, but no challenge ack was observed before the short timeout.");
-            }
+            result.Warnings.Add("Plaintext UDP reachability probes are disabled; use authenticated peer-session telemetry.");
         }
 
         result.Summary = BuildReachabilitySummary(result);
@@ -178,15 +154,7 @@ public async Task<IActionResult> RunReachabilityTest([FromBody] BootReachability
     [HttpPost("reachability-ack")]
     public IActionResult AckReachabilityProbe([FromBody] BootUdpReachabilityAckRequest? request)
     {
-        if (request == null || string.IsNullOrWhiteSpace(request.Nonce))
-        {
-            return BadRequest(new { status = "rejected", reason = "nonce is required" });
-        }
-
-        bool accepted = _udpRelayService.AcknowledgeReachabilityChallenge(
-            request.Nonce,
-            request.TargetBaseUrl);
-        return Ok(new { status = accepted ? "accepted" : "unknown", accepted });
+        return NotFound();
     }
 
     [EnableRateLimiting("admin-write")]
@@ -236,6 +204,79 @@ private static bool TryNormalizeReachabilityTarget(string target, out Uri? norma
         return true;
     }
 
+    internal static async Task<bool> IsPublicReachabilityTargetAsync(Uri target, CancellationToken cancellationToken)
+    {
+        IPAddress[] addresses;
+        try
+        {
+            addresses = await Dns.GetHostAddressesAsync(target.Host, cancellationToken);
+        }
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException or ArgumentException)
+        {
+            return false;
+        }
+
+        return addresses.Length > 0 && addresses.All(address => !IsNonPublicAddress(address));
+    }
+
+    internal static bool IsNonPublicAddress(IPAddress address)
+    {
+        if (address.IsIPv4MappedToIPv6)
+        {
+            address = address.MapToIPv4();
+        }
+
+        if (IPAddress.IsLoopback(address) || address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any))
+        {
+            return true;
+        }
+
+        byte[] bytes = address.GetAddressBytes();
+        if (address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
+        {
+            return bytes[0] == 0 || bytes[0] == 10 || bytes[0] == 127 || bytes[0] >= 224 ||
+                   (bytes[0] == 100 && bytes[1] is >= 64 and <= 127) ||
+                   (bytes[0] == 169 && bytes[1] == 254) ||
+                   (bytes[0] == 172 && bytes[1] is >= 16 and <= 31) ||
+                   (bytes[0] == 192 && bytes[1] == 168);
+        }
+
+        return address.IsIPv6LinkLocal || address.IsIPv6Multicast || address.IsIPv6SiteLocal ||
+               (bytes.Length == 16 && (bytes[0] & 0xfe) == 0xfc);
+    }
+
+    internal static async ValueTask<Stream> ConnectToPublicHostAsync(
+        SocketsHttpConnectionContext context,
+        CancellationToken cancellationToken)
+    {
+        IPAddress[] addresses = await Dns.GetHostAddressesAsync(context.DnsEndPoint.Host, cancellationToken);
+        IPAddress[] publicAddresses = addresses.Where(address => !IsNonPublicAddress(address)).ToArray();
+        if (publicAddresses.Length == 0 || publicAddresses.Length != addresses.Length)
+        {
+            throw new HttpRequestException("Reachability target resolved to a non-public address.");
+        }
+
+        Exception? lastError = null;
+        foreach (IPAddress address in publicAddresses)
+        {
+            var socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
+            try
+            {
+                await socket.ConnectAsync(
+                    new IPEndPoint(address, context.DnsEndPoint.Port),
+                    cancellationToken);
+                return new NetworkStream(socket, ownsSocket: true);
+            }
+            catch (Exception ex) when (ex is SocketException or OperationCanceledException)
+            {
+                socket.Dispose();
+                lastError = ex;
+            }
+        }
+
+        throw new HttpRequestException("Reachability target connection failed.", lastError);
+    }
+
     private static async Task ProbeHttpAsync(
         HttpClient client,
         Uri uri,
diff --git a/boot_portal/HostedServices/BitcoinRpcReconciliationService.cs b/boot_portal/HostedServices/BitcoinRpcReconciliationService.cs
index 64171c7..dda4b8c 100644
--- a/boot_portal/HostedServices/BitcoinRpcReconciliationService.cs
+++ b/boot_portal/HostedServices/BitcoinRpcReconciliationService.cs
@@ -69,6 +69,14 @@ internal async Task ReconcileAsync(CancellationToken cancellationToken)
         {
             BitcoinBlockchainInfo info = await _rpcClient.GetBlockchainInfoAsync(cancellationToken);
             string bestHash = await _rpcClient.GetBestBlockHashAsync(cancellationToken);
+            if (!string.IsNullOrWhiteSpace(info.Chain) && !RpcChainMatchesConfiguredNetwork(info.Chain))
+            {
+                _health.RecordRpcFailure(
+                    $"Attached Bitcoin RPC chain '{Sanitize(info.Chain)}' does not match configured bitcoin_network '{BitcoinScript.NormalizeNetwork(_config.BitcoinNetwork)}'.",
+                    checkUtc);
+                return;
+            }
+
             _health.RecordRpcSuccess(
                 info.Blocks,
                 info.Headers,
@@ -125,6 +133,19 @@ internal async Task ReconcileAsync(CancellationToken cancellationToken)
         }
     }
 
+    private bool RpcChainMatchesConfiguredNetwork(string rpcChain)
+    {
+        string configured = BitcoinScript.NormalizeNetwork(_config.BitcoinNetwork);
+        string actual = rpcChain.Trim().ToLowerInvariant();
+        return configured switch
+        {
+            BitcoinScript.Mainnet => actual == "main",
+            BitcoinScript.Testnet4 => actual is "testnet4" or "test",
+            BitcoinScript.Regtest => actual == "regtest",
+            _ => false
+        };
+    }
+
     private async Task InspectPeerNetworkAsync(DateTime checkUtc, CancellationToken cancellationToken)
     {
         try
@@ -175,21 +196,13 @@ private async Task<int> ReconcileTipAsync(
             localHash,
             rpcHeight,
             rpcBestHash);
-        if (plan.Reorganization && plan.Heights.Count == 0)
-        {
-            _health.RecordRpcTipMismatch(
-                $"Bitcoin RPC active height {rpcHeight} is behind GridPool observed height {localHeight}; waiting for the replacement chain before resuming mining.",
-                DateTime.UtcNow);
-            return 0;
-        }
-
         int recovered = 0;
         foreach (long height in plan.Heights)
         {
             string hash = height == rpcHeight
                 ? rpcBestHash
                 : await _rpcClient.GetBlockHashAsync(height, cancellationToken);
-            await ObserveRpcBlockAsync(height, hash, cancellationToken);
+            await ObserveRpcBlockAsync(height, hash, plan.Reorganization, cancellationToken);
             if (!plan.EstablishesBaseline)
             {
                 recovered++;
@@ -202,6 +215,7 @@ private async Task<int> ReconcileTipAsync(
     private async Task ObserveRpcBlockAsync(
         long height,
         string blockHash,
+        bool reorganization,
         CancellationToken cancellationToken)
     {
         string headerHex = await _rpcClient.GetBlockHeaderHexAsync(blockHash, cancellationToken);
@@ -213,7 +227,7 @@ private async Task ObserveRpcBlockAsync(
             height);
         await _stateService.ObserveChainTipAsync(
             blockHash,
-            "rpc-reconcile",
+            reorganization ? "rpc-reconcile-reorg" : "rpc-reconcile",
             height);
     }
 
diff --git a/boot_portal/HostedServices/BootPeerSyncService.cs b/boot_portal/HostedServices/BootPeerSyncService.cs
index 1eee8a0..508b25f 100644
--- a/boot_portal/HostedServices/BootPeerSyncService.cs
+++ b/boot_portal/HostedServices/BootPeerSyncService.cs
@@ -18,6 +18,7 @@ public class BootPeerSyncService : BackgroundService
     private readonly IHttpClientFactory _httpClientFactory;
     private readonly ILogger<BootPeerSyncService> _logger;
     private readonly BootPeerLoopHealth _loopHealth;
+    private readonly PeerBundleFetchLimiter _bundleFetchLimiter;
 
     public BootPeerSyncService(
         PoolConfig poolConfig,
@@ -35,6 +36,9 @@ public BootPeerSyncService(
         _httpClientFactory = httpClientFactory;
         _logger = logger;
         _loopHealth = loopHealth;
+        _bundleFetchLimiter = new PeerBundleFetchLimiter(
+            Math.Max(1, poolConfig.PeerStateBundleFetchRateLimitPerMinute),
+            TimeSpan.FromMinutes(1));
     }
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
@@ -306,6 +310,12 @@ private async Task PollPeerAsync(string peer, CancellationToken stoppingToken)
             !string.Equals(remote.CurrentStateId, local.CurrentStateId, StringComparison.OrdinalIgnoreCase) &&
             ShouldFetchRemoteCurrentState(local, remote))
         {
+            if (!_bundleFetchLimiter.TryAcquire(remoteEndpoint, DateTime.UtcNow))
+            {
+                RecordBundleFetchRateLimit(remoteEndpoint, remote.CurrentStateId);
+                return;
+            }
+
             BootStateBundle? lockedBundle = await client.GetFromJsonAsync<BootStateBundle>(
                 $"{remoteEndpoint}/api/network/state/{remote.CurrentStateId}",
                 stoppingToken);
@@ -349,12 +359,17 @@ await _stateService.TrySyncCurrentRoundMetadataAsync(
         }
 
         if (string.IsNullOrWhiteSpace(remote.CandidateStateId) ||
-            string.Equals(remote.CandidateStateId, local.CandidateStateId, StringComparison.OrdinalIgnoreCase) ||
-            remote.OnDeckTotalDifficulty <= local.OnDeckTotalDifficulty)
+            string.Equals(remote.CandidateStateId, local.CandidateStateId, StringComparison.OrdinalIgnoreCase))
         {
             return;
         }
 
+        if (!_bundleFetchLimiter.TryAcquire(remoteEndpoint, DateTime.UtcNow))
+        {
+            RecordBundleFetchRateLimit(remoteEndpoint, remote.CandidateStateId);
+            return;
+        }
+
         using HttpResponseMessage bundleResponse = await client.GetAsync(
             $"{remoteEndpoint}/api/network/state/{remote.CandidateStateId}",
             stoppingToken);
@@ -377,6 +392,18 @@ await _stateService.TrySyncCurrentRoundMetadataAsync(
         await _stateService.TryImportCandidateStateAsync(bundle, remoteEndpoint);
     }
 
+    private void RecordBundleFetchRateLimit(string remoteEndpoint, string stateId)
+    {
+        _logger.LogWarning(
+            "Deferred state bundle {StateId} from {Peer}: per-peer fetch budget exhausted.",
+            stateId,
+            remoteEndpoint);
+        _stateService.RecordExternalNetworkEvent(
+            "peer-state-bundle-fetch-rate-limited",
+            remoteEndpoint,
+            "Deferred outbound state bundle fetch because the peer exhausted its per-minute budget.");
+    }
+
     private async Task FetchPeerAddressesAsync(HttpClient client, string remoteEndpoint, CancellationToken stoppingToken)
     {
         try
diff --git a/boot_portal/HostedServices/DatumServer.cs b/boot_portal/HostedServices/DatumServer.cs
index 2c1e144..3928cb9 100644
--- a/boot_portal/HostedServices/DatumServer.cs
+++ b/boot_portal/HostedServices/DatumServer.cs
@@ -17,6 +17,7 @@ public class DatumServer : BackgroundService
     private readonly BootProtocolStateService _stateService;
     private readonly ILogger<DatumServer> _logger;
     private readonly ConcurrentDictionary<int, (TcpClient Client, ClientHandler Handler)> _activeClients = new();
+    private readonly SemaphoreSlim _connectionSlots;
     private int _nextClientId;
 
     public static BootProtocolStateService StateService { get; private set; } = null!;
@@ -43,6 +44,7 @@ public DatumServer(
         _poolConfig = poolConfig;
         _stateService = stateService;
         _logger = logger;
+        _connectionSlots = new SemaphoreSlim(poolConfig.DatumMaxConnections, poolConfig.DatumMaxConnections);
         StateService = stateService;
         PoolPort = port;
         _stateService.WinnersListChanged += HandleWinnersListChangedAsync;
@@ -70,6 +72,14 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         while (!stoppingToken.IsCancellationRequested)
         {
             var client = await _listener.AcceptTcpClientAsync(stoppingToken);
+            if (!_connectionSlots.Wait(0))
+            {
+                _logger.LogWarning(
+                    "Rejected DATUM connection because the configured limit of {Limit} active sessions was reached.",
+                    _poolConfig.DatumMaxConnections);
+                client.Dispose();
+                continue;
+            }
             int clientId = Interlocked.Increment(ref _nextClientId);
             var clientHandler = new ClientHandler(client, _serverKey, _serverXKey, _poolConfig, _stateService, stoppingToken);
             _activeClients[clientId] = (client, clientHandler);
@@ -83,6 +93,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
                 {
                     _activeClients.TryRemove(clientId, out _);
                     client.Dispose();
+                    _connectionSlots.Release();
                 }
             }, stoppingToken);
         }
diff --git a/boot_portal/Models/PoolConfig.cs b/boot_portal/Models/PoolConfig.cs
index 087945a..f7545d8 100644
--- a/boot_portal/Models/PoolConfig.cs
+++ b/boot_portal/Models/PoolConfig.cs
@@ -17,6 +17,9 @@ public class PoolConfig
     [JsonPropertyName("bitcoin_network")]
     public string BitcoinNetwork { get; set; } = BitcoinScript.Mainnet;
 
+    [JsonPropertyName("allow_empty_snapshot_bootstrap")]
+    public bool AllowEmptySnapshotBootstrap { get; set; } = false;
+
     [JsonPropertyName("pool_payout_script")]
     public string PoolPayoutScript { get; set; } = string.Empty;
 
@@ -191,6 +194,9 @@ public class PoolConfig
     [JsonPropertyName("peer_write_rate_limit_per_minute")]
     public int PeerWriteRateLimitPerMinute { get; set; } = 3000;
 
+    [JsonPropertyName("peer_state_bundle_fetch_rate_limit_per_minute")]
+    public int PeerStateBundleFetchRateLimitPerMinute { get; set; } = 12;
+
     [JsonPropertyName("enable_peer_persistent_sessions")]
     public bool EnablePeerPersistentSessions { get; set; } = true;
 
@@ -313,6 +319,12 @@ public class PoolConfig
     [JsonPropertyName("max_share_request_bytes")]
     public int MaxShareRequestBytes { get; set; } = 262144;
 
+    [JsonPropertyName("datum_max_connections")]
+    public int DatumMaxConnections { get; set; } = 32;
+
+    [JsonPropertyName("datum_read_timeout_seconds")]
+    public int DatumReadTimeoutSeconds { get; set; } = 15;
+
     [JsonPropertyName("max_coinbase_hex_chars")]
     public int MaxCoinbaseHexChars { get; set; } = 100000;
 
diff --git a/boot_portal/Pages/Legacy.cshtml b/boot_portal/Pages/Legacy.cshtml
index ece7b3b..f14f8d7 100644
--- a/boot_portal/Pages/Legacy.cshtml
+++ b/boot_portal/Pages/Legacy.cshtml
@@ -2202,9 +2202,9 @@
         const submittedBase = getBaseMinerAddress(submitted);
         const credited = getAttributionAddress(item);
         if (submitted && submittedBase && credited && normalizeSearchValue(submittedBase) !== normalizeSearchValue(credited)) {
-            return `Credited to ${label}; submitted username ${submitted}`;
+            return escapeHtml(`Credited to ${label}; submitted username ${submitted}`);
         }
-        return label;
+        return escapeHtml(label);
     }
 
     function minerMatchesSearch(item, term = currentSearchValue()) {
@@ -3449,7 +3449,7 @@
         if (kind === "manual-reset") return "manual";
         if (kind.startsWith("adopted-state:")) return "adopted";
         if (kind.startsWith("bootstrap-state:")) return "bootstrap";
-        return kind.replace(/[:_]/g, " ");
+        return String(kind).replace(/[^A-Za-z0-9 :_.-]/g, "_").replace(/[:_]/g, " ");
     }
 
     function roundHistoryDisplayOrder(history) {
@@ -4051,7 +4051,7 @@
         if (!recipients || recipients.length === 0) return "No payouts";
         return recipients.slice(0, 3).map(entry => {
             const label = formatAttributionLabel(entry);
-            return `${label} ${formatPercent(entry.totalValue, totalValue)}`;
+            return `${escapeHtml(label)} ${escapeHtml(formatPercent(entry.totalValue, totalValue))}`;
         }).join(" · ");
     }
 
@@ -4264,7 +4264,7 @@
 
             return recipients.map(item => `
                 <tr class="${recipientMatchesSearch(item) ? 'highlight-row' : ''}">
-                    <td class="${isLottery || isBusiness ? 'full-label' : 'compact-label'}" title="${attributionTitle(item)}">${formatAttributionLabel(item, isLottery || isBusiness)}</td>
+                    <td class="${isLottery || isBusiness ? 'full-label' : 'compact-label'}" title="${attributionTitle(item)}">${escapeHtml(formatAttributionLabel(item, isLottery || isBusiness))}</td>
                     <td>${item.slotCount}</td>
                     <td>${formatBtcFromSats(item.totalValue)}</td>
                     <td>${formatPercent(item.totalValue, totalValue)}</td>
@@ -4693,7 +4693,7 @@
 
             const btcValue = payout.value / 100000000.0;
             const useFullLabel = listViewModes[tableId] === 'full';
-            const formattedAddr = formatAttributionLabel(payout, useFullLabel);
+            const formattedAddr = escapeHtml(formatAttributionLabel(payout, useFullLabel));
             const diffVal = payout.difficulty || 0;
             const diffDisplay = payout.diffString || diffVal.toLocaleString(undefined, {maximumFractionDigits: 2});
 
diff --git a/boot_portal/Program.cs b/boot_portal/Program.cs
index abb81ce..591c2ed 100644
--- a/boot_portal/Program.cs
+++ b/boot_portal/Program.cs
@@ -15,6 +15,7 @@
 using boot_portal.HostedServices;
 using boot_portal.Services;
 using boot_portal.Utils;
+using boot_portal.Controllers;
 using Microsoft.AspNetCore.RateLimiting;
 using NSec.Cryptography;
 using Microsoft.AspNetCore.SignalR;
@@ -350,6 +351,14 @@ public static async Task Main(string[] args)
             {
                 client.Timeout = TimeSpan.FromSeconds(Math.Max(2, _poolConfig.PeerRequestTimeoutSeconds));
             });
+            builder.Services.AddHttpClient("ReachabilityProbeClient", client =>
+            {
+                client.Timeout = TimeSpan.FromSeconds(Math.Max(2, _poolConfig.PeerRequestTimeoutSeconds));
+            }).ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
+            {
+                AllowAutoRedirect = false,
+                ConnectCallback = BootNetworkController.ConnectToPublicHostAsync
+            });
             builder.Services.AddHttpClient<BitcoinRpcClient>(client =>
             {
                 client.Timeout = TimeSpan.FromSeconds(Math.Max(1, _poolConfig.BitcoinRpcTimeoutSeconds));
@@ -466,6 +475,18 @@ await context.Response.WriteAsJsonAsync(new
                     context.Response.StatusCode = StatusCodes.Status404NotFound;
                     return;
                 }
+                context.Response.OnStarting(() =>
+                {
+                    context.Response.Headers["Content-Security-Policy"] =
+                        "default-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'self'; " +
+                        "script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://cdnjs.cloudflare.com; " +
+                        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
+                        "font-src 'self' https://fonts.gstatic.com data:; img-src 'self' data:; " +
+                        "connect-src 'self' ws: wss: https://mempool.space";
+                    context.Response.Headers["X-Content-Type-Options"] = "nosniff";
+                    context.Response.Headers["Referrer-Policy"] = "no-referrer";
+                    return Task.CompletedTask;
+                });
 
                 if (IsPeerOnlyListenerRequest(context, _poolConfig) &&
                     !IsAllowedPeerOnlyPath(context.Request.Path))
@@ -868,11 +889,17 @@ public ClientHandler(
         _x25519KeyLongTerm = serverLongTermXKey;
         _poolConfig = poolConfig;
         _stateService = stateService;
-        _clientPayoutAddress = BootProtocolStateService.GetGenesisFoundationAddress(_poolConfig.BitcoinNetwork);
+        _clientPayoutAddress = BitcoinScript.NormalizeAddress(_poolConfig.PoolPayoutScript);
+        _sessionPayoutAddressLocked = IsValidAddress(_clientPayoutAddress);
         _stoppingToken = st;
         _sessionStartedUtc = DateTime.UtcNow;
         _sessionId = $"datum-{Interlocked.Increment(ref _nextSessionId)}";
         _stateService.RecordDatumSessionOpened(_sessionId, RemoteEndpointLabel, _sessionStartedUtc);
+        if (_sessionPayoutAddressLocked)
+        {
+            RememberClientPayoutAddress(_clientPayoutAddress);
+            _stateService.RecordDatumSessionPayoutLock(_sessionId, _clientPayoutAddress);
+        }
         RecordDatumProtocolEvent(new BootDatumProtocolEvent
         {
             Direction = "internal",
@@ -995,10 +1022,12 @@ private void RecordPowSubmitProtocolOutcome(
 
     private async Task<int> ReadExactOrUntilClosedAsync(byte[] buffer, int length)
     {
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(_stoppingToken);
+        timeout.CancelAfter(TimeSpan.FromSeconds(Math.Max(1, _poolConfig.DatumReadTimeoutSeconds)));
         int offset = 0;
         while (offset < length)
         {
-            int read = await _stream.ReadAsync(buffer, offset, length - offset);
+            int read = await _stream.ReadAsync(buffer.AsMemory(offset, length - offset), timeout.Token);
             if (read == 0)
             {
                 break;
@@ -1130,6 +1159,15 @@ public async Task HandleClientAsync()
                 //Console.WriteLine($"📋 Parsed header: Cmd={header.ProtoCmd}, Len={header.CmdLen}, Signed={header.IsSigned}, EncryptedPubKey={header.IsEncryptedPubKey}, EncryptedChannel={header.IsEncryptedChannel}");
 
                 // Step 2: Read in the message body
+                if (header.CmdLen > _poolConfig.MaxShareRequestBytes)
+                {
+                    MarkSessionClose(
+                        "message-too-large",
+                        $"DATUM message declared {header.CmdLen} bytes; maximum is {_poolConfig.MaxShareRequestBytes}.");
+                    ScheduleServerInitiatedClose(
+                        $"Closing DATUM session {RemoteEndpointLabel} after an oversized message header.");
+                    break;
+                }
                 var bodyBuffer = new byte[header.CmdLen];
                 bytesRead = await ReadExactOrUntilClosedAsync(bodyBuffer, bodyBuffer.Length);
                 if (bytesRead == 0)
@@ -1366,6 +1404,11 @@ public async Task HandleClientAsync()
                 //Finally back to the top of the loop and await the next incoming message
             }
         }
+        catch (OperationCanceledException) when (!_stoppingToken.IsCancellationRequested)
+        {
+            MarkSessionClose("read-timeout", "DATUM header or body was not received before the read deadline.");
+            ScheduleServerInitiatedClose($"Closing DATUM session {RemoteEndpointLabel} after a read timeout.");
+        }
         catch (IOException ex)
         {
             MarkSessionClose("client-disconnected-io", $"I/O exception while handling DATUM session: {ex.Message}");
@@ -2084,6 +2127,16 @@ private async Task HandleCoinbaserFetchAsync(byte[] payload)
             fetchRequest = CoinbaserFetchMessage.FromBytes(payload);
             parseDurationMs = stageStopwatch.Elapsed.TotalMilliseconds;
 
+            if (!_sessionPayoutAddressLocked || string.IsNullOrWhiteSpace(_clientPayoutAddress))
+            {
+                MarkSessionClose(
+                    "payout-address-required",
+                    "DATUM coinbase work is unavailable until the miner locks a valid payout address.");
+                ScheduleServerInitiatedClose(
+                    $"Closing DATUM session {RemoteEndpointLabel} because no valid slot-0 payout address is locked.");
+                return;
+            }
+
             stageStopwatch.Restart();
             DatumCoinbaseTemplate coinbaseTemplate = _stateService.GetDatumCoinbaseTemplate();
             winnersList = coinbaseTemplate.WinnersList;
diff --git a/boot_portal/Services/BitcoinNotificationHealth.cs b/boot_portal/Services/BitcoinNotificationHealth.cs
index 7890aa5..d9bef29 100644
--- a/boot_portal/Services/BitcoinNotificationHealth.cs
+++ b/boot_portal/Services/BitcoinNotificationHealth.cs
@@ -338,7 +338,8 @@ public bool IsMiningSafe(DateTime nowUtc, out string reason)
                 return false;
             }
 
-            DateTime reference = _lastRpcSuccessUtc ?? _lastRpcCheckUtc ?? _startedUtc;
+            // Repeated failed polls must not renew the grace period indefinitely.
+            DateTime reference = _lastRpcSuccessUtc ?? _startedUtc;
             if (!_rpcReachable && nowUtc - reference >= TimeSpan.FromSeconds(_lagGraceSeconds))
             {
                 reason = string.IsNullOrWhiteSpace(_lastRpcError)
@@ -462,7 +463,7 @@ private bool IsMiningSafeNoLock(DateTime nowUtc, out string reason)
             return false;
         }
 
-        DateTime reference = _lastRpcSuccessUtc ?? _lastRpcCheckUtc ?? _startedUtc;
+        DateTime reference = _lastRpcSuccessUtc ?? _startedUtc;
         if (!_rpcReachable && nowUtc - reference >= TimeSpan.FromSeconds(_lagGraceSeconds))
         {
             reason = string.IsNullOrWhiteSpace(_lastRpcError)
diff --git a/boot_portal/Services/BitcoinRpcClient.cs b/boot_portal/Services/BitcoinRpcClient.cs
index 8254620..75a2a33 100644
--- a/boot_portal/Services/BitcoinRpcClient.cs
+++ b/boot_portal/Services/BitcoinRpcClient.cs
@@ -10,7 +10,8 @@ public sealed record BitcoinBlockchainInfo(
     long Headers,
     string BestBlockHash,
     bool InitialBlockDownload,
-    double? VerificationProgress);
+    double? VerificationProgress,
+    string Chain = "");
 
 public sealed record BitcoinZmqPublisher(string Topic, string Address);
 public sealed record BitcoinNetworkInfo(int Connections, int ConnectionsIn, int ConnectionsOut);
@@ -54,7 +55,8 @@ public async Task<BitcoinBlockchainInfo> GetBlockchainInfoAsync(CancellationToke
             result.GetProperty("headers").GetInt64(),
             result.GetProperty("bestblockhash").GetString() ?? string.Empty,
             result.TryGetProperty("initialblockdownload", out JsonElement ibd) && ibd.GetBoolean(),
-            result.TryGetProperty("verificationprogress", out JsonElement progress) ? progress.GetDouble() : null);
+            result.TryGetProperty("verificationprogress", out JsonElement progress) ? progress.GetDouble() : null,
+            result.TryGetProperty("chain", out JsonElement chain) ? chain.GetString() ?? string.Empty : string.Empty);
     }
 
     public async Task<string> GetBestBlockHashAsync(CancellationToken cancellationToken)
diff --git a/boot_portal/Services/BitcoinRpcRecoveryPlanner.cs b/boot_portal/Services/BitcoinRpcRecoveryPlanner.cs
index 6f258d4..8149bff 100644
--- a/boot_portal/Services/BitcoinRpcRecoveryPlanner.cs
+++ b/boot_portal/Services/BitcoinRpcRecoveryPlanner.cs
@@ -7,6 +7,8 @@ public sealed record BitcoinRpcRecoveryPlan(
 
 public static class BitcoinRpcRecoveryPlanner
 {
+    private const int ShallowReorganizationLookback = 1;
+
     public static BitcoinRpcRecoveryPlan Build(
         long? localHeight,
         string? localHash,
@@ -27,12 +29,12 @@ public static BitcoinRpcRecoveryPlan Build(
 
         if (localHeight.Value > rpcHeight)
         {
-            return new BitcoinRpcRecoveryPlan([], false, true);
+            return new BitcoinRpcRecoveryPlan(ReorganizationHeights(rpcHeight), false, true);
         }
 
         if (localHeight.Value == rpcHeight)
         {
-            return new BitcoinRpcRecoveryPlan([rpcHeight], false, true);
+            return new BitcoinRpcRecoveryPlan(ReorganizationHeights(rpcHeight), false, true);
         }
 
         return new BitcoinRpcRecoveryPlan(
@@ -44,4 +46,14 @@ public static BitcoinRpcRecoveryPlan Build(
             false,
             false);
     }
+
+    private static IReadOnlyList<long> ReorganizationHeights(long tipHeight)
+    {
+        long firstHeight = Math.Max(0, tipHeight - ShallowReorganizationLookback);
+        return Enumerable.Range(
+                checked((int)firstHeight),
+                checked((int)(tipHeight - firstHeight + 1)))
+            .Select(height => (long)height)
+            .ToList();
+    }
 }
diff --git a/boot_portal/Services/BootPeerUdpRelayService.cs b/boot_portal/Services/BootPeerUdpRelayService.cs
index 799606a..69b72e3 100644
--- a/boot_portal/Services/BootPeerUdpRelayService.cs
+++ b/boot_portal/Services/BootPeerUdpRelayService.cs
@@ -1,22 +1,15 @@
 using System.Net;
-using System.Net.Http.Json;
 using System.Net.Sockets;
-using System.Text;
-using System.Collections.Concurrent;
 using boot_portal.Models;
 
 namespace boot_portal.Services;
 
 public sealed class BootPeerUdpRelayService : BackgroundService
 {
-    private const string ReachabilityProbePrefix = "GP_REACHABILITY_PROBE:";
-    private const string ReachabilityAckPrefix = "GP_REACHABILITY_ACK:";
-    private static readonly TimeSpan ReachabilityChallengeTtl = TimeSpan.FromMinutes(2);
     private readonly PoolConfig _poolConfig;
     private readonly BootProtocolStateService _stateService;
     private readonly BootPeerSessionManager _sessionManager;
     private readonly ILogger<BootPeerUdpRelayService> _logger;
-    private readonly ConcurrentDictionary<string, BootUdpReachabilityChallenge> _reachabilityChallenges = new(StringComparer.Ordinal);
     private UdpClient? _udpClient;
 
     public BootPeerUdpRelayService(
@@ -193,96 +186,6 @@ private void RecordChainTipSendTelemetry(
             target.Datagram.Length);
     }
 
-    public async Task<bool> SendReachabilityProbeAsync(
-        string host,
-        int port,
-        string nonce,
-        string ackUrl,
-        string targetBaseUrl,
-        CancellationToken cancellationToken)
-    {
-        if (string.IsNullOrWhiteSpace(host) ||
-            port is <= 0 or > 65535 ||
-            string.IsNullOrWhiteSpace(nonce))
-        {
-            return false;
-        }
-
-        try
-        {
-            IPAddress[] addresses = await Dns.GetHostAddressesAsync(host, cancellationToken);
-            IPAddress? address = addresses.FirstOrDefault(candidate => candidate.AddressFamily == AddressFamily.InterNetwork);
-            if (address == null)
-            {
-                return false;
-            }
-
-            string payloadText = $"{ReachabilityProbePrefix}{nonce}|{ackUrl}|{targetBaseUrl}";
-            byte[] payload = Encoding.ASCII.GetBytes(payloadText);
-            using var udp = new UdpClient(AddressFamily.InterNetwork);
-            await udp.SendAsync(payload, payload.Length, new IPEndPoint(address, port));
-            return true;
-        }
-        catch (Exception ex) when (ex is SocketException or ObjectDisposedException or ArgumentException or InvalidOperationException)
-        {
-            _logger.LogDebug(ex, "Failed to send UDP reachability probe to {Host}:{Port}.", host, port);
-            return false;
-        }
-    }
-
-    public void RegisterReachabilityChallenge(string nonce, string targetBaseUrl)
-    {
-        if (string.IsNullOrWhiteSpace(nonce))
-        {
-            return;
-        }
-
-        PruneReachabilityChallenges();
-        _reachabilityChallenges[nonce.Trim()] = new BootUdpReachabilityChallenge
-        {
-            Nonce = nonce.Trim(),
-            TargetBaseUrl = targetBaseUrl.Trim(),
-            CreatedAtUtc = DateTime.UtcNow
-        };
-    }
-
-    public bool AcknowledgeReachabilityChallenge(string nonce, string targetBaseUrl)
-    {
-        if (string.IsNullOrWhiteSpace(nonce))
-        {
-            return false;
-        }
-
-        PruneReachabilityChallenges();
-        string key = nonce.Trim();
-        if (!_reachabilityChallenges.TryGetValue(key, out BootUdpReachabilityChallenge? challenge))
-        {
-            return false;
-        }
-
-        if (!string.IsNullOrWhiteSpace(challenge.TargetBaseUrl) &&
-            !string.IsNullOrWhiteSpace(targetBaseUrl) &&
-            !string.Equals(challenge.TargetBaseUrl.Trim().TrimEnd('/'), targetBaseUrl.Trim().TrimEnd('/'), StringComparison.OrdinalIgnoreCase))
-        {
-            return false;
-        }
-
-        challenge.AcknowledgedAtUtc = DateTime.UtcNow;
-        return true;
-    }
-
-    public bool WasReachabilityChallengeAcknowledged(string nonce)
-    {
-        if (string.IsNullOrWhiteSpace(nonce))
-        {
-            return false;
-        }
-
-        PruneReachabilityChallenges();
-        return _reachabilityChallenges.TryGetValue(nonce.Trim(), out BootUdpReachabilityChallenge? challenge) &&
-            challenge.AcknowledgedAtUtc.HasValue;
-    }
-
     private async Task HandleDatagramAsync(
         byte[] datagram,
         IPEndPoint remoteEndPoint,
@@ -298,11 +201,6 @@ private async Task HandleDatagramAsync(
             return;
         }
 
-        if (TryHandleReachabilityProbe(datagram, remoteEndPoint))
-        {
-            return;
-        }
-
         if (!_sessionManager.TryDecryptUdpDatagram(datagram, out BootPeerUdpReceivedPayload received, out string decryptReason))
         {
             _logger.LogDebug("Ignored unauthenticated V3 UDP datagram from {RemoteEndPoint}: {Reason}", remoteEndPoint, decryptReason);
@@ -365,105 +263,10 @@ await _stateService.ObservePeerChainTipAsync(
         _stateService.UpdatePeerUdpHeartbeat(received.RemoteEndpoint, received.RemoteNodeId, "udp-invalid", success: false, DateTime.UtcNow);
     }
 
-    private bool TryHandleReachabilityProbe(byte[] datagram, IPEndPoint remoteEndPoint)
-    {
-        string text;
-        try
-        {
-            text = Encoding.ASCII.GetString(datagram);
-        }
-        catch
-        {
-            return false;
-        }
-
-        if (!text.StartsWith(ReachabilityProbePrefix, StringComparison.Ordinal))
-        {
-            return false;
-        }
-
-        string payload = text[ReachabilityProbePrefix.Length..].Trim();
-        string[] parts = payload.Split('|', 3);
-        string nonce = parts.ElementAtOrDefault(0)?.Trim() ?? string.Empty;
-        string ackUrl = parts.ElementAtOrDefault(1)?.Trim() ?? string.Empty;
-        string targetBaseUrl = parts.ElementAtOrDefault(2)?.Trim() ?? string.Empty;
-        if (string.IsNullOrWhiteSpace(nonce))
-        {
-            return true;
-        }
-
-        _ = Task.Run(async () =>
-        {
-            try
-            {
-                byte[] ack = Encoding.ASCII.GetBytes($"{ReachabilityAckPrefix}{nonce}");
-                using var udp = new UdpClient(AddressFamily.InterNetwork);
-                await udp.SendAsync(ack, ack.Length, remoteEndPoint);
-                await PostReachabilityAckAsync(ackUrl, nonce, targetBaseUrl);
-            }
-            catch (Exception ex) when (ex is SocketException or ObjectDisposedException)
-            {
-                _logger.LogDebug(ex, "Failed to send UDP reachability ack to {RemoteEndPoint}.", remoteEndPoint);
-            }
-        });
-
-        _stateService.RecordExternalNetworkEvent(
-            "udp-reachability-probe",
-            remoteEndPoint.ToString(),
-            "Received UDP reachability probe and attempted ack.");
-        return true;
-    }
-
-    private async Task PostReachabilityAckAsync(string ackUrl, string nonce, string targetBaseUrl)
-    {
-        if (string.IsNullOrWhiteSpace(ackUrl) ||
-            !Uri.TryCreate(ackUrl, UriKind.Absolute, out Uri? uri) ||
-            (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
-        {
-            return;
-        }
-
-        try
-        {
-            using var client = new HttpClient
-            {
-                Timeout = TimeSpan.FromSeconds(2)
-            };
-            using var response = await client.PostAsJsonAsync(uri, new BootUdpReachabilityAckRequest
-            {
-                Nonce = nonce,
-                TargetBaseUrl = targetBaseUrl
-            });
-        }
-        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or InvalidOperationException)
-        {
-            _logger.LogDebug(ex, "Failed to POST UDP reachability ack to {AckUrl}.", ackUrl);
-        }
-    }
-
-    private void PruneReachabilityChallenges()
-    {
-        DateTime cutoff = DateTime.UtcNow - ReachabilityChallengeTtl;
-        foreach (var item in _reachabilityChallenges)
-        {
-            if (item.Value.CreatedAtUtc < cutoff)
-            {
-                _reachabilityChallenges.TryRemove(item.Key, out _);
-            }
-        }
-    }
-
     public override void Dispose()
     {
         _udpClient?.Dispose();
         base.Dispose();
     }
 
-    private sealed class BootUdpReachabilityChallenge
-    {
-        public string Nonce { get; init; } = string.Empty;
-        public string TargetBaseUrl { get; init; } = string.Empty;
-        public DateTime CreatedAtUtc { get; init; }
-        public DateTime? AcknowledgedAtUtc { get; set; }
-    }
 }
diff --git a/boot_portal/Services/BootProtocolStateService.cs b/boot_portal/Services/BootProtocolStateService.cs
index 797e868..0e56eac 100644
--- a/boot_portal/Services/BootProtocolStateService.cs
+++ b/boot_portal/Services/BootProtocolStateService.cs
@@ -24,23 +24,23 @@ public class BootProtocolStateService
 
     public static string GetGenesisFoundationAddress(string? bitcoinNetwork)
     {
-        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Testnet4
-            ? TestnetGenesisFoundationAddress
-            : GenesisFoundationAddress;
+        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Mainnet
+            ? GenesisFoundationAddress
+            : TestnetGenesisFoundationAddress;
     }
 
     public static ulong GetCurrentBlockSubsidySats(string? bitcoinNetwork)
     {
-        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Testnet4
-            ? Testnet4CurrentSubsidySats
-            : MainnetCurrentSubsidySats;
+        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Mainnet
+            ? MainnetCurrentSubsidySats
+            : Testnet4CurrentSubsidySats;
     }
 
     public static string GetGridLabsSupportAddress(string? bitcoinNetwork)
     {
-        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Testnet4
-            ? TestnetGridLabsSupportAddress
-            : GridLabsSupportAddress;
+        return BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Mainnet
+            ? GridLabsSupportAddress
+            : TestnetGridLabsSupportAddress;
     }
 
     private readonly DateTime _serviceStartedUtc = DateTime.UtcNow;
@@ -88,7 +88,7 @@ public static string GetGridLabsSupportAddress(string? bitcoinNetwork)
     private const double SlowStateLockWaitWarningMs = 250;
     private const double SlowStateSaveWarningMs = 250;
     private const int MaxSeenShareIds = 20000;
-    private const int MaxAcceptedParentBlockHashes = 100000;
+    private const int MaxAcceptedParentBlockHashes = 128;
     private const int MaxRecentRejectedShareDiagnostics = 1000;
     private const int MaxRecentCoinbaserDiagnostics = 1000;
     private const int MaxRecentDatumShareResponses = 2000;
@@ -149,7 +149,8 @@ public BootProtocolStateService(
             {
                 BitcoinHeaderEvaluation restoredHeader = BitcoinHashes.EvaluateHeader(
                     _state.ProvisionalTip.HeaderHex,
-                    _state.ProvisionalTip.ObservedUtc);
+                    _state.ProvisionalTip.ObservedUtc,
+                    _poolConfig.BitcoinNetwork);
                 if (!restoredHeader.IsValid ||
                     !BitcoinHashes.AreEquivalent(restoredHeader.BlockHash, _state.ProvisionalTip.BlockHash) ||
                     !BitcoinHashes.AreEquivalent(restoredHeader.ParentBlockHash, _state.CurrentTipBlockHash))
@@ -2074,36 +2075,60 @@ public async Task<ShareRecordingResult> RecordShareAsync(RecordedShareSubmission
                         $"Fresh-parent retry validated but computed difficulty {freshParentValidation.Difficulty.ToString("F2", CultureInfo.InvariantCulture)} was below the floor.");
                     validation = freshParentValidation;
                 }
-                else if (TryLearnFreshParentFromTrustedShare(share.Source, freshParentValidation, currentStateSnapshot))
-                {
-                    validation = freshParentValidation;
-                    matchedSnapshotId = freshParentSnapshotValidation.SnapshotId;
-                }
                 else
                 {
                     RecordFreshParentRetryEvent(
-                        "fresh-parent-learn-failed",
+                        "fresh-parent-rejected",
                         share.Source,
                         freshParentValidation.PrevBlockHash,
-                        "Fresh-parent retry validated, but the parent could not be learned before the state changed.");
+                        "A mining share cannot establish a new Bitcoin parent; local Bitcoin notification authority must validate the tip first.");
+                    validation = RejectValidatedShare(
+                        freshParentValidation,
+                        "Fresh proof parent is outside the active Bitcoin tip; the attached Bitcoin source must validate it before direct ingress.");
                 }
             }
         }
 
+        bool locallyConfirmedCurrentBlockShare;
+        lock (_sync)
+        {
+            locallyConfirmedCurrentBlockShare =
+                IsLocallyConfirmedCurrentBlockShareNoLock(headerEvaluation);
+        }
+
+        if (!validation.IsValid && locallyConfirmedCurrentBlockShare)
+        {
+            lock (_sync)
+            {
+                snapshotContextsSnapshot = _state.SnapshotContexts.Select(CloneSnapshotContext).ToList();
+            }
+
+            SnapshotValidationResult confirmedBlockValidation =
+                ValidateConfirmedBlockShareAgainstRetainedSnapshots(share, snapshotContextsSnapshot);
+            if (confirmedBlockValidation.Validation.IsValid)
+            {
+                validation = confirmedBlockValidation.Validation;
+                matchedSnapshotId = confirmedBlockValidation.SnapshotId;
+            }
+        }
+
         lock (_sync)
         {
-            if (validation.IsValid && ShouldQuarantinePreviousParentNoLock(validation.PrevBlockHash, DateTime.UtcNow))
+            if (validation.IsValid &&
+                !locallyConfirmedCurrentBlockShare &&
+                ShouldQuarantinePreviousParentNoLock(validation.PrevBlockHash, DateTime.UtcNow))
             {
                 validation = RejectValidatedShare(
                     validation,
                     "Previous-parent proof quarantined after the provisional peer-tip boundary.");
             }
             else if (validation.IsValid &&
-                     IsNewDirectIngressPreviousParentProofNoLock(validation.ShareId, validation.PrevBlockHash))
+                     !locallyConfirmedCurrentBlockShare &&
+                     IsNewDirectIngressOutsideActiveParentNoLock(validation.ShareId, validation.PrevBlockHash))
             {
                 validation = RejectValidatedShare(
                     validation,
-                    "New previous-parent proof rejected after the local snapshot boundary.");
+                    "Fresh proof parent is outside the active Bitcoin tip; retained proofs may be revalidated only through state reconciliation.");
             }
         }
         shareCoreValidationDurationMs = stageStopwatch.Elapsed.TotalMilliseconds;
@@ -2251,11 +2276,6 @@ ShareRecordingResult AttachTimings(ShareRecordingResult result)
             });
         }
 
-        if (IsTrustedFreshParentSource(share.Source))
-        {
-            TryLearnFreshParentFromTrustedShare(share.Source, validation, currentStateSnapshot);
-        }
-
         ShareRecordingResult result;
         bool shouldRelay = false;
         bool shouldNotifyNetwork = false;
@@ -2303,7 +2323,8 @@ ShareRecordingResult AttachTimings(ShareRecordingResult result)
                 });
             }
 
-            if (!IsAcceptedParentBlockHashNoLock(validation.PrevBlockHash))
+            if (!locallyConfirmedCurrentBlockShare &&
+                !IsAcceptedParentBlockHashNoLock(validation.PrevBlockHash))
             {
                 RecordShareDiagnosticNoLock(
                     share.Source,
@@ -3022,6 +3043,36 @@ private SnapshotValidationResult ValidateShareAgainstKnownSnapshotsIgnoringParen
         return ValidateShareAgainstKnownSnapshots(share, currentWinners, snapshotContexts, []);
     }
 
+    private SnapshotValidationResult ValidateConfirmedBlockShareAgainstRetainedSnapshots(
+        RecordedShareSubmission share,
+        IReadOnlyCollection<BootPayoutSnapshotContext> snapshotContexts)
+    {
+        BootShareValidationResult firstFailure = InvalidValidationResult();
+        IEnumerable<BootPayoutSnapshotContext> orderedContexts = snapshotContexts
+            .Where(context => !string.IsNullOrWhiteSpace(context.SnapshotId))
+            .OrderByDescending(context => string.Equals(
+                context.SnapshotId,
+                share.PayoutSnapshotId,
+                StringComparison.OrdinalIgnoreCase))
+            .ThenByDescending(context => context.CreatedAtUtc);
+
+        foreach (BootPayoutSnapshotContext context in orderedContexts)
+        {
+            foreach (List<PayoutInfo> payoutVariant in GetSnapshotPayoutVariants(context))
+            {
+                BootShareValidationResult validation = _shareVerifier.ValidateShare(share, payoutVariant, []);
+                if (validation.IsValid)
+                {
+                    return new SnapshotValidationResult(validation, context.SnapshotId);
+                }
+
+                firstFailure = PreferInformativeFailure(firstFailure, validation);
+            }
+        }
+
+        return new SnapshotValidationResult(firstFailure, string.Empty);
+    }
+
     private SnapshotValidationResult ValidateProofAgainstKnownSnapshots(
         BootShareProof proof,
         IReadOnlyList<PayoutInfo> currentWinners,
@@ -3114,18 +3165,32 @@ private static BootShareValidationResult PreferInformativeFailure(
     private List<List<PayoutInfo>> GetSnapshotPayoutVariants(BootPayoutSnapshotContext context)
     {
         var variants = new List<List<PayoutInfo>>();
+        if (IsExplicitEmptySnapshotBootstrapContext(context))
+        {
+            variants.Add([]);
+        }
+
         if (context.WinnersList.Count > 0)
         {
             variants.Add(ClonePayouts(context.WinnersList));
         }
 
-        if (context.FeeFreeWinnersList.Count > 0 &&
-            !variants.Any(existing => WinnersMatch(existing, context.FeeFreeWinnersList)))
+        return variants;
+    }
+
+    private bool IsExplicitEmptySnapshotBootstrapContext(BootPayoutSnapshotContext context)
+    {
+        if (!_poolConfig.AllowEmptySnapshotBootstrap ||
+            BitcoinScript.NormalizeNetwork(_poolConfig.BitcoinNetwork) != BitcoinScript.Regtest ||
+            context.WinnersList.Count != 0 ||
+            context.FeeFreeWinnersList.Count != 0 ||
+            context.ProofIds.Count != 0)
         {
-            variants.Add(ClonePayouts(context.FeeFreeWinnersList));
+            return false;
         }
 
-        return variants;
+        string expectedSnapshotId = ComputeStateIdNoLock([], context.LockedByBlockHash);
+        return string.Equals(context.SnapshotId, expectedSnapshotId, StringComparison.OrdinalIgnoreCase);
     }
 
     private static List<BootShareProof> SortAndTrimProofs(IEnumerable<BootShareProof> proofs, int limit)
@@ -3751,7 +3816,10 @@ public bool ObserveLocalChainTipHeader(
         DateTime transportReceivedUtc,
         long? blockHeight = null)
     {
-        BitcoinHeaderEvaluation evaluation = BitcoinHashes.EvaluateHeader(headerHex, transportReceivedUtc);
+        BitcoinHeaderEvaluation evaluation = BitcoinHashes.EvaluateHeader(
+            headerHex,
+            transportReceivedUtc,
+            _poolConfig.BitcoinNetwork);
         if (!evaluation.IsValid)
         {
             _logger.LogWarning(
@@ -3892,7 +3960,8 @@ public async Task<BootNetworkStatusDto> ObserveChainTipAsync(string blockHash, s
                 }
             }
 
-            if (IsStaleTipObservationNoLock(
+            bool trustedReorganization = source.Contains("reorg", StringComparison.OrdinalIgnoreCase);
+            if (!trustedReorganization && IsStaleTipObservationNoLock(
                 normalizedBlockHash,
                 effectiveBlockHeight,
                 _state.CurrentTipBlockHash,
@@ -3911,7 +3980,7 @@ public async Task<BootNetworkStatusDto> ObserveChainTipAsync(string blockHash, s
 
             bool oneBlockReorg = GetActiveConsensusVersionNoLock() >= BootProtocolVersions.ConsensusVersion &&
                 effectiveBlockHeight.HasValue &&
-                _state.CurrentTipBlockHeight == effectiveBlockHeight &&
+                (_state.CurrentTipBlockHeight == effectiveBlockHeight || trustedReorganization) &&
                 !BitcoinHashes.AreEquivalent(normalizedBlockHash, _state.CurrentTipBlockHash);
             if (oneBlockReorg)
             {
@@ -4039,7 +4108,10 @@ public async Task<BootNetworkStatusDto> ObservePeerChainTipAsync(
         DateTime? transportReceivedUtc = null)
     {
         DateTime receivedUtc = transportReceivedUtc ?? DateTime.UtcNow;
-        BitcoinHeaderEvaluation evaluation = BitcoinHashes.EvaluateHeader(announcement.HeaderHex, receivedUtc);
+        BitcoinHeaderEvaluation evaluation = BitcoinHashes.EvaluateHeader(
+            announcement.HeaderHex,
+            receivedUtc,
+            _poolConfig.BitcoinNetwork);
         string diagramPeerId = !string.IsNullOrWhiteSpace(remoteNodeId) ? remoteNodeId : remoteEndpoint;
         void RecordHeaderRejection(string reason, string? blockHash)
         {
@@ -5840,24 +5912,39 @@ private void PruneSnapshotFamiliesNoLock()
         };
     }
 
-    private bool IsNewDirectIngressPreviousParentProofNoLock(string? shareId, string? parentBlockHash)
+    private bool IsNewDirectIngressOutsideActiveParentNoLock(string? shareId, string? parentBlockHash)
     {
         if (string.IsNullOrWhiteSpace(parentBlockHash))
         {
             return false;
         }
 
-        BootPayoutSnapshotContext? active = GetSnapshotContextNoLock(_state.ActiveSnapshotId);
-        BootPayoutSnapshotContext? predecessor = GetSnapshotContextNoLock(active?.PreviousSnapshotId);
-        string? finalizedPreviousParent = NormalizeCanonicalBlockHash(predecessor?.LockedByBlockHash);
-        if (string.IsNullOrWhiteSpace(finalizedPreviousParent) ||
-            !BitcoinHashes.AreEquivalent(parentBlockHash, finalizedPreviousParent))
+        if (_state.OnDeckProofs.Any(proof =>
+                string.Equals(proof.ShareId, shareId, StringComparison.OrdinalIgnoreCase)))
         {
             return false;
         }
 
-        return !_state.OnDeckProofs.Any(proof =>
-            string.Equals(proof.ShareId, shareId, StringComparison.OrdinalIgnoreCase));
+        string? currentTip = NormalizeCanonicalBlockHash(_state.CurrentTipBlockHash);
+        return !string.IsNullOrWhiteSpace(currentTip) &&
+               !BitcoinHashes.AreEquivalent(parentBlockHash, currentTip);
+    }
+
+    private bool IsLocallyConfirmedCurrentBlockShareNoLock(BootShareHeaderEvaluationResult headerEvaluation)
+    {
+        if (!headerEvaluation.IsValid ||
+            !headerEvaluation.IsBlock ||
+            BitcoinNotificationModes.Resolve(_poolConfig) != BitcoinNotificationModes.AttachedNode ||
+            string.IsNullOrWhiteSpace(headerEvaluation.BlockHash) ||
+            !BitcoinHashes.AreEquivalent(headerEvaluation.BlockHash, _state.CurrentTipBlockHash) ||
+            !BitcoinHashes.AreEquivalent(headerEvaluation.BlockHash, _state.TrustedLocalTipBlockHash) ||
+            !_localChainTipHeaders.TryGetValue(headerEvaluation.BlockHash, out BitcoinHeaderEvaluation? localHeader))
+        {
+            return false;
+        }
+
+        return localHeader.IsValid &&
+               BitcoinHashes.AreEquivalent(localHeader.BlockHash, headerEvaluation.BlockHash);
     }
 
     private void RestorePredecessorForRemovedBoundaryNoLock(
@@ -5865,19 +5952,25 @@ private void RestorePredecessorForRemovedBoundaryNoLock(
         string replacementBlockHash,
         long replacementBlockHeight)
     {
-        BootSnapshotFamilyState? removedFamily = GetActiveSnapshotFamilyNoLock();
-        if (removedFamily == null ||
-            removedFamily.BoundaryBlockHeight != replacementBlockHeight ||
-            BitcoinHashes.AreEquivalent(removedFamily.BoundaryBlockHash, replacementBlockHash))
+        while (true)
         {
-            return;
-        }
+            BootSnapshotFamilyState? removedFamily = GetActiveSnapshotFamilyNoLock();
+            if (removedFamily == null ||
+                removedFamily.BoundaryBlockHeight < replacementBlockHeight ||
+                (removedFamily.BoundaryBlockHeight == replacementBlockHeight &&
+                 BitcoinHashes.AreEquivalent(removedFamily.BoundaryBlockHash, replacementBlockHash)))
+            {
+                return;
+            }
+
+            removedFamily.IsOpen = false;
+            removedFamily.BoundaryOnActiveChain = false;
+            BootPayoutSnapshotContext? predecessor = GetSnapshotContextNoLock(removedFamily.PredecessorSnapshotId);
+            if (predecessor == null)
+            {
+                return;
+            }
 
-        removedFamily.IsOpen = false;
-        removedFamily.BoundaryOnActiveChain = false;
-        BootPayoutSnapshotContext? predecessor = GetSnapshotContextNoLock(removedFamily.PredecessorSnapshotId);
-        if (predecessor != null)
-        {
             _state.ActiveSnapshotId = predecessor.SnapshotId;
             _state.ActiveSnapshotProofIds = predecessor.ProofIds.ToList();
             _state.WinnersList = ClonePayouts(predecessor.WinnersList);
@@ -5886,14 +5979,14 @@ private void RestorePredecessorForRemovedBoundaryNoLock(
             _state.CurrentRoundNumber = Math.Max(0, predecessor.CurrentRoundNumber);
             _state.CurrentTipBlockHash = NormalizeCanonicalBlockHash(predecessor.LockedByBlockHash);
             _state.CurrentTipBlockHeight = predecessor.LockedByBlockHeight;
-        }
 
-        RecordNetworkEventNoLock(
-            "snapshot-family-reorg",
-            source,
-            $"Deactivated snapshot family {removedFamily.FamilyId} after boundary {removedFamily.BoundaryBlockHash} left the active chain.",
-            replacementBlockHash,
-            replacementBlockHeight);
+            RecordNetworkEventNoLock(
+                "snapshot-family-reorg",
+                source,
+                $"Deactivated snapshot family {removedFamily.FamilyId} after boundary {removedFamily.BoundaryBlockHash} left the active chain.",
+                replacementBlockHash,
+                replacementBlockHeight);
+        }
     }
 
     private void EnsureActiveSnapshotNoLock(DateTime nowUtc)
@@ -10807,59 +10900,6 @@ private void RecordFreshParentRetryEvent(
         }
     }
 
-    private bool TryLearnFreshParentFromTrustedShare(
-        string source,
-        BootShareValidationResult validation,
-        string expectedStateId)
-    {
-        if (!IsTrustedFreshParentSource(source) ||
-            string.IsNullOrWhiteSpace(validation.PrevBlockHash))
-        {
-            return false;
-        }
-
-        lock (_sync)
-        {
-            if (!string.Equals(expectedStateId, _state.CurrentStateId, StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            if (IsAcceptedParentBlockHashNoLock(validation.PrevBlockHash))
-            {
-                return true;
-            }
-
-            if (_poolConfig.EnablePeerTipStaleProtection && _state.ProvisionalTip != null)
-            {
-                RecordNetworkEventNoLock(
-                    "fresh-parent-deferred",
-                    source,
-                    "Did not learn a new parent from DATUM while a peer-tip boundary awaited local Bitcoin validation.",
-                    validation.PrevBlockHash,
-                    blockHeight: null);
-                RequestDeferredHistorySaveNoLock();
-                return false;
-            }
-
-            RememberAcceptedParentBlockHashNoLock(validation.PrevBlockHash);
-            if (string.IsNullOrWhiteSpace(_state.CurrentTipBlockHash))
-            {
-                _state.CurrentTipBlockHash = validation.PrevBlockHash;
-                _state.CandidateStateId = ComputeCandidateStateIdNoLock();
-            }
-            RecordNetworkEventNoLock(
-                "fresh-parent-learned",
-                source,
-                $"Learned fresh parent from otherwise-valid local share at difficulty {ClientHandler.FormatDifficulty(validation.Difficulty)}.",
-                validation.PrevBlockHash,
-                blockHeight: null);
-            RequestDeferredSaveNoLock();
-            RequestDeferredHistorySaveNoLock();
-            return true;
-        }
-    }
-
     private static bool IsTrustedFreshParentSource(string source)
     {
         return string.Equals(source, "datum", StringComparison.OrdinalIgnoreCase);
diff --git a/boot_portal/Services/BootShareVerifier.cs b/boot_portal/Services/BootShareVerifier.cs
index 6e3e1aa..f9c852f 100644
--- a/boot_portal/Services/BootShareVerifier.cs
+++ b/boot_portal/Services/BootShareVerifier.cs
@@ -286,7 +286,7 @@ private BootShareValidationResult ValidateCore(
                 IsValid = true,
                 ShareId = shareId,
                 MinerAddress = normalizedMinerAddress,
-                Username = string.IsNullOrWhiteSpace(username) ? normalizedMinerAddress : username,
+                Username = NormalizeUsernameForStorage(username, normalizedMinerAddress),
                 ScriptPubKeyHex = scriptPubKeyHex,
                 HeaderHex = normalizedHeaderHex,
                 CoinbaseHex = normalizedCoinbaseHex,
@@ -307,6 +307,26 @@ private BootShareValidationResult ValidateCore(
         }
     }
 
+    internal static string NormalizeUsernameForStorage(string? username, string fallbackAddress)
+    {
+        if (string.IsNullOrWhiteSpace(username))
+        {
+            return fallbackAddress;
+        }
+
+        string trimmed = username.Trim();
+        var safe = new StringBuilder(Math.Min(trimmed.Length, 128));
+        foreach (char value in trimmed.Take(128))
+        {
+            safe.Append(char.IsAsciiLetterOrDigit(value) || value is '.' or '_' or '-' or ':'
+                ? value
+                : '_');
+        }
+
+        string normalized = safe.ToString().Trim('_');
+        return string.IsNullOrWhiteSpace(normalized) ? fallbackAddress : normalized;
+    }
+
     private string ExtractSlotZeroAddress(byte[] scriptPubKey)
     {
         string address = BitcoinScript.ScriptToAddress(scriptPubKey, _bitcoinNetwork);
diff --git a/boot_portal/Services/PeerBundleFetchLimiter.cs b/boot_portal/Services/PeerBundleFetchLimiter.cs
new file mode 100644
index 0000000..93365e4
--- /dev/null
+++ b/boot_portal/Services/PeerBundleFetchLimiter.cs
@@ -0,0 +1,52 @@
+namespace boot_portal.Services;
+
+public sealed class PeerBundleFetchLimiter
+{
+    private readonly int _limit;
+    private readonly TimeSpan _window;
+    private readonly object _sync = new();
+    private readonly Dictionary<string, Queue<DateTime>> _attempts = new(StringComparer.OrdinalIgnoreCase);
+
+    public PeerBundleFetchLimiter(int limit, TimeSpan window)
+    {
+        ArgumentOutOfRangeException.ThrowIfLessThan(limit, 1);
+        if (window <= TimeSpan.Zero)
+        {
+            throw new ArgumentOutOfRangeException(nameof(window));
+        }
+
+        _limit = limit;
+        _window = window;
+    }
+
+    public bool TryAcquire(string peerEndpoint, DateTime nowUtc)
+    {
+        if (string.IsNullOrWhiteSpace(peerEndpoint))
+        {
+            return false;
+        }
+
+        lock (_sync)
+        {
+            if (!_attempts.TryGetValue(peerEndpoint, out Queue<DateTime>? attempts))
+            {
+                attempts = new Queue<DateTime>();
+                _attempts[peerEndpoint] = attempts;
+            }
+
+            DateTime cutoff = nowUtc - _window;
+            while (attempts.TryPeek(out DateTime attempt) && attempt <= cutoff)
+            {
+                attempts.Dequeue();
+            }
+
+            if (attempts.Count >= _limit)
+            {
+                return false;
+            }
+
+            attempts.Enqueue(nowUtc);
+            return true;
+        }
+    }
+}
diff --git a/boot_portal/Utils/Bech32.cs b/boot_portal/Utils/Bech32.cs
index b1ae3cf..45a01cd 100644
--- a/boot_portal/Utils/Bech32.cs
+++ b/boot_portal/Utils/Bech32.cs
@@ -10,7 +10,7 @@ public static (string hrp, int version, byte[] program) Decode(string address)
         int sepIndex = address.LastIndexOf('1');
         if (sepIndex < 1) throw new FormatException("Invalid Bech32 address: no separator");
         string hrp = address.Substring(0, sepIndex).ToLower();
-        if (hrp != "bc" && hrp != "tb") throw new FormatException($"Invalid HRP: {hrp}");
+        if (hrp != "bc" && hrp != "tb" && hrp != "bcrt") throw new FormatException($"Invalid HRP: {hrp}");
 
         string dataPart = address.Substring(sepIndex + 1);
         if (dataPart.Length < 6) throw new FormatException("Bech32 data too short");
@@ -76,7 +76,7 @@ public static (string hrp, int version, byte[] program) Decode(string address)
 
     public static string Encode(string hrp, int version, byte[] program)
     {
-        if (hrp != "bc" && hrp != "tb") throw new ArgumentException($"Invalid HRP: {hrp}");
+        if (hrp != "bc" && hrp != "tb" && hrp != "bcrt") throw new ArgumentException($"Invalid HRP: {hrp}");
         if (version < 0 || version > 16) throw new ArgumentException($"Invalid witness version: {version}");
         if (program.Length < 2 || program.Length > 40) throw new ArgumentException($"Invalid program length: {program.Length}");
         
@@ -198,4 +198,4 @@ private static byte[] ConvertBits(byte[] data, int fromBits, int toBits, bool pa
         }
         return ret.ToArray();
     }
-}
\ No newline at end of file
+}
diff --git a/boot_portal/Utils/BitcoinHashes.cs b/boot_portal/Utils/BitcoinHashes.cs
index 407cbfc..5df7106 100644
--- a/boot_portal/Utils/BitcoinHashes.cs
+++ b/boot_portal/Utils/BitcoinHashes.cs
@@ -7,6 +7,7 @@ namespace boot_portal.Utils;
 public static class BitcoinHashes
 {
     private static readonly BigInteger BitcoinPowLimit = DecodeCompactTarget(0x1d00ffff);
+    private static readonly BigInteger RegtestPowLimit = DecodeCompactTarget(0x207fffff);
     public static string NormalizeHex(string? hex)
     {
         if (string.IsNullOrWhiteSpace(hex))
@@ -120,7 +121,10 @@ public static string ComputeBlockHashFromHeader(string? headerHex)
         return ToDisplayHashHex(second);
     }
 
-    public static BitcoinHeaderEvaluation EvaluateHeader(string? headerHex, DateTime receivedUtc)
+    public static BitcoinHeaderEvaluation EvaluateHeader(
+        string? headerHex,
+        DateTime receivedUtc,
+        string? bitcoinNetwork = BitcoinScript.Mainnet)
     {
         try
         {
@@ -138,7 +142,10 @@ public static BitcoinHeaderEvaluation EvaluateHeader(string? headerHex, DateTime
             uint timestamp = BinaryPrimitives.ReadUInt32LittleEndian(header.AsSpan(68, 4));
             uint compactTarget = BinaryPrimitives.ReadUInt32LittleEndian(header.AsSpan(72, 4));
             BigInteger target = DecodeCompactTarget(compactTarget);
-            if (target <= BigInteger.Zero || target > BitcoinPowLimit)
+            BigInteger proofOfWorkLimit = BitcoinScript.NormalizeNetwork(bitcoinNetwork) == BitcoinScript.Regtest
+                ? RegtestPowLimit
+                : BitcoinPowLimit;
+            if (target <= BigInteger.Zero || target > proofOfWorkLimit)
             {
                 return BitcoinHeaderEvaluation.Invalid("Header target is outside the Bitcoin proof-of-work limit.");
             }
@@ -160,7 +167,7 @@ public static BitcoinHeaderEvaluation EvaluateHeader(string? headerHex, DateTime
                 ReceivedUtc = receivedUtc
             };
         }
-        catch (Exception ex) when (ex is ArgumentException or FormatException or ArgumentOutOfRangeException)
+        catch (Exception ex) when (ex is ArgumentException or FormatException or ArgumentOutOfRangeException or InvalidOperationException)
         {
             return BitcoinHeaderEvaluation.Invalid(ex.Message);
         }
diff --git a/boot_portal/Utils/BitcoinScript.cs b/boot_portal/Utils/BitcoinScript.cs
index a294179..e4fdb34 100644
--- a/boot_portal/Utils/BitcoinScript.cs
+++ b/boot_portal/Utils/BitcoinScript.cs
@@ -6,6 +6,7 @@ public static class BitcoinScript
 {
     public const string Mainnet = "mainnet";
     public const string Testnet4 = "testnet4";
+    public const string Regtest = "regtest";
 
     public static string NormalizeNetwork(string? network)
     {
@@ -14,7 +15,8 @@ public static string NormalizeNetwork(string? network)
         {
             "" or "main" or "mainnet" => Mainnet,
             "test" or "testnet" or "testnet3" or "testnet4" => Testnet4,
-            _ => throw new InvalidOperationException($"Unsupported bitcoin_network '{network}'. Expected mainnet or testnet4.")
+            "regtest" => Regtest,
+            _ => throw new InvalidOperationException($"Unsupported bitcoin_network '{network}'. Expected mainnet, testnet4, or regtest.")
         };
     }
 
@@ -63,10 +65,11 @@ public static byte[] AddressToScriptPubKey(string address, string? network)
         }
 
         if (normalized.StartsWith("bc1", StringComparison.OrdinalIgnoreCase) ||
-            normalized.StartsWith("tb1", StringComparison.OrdinalIgnoreCase))
+            normalized.StartsWith("tb1", StringComparison.OrdinalIgnoreCase) ||
+            normalized.StartsWith("bcrt1", StringComparison.OrdinalIgnoreCase))
         {
             var (hrp, version, program) = Bech32.Decode(normalized);
-            string expectedHrp = normalizedNetwork == Testnet4 ? "tb" : "bc";
+            string expectedHrp = GetBech32Hrp(normalizedNetwork);
             if (!string.Equals(hrp, expectedHrp, StringComparison.OrdinalIgnoreCase))
             {
                 throw new InvalidOperationException($"Address {address} is not valid for bitcoin_network {normalizedNetwork}.");
@@ -96,8 +99,8 @@ public static byte[] AddressToScriptPubKey(string address, string? network)
         {
             0x00 when normalizedNetwork == Mainnet => BuildP2PkhScript(payload),
             0x05 when normalizedNetwork == Mainnet => BuildP2ShScript(payload),
-            0x6f when normalizedNetwork == Testnet4 => BuildP2PkhScript(payload),
-            0xc4 when normalizedNetwork == Testnet4 => BuildP2ShScript(payload),
+            0x6f when normalizedNetwork != Mainnet => BuildP2PkhScript(payload),
+            0xc4 when normalizedNetwork != Mainnet => BuildP2ShScript(payload),
             _ => throw new InvalidOperationException($"Unsupported Base58 version 0x{payload[0]:X2} for address {address}.")
         };
     }
@@ -128,7 +131,7 @@ public static string ScriptToAddress(byte[] script, string? network)
             script[24] == 0xAC)
         {
             byte[] payload = new byte[21];
-            payload[0] = normalizedNetwork == Testnet4 ? (byte)0x6f : (byte)0x00;
+            payload[0] = normalizedNetwork == Mainnet ? (byte)0x00 : (byte)0x6f;
             Array.Copy(script, 3, payload, 1, 20);
             return Base58Check.Encode(payload);
         }
@@ -139,7 +142,7 @@ public static string ScriptToAddress(byte[] script, string? network)
             script[22] == 0x87)
         {
             byte[] payload = new byte[21];
-            payload[0] = normalizedNetwork == Testnet4 ? (byte)0xc4 : (byte)0x05;
+            payload[0] = normalizedNetwork == Mainnet ? (byte)0x05 : (byte)0xc4;
             Array.Copy(script, 2, payload, 1, 20);
             return Base58Check.Encode(payload);
         }
@@ -147,24 +150,32 @@ public static string ScriptToAddress(byte[] script, string? network)
         if (script.Length == 22 && script[0] == 0x00 && script[1] == 0x14)
         {
             byte[] program = script.Skip(2).Take(20).ToArray();
-            return Bech32.Encode(normalizedNetwork == Testnet4 ? "tb" : "bc", 0, program);
+            return Bech32.Encode(GetBech32Hrp(normalizedNetwork), 0, program);
         }
 
         if (script.Length == 34 && script[0] == 0x00 && script[1] == 0x20)
         {
             byte[] program = script.Skip(2).Take(32).ToArray();
-            return Bech32.Encode(normalizedNetwork == Testnet4 ? "tb" : "bc", 0, program);
+            return Bech32.Encode(GetBech32Hrp(normalizedNetwork), 0, program);
         }
 
         if (script.Length == 34 && script[0] == 0x51 && script[1] == 0x20)
         {
             byte[] program = script.Skip(2).Take(32).ToArray();
-            return Bech32.Encode(normalizedNetwork == Testnet4 ? "tb" : "bc", 1, program);
+            return Bech32.Encode(GetBech32Hrp(normalizedNetwork), 1, program);
         }
 
         return "UNKNOWN";
     }
 
+    private static string GetBech32Hrp(string normalizedNetwork) => normalizedNetwork switch
+    {
+        Mainnet => "bc",
+        Testnet4 => "tb",
+        Regtest => "bcrt",
+        _ => throw new InvalidOperationException($"Unsupported bitcoin network '{normalizedNetwork}'.")
+    };
+
     private static byte[] BuildP2PkhScript(byte[] payload)
     {
         byte[] script = new byte[25];
diff --git a/boot_portal/Utils/PoolConfigValidator.cs b/boot_portal/Utils/PoolConfigValidator.cs
index a6022e7..18f1b53 100644
--- a/boot_portal/Utils/PoolConfigValidator.cs
+++ b/boot_portal/Utils/PoolConfigValidator.cs
@@ -77,6 +77,13 @@ public static List<string> Validate(PoolConfig config)
             errors.Add(ex.Message);
         }
 
+        if (config.AllowEmptySnapshotBootstrap &&
+            (!string.Equals(bitcoinNetwork, BitcoinScript.Regtest, StringComparison.OrdinalIgnoreCase) ||
+             IsProduction(config)))
+        {
+            errors.Add("allow_empty_snapshot_bootstrap is restricted to non-production regtest labs");
+        }
+
         if (!string.IsNullOrWhiteSpace(config.PoolPayoutScript) &&
             !BitcoinScript.TryAddressToScriptPubKey(config.PoolPayoutScript, bitcoinNetwork, out _))
         {
@@ -161,6 +168,7 @@ public static List<string> Validate(PoolConfig config)
         ValidatePositive(errors, config.NetworkReadRateLimitPerMinute, "network_read_rate_limit_per_minute");
         ValidatePositive(errors, config.DashboardReadRateLimitPerMinute, "dashboard_read_rate_limit_per_minute");
         ValidatePositive(errors, config.PeerWriteRateLimitPerMinute, "peer_write_rate_limit_per_minute");
+        ValidatePositive(errors, config.PeerStateBundleFetchRateLimitPerMinute, "peer_state_bundle_fetch_rate_limit_per_minute");
         ValidatePositive(errors, config.PeerSessionTarget, "peer_session_target");
         ValidatePositive(errors, config.PeerSessionConnectIntervalSeconds, "peer_session_connect_interval_seconds");
         ValidatePositive(errors, config.PeerSessionIdleTimeoutSeconds, "peer_session_idle_timeout_seconds");
@@ -198,6 +206,12 @@ public static List<string> Validate(PoolConfig config)
         }
         ValidatePositive(errors, config.AdminRateLimitPerMinute, "admin_rate_limit_per_minute");
         ValidatePositive(errors, config.MaxShareRequestBytes, "max_share_request_bytes");
+        ValidatePositive(errors, config.DatumMaxConnections, "datum_max_connections");
+        ValidatePositive(errors, config.DatumReadTimeoutSeconds, "datum_read_timeout_seconds");
+        if (config.DatumMaxConnections > 1024)
+        {
+            errors.Add("datum_max_connections must be 1024 or less");
+        }
         ValidatePositive(errors, config.MaxCoinbaseHexChars, "max_coinbase_hex_chars");
         ValidatePositive(errors, config.MaxMerklePathEntries, "max_merkle_path_entries");
         ValidatePositive(errors, config.HashrateSampleIntervalSeconds, "hashrate_sample_interval_seconds");
@@ -282,6 +296,11 @@ public static List<string> Validate(PoolConfig config)
             }
         }
 
+        if (config.EnableAdminApi && !HasStrongAdminKey(config.AdminApiKey))
+        {
+            errors.Add("admin_api_key must be a strong non-placeholder value whenever enable_admin_api is true");
+        }
+
         return errors;
     }
 
diff --git a/boot_portal/boot_portal.csproj b/boot_portal/boot_portal.csproj
index dfb3fe7..d3913f6 100644
--- a/boot_portal/boot_portal.csproj
+++ b/boot_portal/boot_portal.csproj
@@ -4,6 +4,8 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <RestoreLockedMode Condition="'$(ContinuousIntegrationBuild)' == 'true'">true</RestoreLockedMode>
   </PropertyGroup>
 
   <ItemGroup>
@@ -12,7 +14,6 @@
     <PackageReference Include="NetMQ" Version="4.0.2.2" />
     <PackageReference Include="NSec.Cryptography" Version="25.4.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
-    <PackageReference Include="System.Security.Cryptography.Xml" Version="9.0.18" />
   </ItemGroup>
 
   <ItemGroup>
@@ -20,4 +21,8 @@
     <None Remove="publish/**;**/pool_state*.json;boot_portal_config.json;boot_portal_config.local.json" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="boot.tests" />
+  </ItemGroup>
+
 </Project>
diff --git a/boot_portal/packages.lock.json b/boot_portal/packages.lock.json
new file mode 100644
index 0000000..12f3e18
--- /dev/null
+++ b/boot_portal/packages.lock.json
@@ -0,0 +1,68 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net10.0": {
+      "BouncyCastle.Cryptography": {
+        "type": "Direct",
+        "requested": "[2.6.1, )",
+        "resolved": "2.6.1",
+        "contentHash": "vZsG2YILhthgRqO+ZVgRff4ZFKKTl0v7kqaVBLCtRvpREhfBP33pcWrdA3PRYgWuFL1RxiUFvjMUHTdBZlJcoA=="
+      },
+      "LibSodium.Net": {
+        "type": "Direct",
+        "requested": "[0.16.0-alpha, )",
+        "resolved": "0.16.0-alpha",
+        "contentHash": "uNW5uuT2QEu5zUSDAbNyXM/RPZjnLjMEp88uYMCkH2yr9+jX7LpZsV9JZimdIABKiHivfGqSJAXmj3Bd2tmJUQ==",
+        "dependencies": {
+          "libsodium": "1.0.20.1"
+        }
+      },
+      "NetMQ": {
+        "type": "Direct",
+        "requested": "[4.0.2.2, )",
+        "resolved": "4.0.2.2",
+        "contentHash": "G2dNt5Fcv/wdZOwTkUksJBe8RUc4wJn38FTZw8UmH5tcEkPi3KM8ME8igJ1fR+1msNpEKfLzEfgJOA6RpOE1jA==",
+        "dependencies": {
+          "AsyncIO": "0.1.69",
+          "NaCl.Net": "0.1.13",
+          "System.ServiceModel.Primitives": "8.1.2"
+        }
+      },
+      "NSec.Cryptography": {
+        "type": "Direct",
+        "requested": "[25.4.0, )",
+        "resolved": "25.4.0",
+        "contentHash": "Z3wPpG0xefMLmhn9T+Ka/EzAmMQPT0THL/5E4lf9cXI/N9rbGH0G23ZFpRcPnD0ast2k7ieG6QSVNIjmfPCXBQ==",
+        "dependencies": {
+          "libsodium": "[1.0.20.1, 1.0.21)"
+        }
+      },
+      "System.CommandLine": {
+        "type": "Direct",
+        "requested": "[2.0.0-beta4.22272.1, )",
+        "resolved": "2.0.0-beta4.22272.1",
+        "contentHash": "1uqED/q2H0kKoLJ4+hI2iPSBSEdTuhfCYADeJrAqERmiGQ2NNacYKRNEQ+gFbU4glgVyK8rxI+ZOe1onEtr/Pg=="
+      },
+      "AsyncIO": {
+        "type": "Transitive",
+        "resolved": "0.1.69",
+        "contentHash": "xyXJLi+wjy6AtIyWXHXJkPS0gItqVT4lg5w++7bA5YEjugYKdrFMGxCo6KUJ1yYwjriLQJ1g35LDljZs3Q90XQ=="
+      },
+      "libsodium": {
+        "type": "Transitive",
+        "resolved": "1.0.20.1",
+        "contentHash": "pkiceEqJDQFHjbga3k/oPfTVX9g+GKJZ1VrkuiLhaymt9YNw1Dr7cX9hNuZuNaWcr9WD0moW55k4pMwzQ7JaZQ=="
+      },
+      "NaCl.Net": {
+        "type": "Transitive",
+        "resolved": "0.1.13",
+        "contentHash": "AVg1455RQnyTy6tiessudruZHvbl70QWRPyx3og2I1Fei17LDNc7Z3DRgqN2+PsySBui/1EDP4A7adhQXydi6g=="
+      },
+      "System.ServiceModel.Primitives": {
+        "type": "Transitive",
+        "resolved": "8.1.2",
+        "contentHash": "xlJ07FAUSDjPL/GhvVY1/KVPWn2ce056X4nHPwqAa5rkNLiNN5rqh6VcgMUoF6J7ckwhkVJ1vVx/K/47nyyR9g=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/boot_portal/ui/package-lock.json b/boot_portal/ui/package-lock.json
index d5d5364..ff20382 100644
--- a/boot_portal/ui/package-lock.json
+++ b/boot_portal/ui/package-lock.json
@@ -26,7 +26,7 @@
         "jsdom": "^26.1.0",
         "typescript": "~5.8.3",
         "vite": "^7.0.4",
-        "vitest": "^3.2.4"
+        "vitest": "^4.1.11"
       }
     },
     "node_modules/@adobe/css-tools": {
@@ -1360,6 +1360,13 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@testing-library/dom": {
       "version": "10.4.1",
       "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
@@ -1580,39 +1587,40 @@
       }
     },
     "node_modules/@vitest/expect": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.7.tgz",
-      "integrity": "sha512-E8eBXaKibuvH2pSZErOjdVb5vF4PbKYcrnluBTYxEk1l/VhhwZg1kZQsdtjq+CsF5CFydf2Rdkz7jDHKSisi3w==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.11.tgz",
+      "integrity": "sha512-VX2x5vNJXET47KAFzwERI+KRMtTTCSWTfSMKsW7JsUsXV4psq++e3DvZpuTDOpHcxytiDs6p2nhVb2tVDiiUYw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
         "@types/chai": "^5.2.2",
-        "@vitest/spy": "3.2.7",
-        "@vitest/utils": "3.2.7",
-        "chai": "^5.2.0",
-        "tinyrainbow": "^2.0.0"
+        "@vitest/spy": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/mocker": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.7.tgz",
-      "integrity": "sha512-Trr0hYO9CM3Wj6ksWHRhK9IZpIY6wTMO5u/MqXurMxT57sWBaOPEtP3Oq60ihZuh5JsiagKfz95OcxdEP6dBrA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.11.tgz",
+      "integrity": "sha512-2XJVD55d1o5AZous5CCGKS74g/riOj9odEt2bQpCVZeblHyHdnMeFl4jl0XjU21stf4mbjUkew2eXQZt65g5CQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "3.2.7",
+        "@vitest/spy": "4.1.11",
         "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.17"
+        "magic-string": "^0.30.21"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "msw": "^2.4.9",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "msw": {
@@ -1624,42 +1632,42 @@
       }
     },
     "node_modules/@vitest/pretty-format": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.7.tgz",
-      "integrity": "sha512-KUHlwqVu0sRlhCdyPdQ/wBoTfRahjUky1MubOmYw9fWfIZy1gNoHpuaaQBPAaMaVYdQYHJLurzj8ECCj5OwTqA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.11.tgz",
+      "integrity": "sha512-yiZzPbGTS9Sr/JpFl8zHrcIkAofNbFV6k21vIgQN/cY/oxZeXhJv5sc/MBJ5jFKWmWs+oJHw0UXLZjmf931+Vw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tinyrainbow": "^2.0.0"
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.7.tgz",
-      "integrity": "sha512-sB9y4ovltoQP+WaUPwmSxO9WIg9Ig694Di5PalVPsYHklAdE027mehpWF2SQSVq+k6sFgaivbTjTJwZLSHbedA==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.11.tgz",
+      "integrity": "sha512-LztvUgdwMNJMIkj3hQnnxiC2Xy1zNxq928W/xhjCLaNCzqTZOudjwbQf6v9IntZGPw132i2Lq2rgTRZHD3JHNw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "3.2.7",
-        "pathe": "^2.0.3",
-        "strip-literal": "^3.0.0"
+        "@vitest/utils": "4.1.11",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.7.tgz",
-      "integrity": "sha512-7C+MwShwtBSI5Buwoyg3s/iY1eHL9PKAf+O1wVh/TdnjXUtkoL/9YQtre90i4MtNXM6edP1wJ2zOBpfCyhIS7g==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.11.tgz",
+      "integrity": "sha512-pN7ikn1ON7h8ee4gIAp4AzyK+zBtJPzVbqOgu5LCEh4VaJVbPQcgYQYJIMGQPXVeJJq1fnfazis7a5pFNPahog==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "3.2.7",
-        "magic-string": "^0.30.17",
+        "@vitest/pretty-format": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "magic-string": "^0.30.21",
         "pathe": "^2.0.3"
       },
       "funding": {
@@ -1667,28 +1675,25 @@
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.7.tgz",
-      "integrity": "sha512-Q2eQGI6d2L/hBtZ0qNuKcAGid68XK6cv1xsoaIma6PaJhHPoqcEJhYpXZ/5myCMqkNgtP6UKuBhbc0nHKnrkuQ==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.11.tgz",
+      "integrity": "sha512-apNa/prQy2qCeywhnixOHPRCgGNhvg7T4Dapfl1GahLp/R+uhBm5cPyFoNVyqsNd2h1nJxL6BqqdIjiABL60YA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "tinyspy": "^4.0.3"
-      },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.7.tgz",
-      "integrity": "sha512-x6BDOd7dyo3PFLY3I9/HJ25X/6OurhGXk2/B9gOZNPF7XDVjeBK4k01lQE5uvDpbuheErh91qYuE1E2OEjK3Rw==",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.11.tgz",
+      "integrity": "sha512-zTCVGpyFsGWBhllOyKlTw/vnr6D9qxsfSDyfbyZmTyjHw5N/VuvzHpHoQjm2ZJzn4RJgx5w4r7V0er69CmLgPQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "3.2.7",
-        "loupe": "^3.1.4",
-        "tinyrainbow": "^2.0.0"
+        "@vitest/pretty-format": "4.1.11",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -1808,16 +1813,6 @@
         "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/caniuse-lite": {
       "version": "1.0.30001806",
       "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001806.tgz",
@@ -1840,32 +1835,15 @@
       "license": "CC-BY-4.0"
     },
     "node_modules/chai": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
-      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "assertion-error": "^2.0.1",
-        "check-error": "^2.1.1",
-        "deep-eql": "^5.0.1",
-        "loupe": "^3.1.0",
-        "pathval": "^2.0.0"
-      },
       "engines": {
         "node": ">=18"
       }
     },
-    "node_modules/check-error": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
-      "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 16"
-      }
-    },
     "node_modules/convert-source-map": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
@@ -1940,16 +1918,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/deep-eql": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
-      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/dequal": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -1989,9 +1957,9 @@
       }
     },
     "node_modules/es-module-lexer": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
-      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
+      "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
       "dev": true,
       "license": "MIT"
     },
@@ -2317,13 +2285,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/loupe": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
-      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -2373,9 +2334,9 @@
       "license": "MIT"
     },
     "node_modules/nanoid": {
-      "version": "3.3.16",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
-      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "version": "3.3.18",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",
+      "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",
       "dev": true,
       "funding": [
         {
@@ -2450,6 +2411,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/obug": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.2.1.tgz",
+      "integrity": "sha512-XrsrhT5sybtKI6wakr2SPOlGZWWYbUXZ7a0jT8/QOeAPau+1X/bSegNe5YR75oJmEZQbKningirmGOEJCIk61Q==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
     "node_modules/parse5": {
       "version": "7.3.0",
       "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
@@ -2470,16 +2445,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/pathval": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
-      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.16"
-      }
-    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -2782,9 +2747,9 @@
       "license": "MIT"
     },
     "node_modules/std-env": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
-      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+      "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
       "dev": true,
       "license": "MIT"
     },
@@ -2801,26 +2766,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/strip-literal": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz",
-      "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "js-tokens": "^9.0.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
-      }
-    },
-    "node_modules/strip-literal/node_modules/js-tokens": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
-      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/symbol-tree": {
       "version": "3.2.4",
       "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
@@ -2836,11 +2781,14 @@
       "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
-      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.1.tgz",
+      "integrity": "sha512-GCvB3aoys96IuDFBMcTB46JOR6mdMtAToqwiW8JlWhsoh1mhHi/xn9ss/Dg7N555GiJyEt2qzoG/NHCwM6h1EA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
     },
     "node_modules/tinyglobby": {
       "version": "0.2.17",
@@ -2859,30 +2807,10 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
-    "node_modules/tinypool": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
-      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      }
-    },
     "node_modules/tinyrainbow": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
-      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/tinyspy": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz",
-      "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz",
+      "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3083,29 +3011,6 @@
         }
       }
     },
-    "node_modules/vite-node": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
-      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.4.1",
-        "es-module-lexer": "^1.7.0",
-        "pathe": "^2.0.3",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
-      },
-      "bin": {
-        "vite-node": "vite-node.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
     "node_modules/vite/node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -3122,65 +3027,79 @@
       }
     },
     "node_modules/vitest": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.7.tgz",
-      "integrity": "sha512-KrxIJ62Fd89gfysR4WotlgZABiz2dqFPgqGzX7s+CwsqLFomRH7777ZcrOD6+WVAh7khPQP41A+BKbpcJFrdEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/chai": "^5.2.2",
-        "@vitest/expect": "3.2.7",
-        "@vitest/mocker": "3.2.7",
-        "@vitest/pretty-format": "^3.2.7",
-        "@vitest/runner": "3.2.7",
-        "@vitest/snapshot": "3.2.7",
-        "@vitest/spy": "3.2.7",
-        "@vitest/utils": "3.2.7",
-        "chai": "^5.2.0",
-        "debug": "^4.4.1",
-        "expect-type": "^1.2.1",
-        "magic-string": "^0.30.17",
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.11.tgz",
+      "integrity": "sha512-fhACrNXUidIbGSBr5FlbuBkO7VWC1ZyLl0DO4CU2DrQoAPxX84Ysxs+HeGQpii5lZWV1Q4gBZTTu49mF+A6Edw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.11",
+        "@vitest/mocker": "4.1.11",
+        "@vitest/pretty-format": "4.1.11",
+        "@vitest/runner": "4.1.11",
+        "@vitest/snapshot": "4.1.11",
+        "@vitest/spy": "4.1.11",
+        "@vitest/utils": "4.1.11",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
         "pathe": "^2.0.3",
-        "picomatch": "^4.0.2",
-        "std-env": "^3.9.0",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
         "tinybench": "^2.9.0",
-        "tinyexec": "^0.3.2",
-        "tinyglobby": "^0.2.14",
-        "tinypool": "^1.1.1",
-        "tinyrainbow": "^2.0.0",
-        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
-        "vite-node": "3.2.4",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
         "why-is-node-running": "^2.3.0"
       },
       "bin": {
         "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "@edge-runtime/vm": "*",
-        "@types/debug": "^4.1.12",
-        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
-        "@vitest/browser": "3.2.7",
-        "@vitest/ui": "3.2.7",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.11",
+        "@vitest/browser-preview": "4.1.11",
+        "@vitest/browser-webdriverio": "4.1.11",
+        "@vitest/coverage-istanbul": "4.1.11",
+        "@vitest/coverage-v8": "4.1.11",
+        "@vitest/ui": "4.1.11",
         "happy-dom": "*",
-        "jsdom": "*"
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "@edge-runtime/vm": {
           "optional": true
         },
-        "@types/debug": {
+        "@opentelemetry/api": {
           "optional": true
         },
         "@types/node": {
           "optional": true
         },
-        "@vitest/browser": {
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
           "optional": true
         },
         "@vitest/ui": {
@@ -3191,6 +3110,9 @@
         },
         "jsdom": {
           "optional": true
+        },
+        "vite": {
+          "optional": false
         }
       }
     },
diff --git a/boot_portal/ui/package.json b/boot_portal/ui/package.json
index 5dac233..62d1143 100644
--- a/boot_portal/ui/package.json
+++ b/boot_portal/ui/package.json
@@ -32,6 +32,6 @@
     "jsdom": "^26.1.0",
     "typescript": "~5.8.3",
     "vite": "^7.0.4",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.11"
   }
 }
diff --git a/boot_portal/ui/src/components/SystemMap.test.tsx b/boot_portal/ui/src/components/SystemMap.test.tsx
index 55db036..b89ad57 100644
--- a/boot_portal/ui/src/components/SystemMap.test.tsx
+++ b/boot_portal/ui/src/components/SystemMap.test.tsx
@@ -354,7 +354,11 @@ describe("GridPool system map", () => {
 
   it("settles motion immediately for reduced-motion observers", () => {
     vi.useFakeTimers();
-    const matchMedia = vi.spyOn(window, "matchMedia").mockImplementation((query) => ({
+    const originalMatchMedia = Object.getOwnPropertyDescriptor(window, "matchMedia");
+    Object.defineProperty(window, "matchMedia", {
+      configurable: true,
+      writable: true,
+      value: vi.fn((query: string) => ({
       matches: query.includes("prefers-reduced-motion"),
       media: query,
       onchange: null,
@@ -363,7 +367,8 @@ describe("GridPool system map", () => {
       addEventListener: vi.fn(),
       removeEventListener: vi.fn(),
       dispatchEvent: vi.fn()
-    }));
+      }))
+    });
     const complete = vi.fn();
     render(
       <SystemMap
@@ -376,7 +381,11 @@ describe("GridPool system map", () => {
 
     act(() => vi.advanceTimersByTime(180));
     expect(complete).toHaveBeenCalledOnce();
-    matchMedia.mockRestore();
+    if (originalMatchMedia) {
+      Object.defineProperty(window, "matchMedia", originalMatchMedia);
+    } else {
+      delete (window as unknown as { matchMedia?: unknown }).matchMedia;
+    }
     vi.useRealTimers();
   });
 });
diff --git a/docker/boot_portal_config.sample.json b/docker/boot_portal_config.sample.json
index 8073573..8a55afc 100644
--- a/docker/boot_portal_config.sample.json
+++ b/docker/boot_portal_config.sample.json
@@ -72,9 +72,12 @@
   "dashboard_read_rate_limit_per_minute": 180,
   "trusted_forwarded_proxy_ranges": [],
   "peer_write_rate_limit_per_minute": 90,
+  "peer_state_bundle_fetch_rate_limit_per_minute": 12,
   "mining_api_share_rate_limit_per_minute": 120,
   "admin_rate_limit_per_minute": 12,
   "max_share_request_bytes": 262144,
+  "datum_max_connections": 32,
+  "datum_read_timeout_seconds": 15,
   "max_coinbase_hex_chars": 20000,
   "max_merkle_path_entries": 64,
   "testing_round_reset_mode": "none",
@@ -84,7 +87,7 @@
   "v22_activation_block_height": 959500,
   "enable_admin_api": false,
   "admin_api_key": "change-this-admin-key",
-  "pool_payout_script": "bc1qrwsx8fs0l6z7ugp5cvzy6lhss7jlyru3kg9s8y",
+  "pool_payout_script": "",
   "winners_list_size": 299,
   "grid_labs_support_fee_enabled": true,
   "work_set_reserve_multiplier": 3,
diff --git a/docker/boot_portal_config.testnet4.sample.json b/docker/boot_portal_config.testnet4.sample.json
index 136fce6..34ea779 100644
--- a/docker/boot_portal_config.testnet4.sample.json
+++ b/docker/boot_portal_config.testnet4.sample.json
@@ -72,9 +72,12 @@
   "dashboard_read_rate_limit_per_minute": 180,
   "trusted_forwarded_proxy_ranges": [],
   "peer_write_rate_limit_per_minute": 90,
+  "peer_state_bundle_fetch_rate_limit_per_minute": 12,
   "mining_api_share_rate_limit_per_minute": 120,
   "admin_rate_limit_per_minute": 12,
   "max_share_request_bytes": 262144,
+  "datum_max_connections": 32,
+  "datum_read_timeout_seconds": 15,
   "max_coinbase_hex_chars": 20000,
   "max_merkle_path_entries": 64,
   "testing_round_reset_mode": "none",
@@ -84,7 +87,7 @@
   "v22_activation_block_height": 0,
   "enable_admin_api": false,
   "admin_api_key": "change-this-admin-key",
-  "pool_payout_script": "mxt9bYPtfBdzoTeZcHr23QgL4Un45PVvF5",
+  "pool_payout_script": "",
   "winners_list_size": 299,
   "grid_labs_support_fee_enabled": true,
   "work_set_reserve_multiplier": 3,
diff --git a/docs/README.md b/docs/README.md
index 58f8702..23aff8e 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -35,6 +35,8 @@ documentation.
 - [Critical State-Validation Security Release](security-release-rt-2026-041-042.md):
   release-candidate behavior and retest gate for proof-backed state sync and
   locally confirmed GridPool block payments.
+- [Regtest Release-Retest Lab](regtest-release-retest.md): isolated two-node
+  setup, normal lifecycle checks, convergence verification, and evidence capture.
 
 ## Operators
 
diff --git a/docs/regtest-release-retest.md b/docs/regtest-release-retest.md
new file mode 100644
index 0000000..9231386
--- /dev/null
+++ b/docs/regtest-release-retest.md
@@ -0,0 +1,259 @@
+# GridPool Regtest Release-Retest Lab
+
+This guide builds a disposable two-node GridPool lab backed by one Bitcoin Core
+regtest node. It covers setup, normal operation, lifecycle checks, convergence,
+and evidence collection. It does not describe exploit traffic or offensive
+testing.
+
+## Safety Boundary
+
+- Use a dedicated host, VM, or private CI runner.
+- Keep the Docker network internal and bind observer ports to `127.0.0.1`.
+- Do not use public GridPool peers or production credentials.
+- Generate disposable RPC credentials, payout addresses, identities, and state.
+- Record exact GridPool commits and Bitcoin Core image digests.
+- Never copy identity or state files between GridPool nodes.
+
+## 1. Pin The Candidate
+
+Requirements: Docker Engine with Compose v2, Git, `curl`, `jq`, `openssl`, and
+a verified Bitcoin Core release. Recommended host capacity is four CPU threads,
+8 GB RAM, and 20 GB free.
+
+```bash
+export LAB_ROOT="$HOME/gridpool-release-lab"
+export GRIDPOOL_REPO="$HOME/src/boot-protocol"
+export CANDIDATE_COMMIT="REPLACE_WITH_IMMUTABLE_COMMIT"
+
+mkdir -p "$LAB_ROOT/worktrees"
+git -C "$GRIDPOOL_REPO" fetch --all --tags --prune
+git -C "$GRIDPOOL_REPO" worktree add --detach \
+  "$LAB_ROOT/worktrees/candidate" "$CANDIDATE_COMMIT"
+git -C "$LAB_ROOT/worktrees/candidate" rev-parse HEAD
+```
+
+Do not move this worktree to another revision during the run.
+
+## 2. Private Inputs
+
+Place verified `bitcoind` and `bitcoin-cli` binaries under
+`$LAB_ROOT/core-dist/bin/`, then create disposable inputs:
+
+```bash
+cd "$LAB_ROOT"
+mkdir -p node-a node-b artifacts core-dist/bin
+chmod 700 node-a node-b artifacts
+umask 077
+cat > .env <<EOF
+GRIDPOOL_SOURCE=$LAB_ROOT/worktrees/candidate
+GRIDPOOL_TAG=rt076-candidate
+RPC_USER=gridpool_regtest
+RPC_PASSWORD=$(openssl rand -hex 32)
+LAB_NETWORK_ID=gridpool-regtest-$(openssl rand -hex 6)
+EOF
+chmod 600 .env
+```
+
+Create `Dockerfile.bitcoin`:
+
+```dockerfile
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates libevent-2.1-7 && rm -rf /var/lib/apt/lists/*
+COPY core-dist/bin/bitcoind /usr/local/bin/bitcoind
+COPY core-dist/bin/bitcoin-cli /usr/local/bin/bitcoin-cli
+RUN chmod 0755 /usr/local/bin/bitcoind /usr/local/bin/bitcoin-cli
+ENTRYPOINT ["bitcoind"]
+```
+
+## 3. Compose Topology
+
+Create `compose.yaml`:
+
+```yaml
+name: gridpool-release-lab
+services:
+  bitcoin:
+    build:
+      context: .
+      dockerfile: Dockerfile.bitcoin
+    command:
+      - -regtest=1
+      - -server=1
+      - -printtoconsole=1
+      - -fallbackfee=0.00001
+      - -rpcbind=0.0.0.0
+      - -rpcallowip=172.16.0.0/12
+      - -rpcuser=${RPC_USER}
+      - -rpcpassword=${RPC_PASSWORD}
+      - -zmqpubhashblock=tcp://0.0.0.0:28332
+      - -zmqpubrawblock=tcp://0.0.0.0:28333
+    volumes: ["bitcoin-data:/root/.bitcoin"]
+    networks: [lab]
+
+  node-a:
+    build:
+      context: ${GRIDPOOL_SOURCE}
+      dockerfile: Dockerfile
+    image: gridpool-release-lab:${GRIDPOOL_TAG}
+    environment:
+      BOOT_PORTAL_CONFIG_PATH: /data/config.json
+      BOOT_PORTAL_STATE_PATH: /data/pool_state.json
+      GRIDPOOL_RELEASE_VERSION: release-lab-${GRIDPOOL_TAG}
+    volumes: ["./node-a:/data"]
+    ports: ["127.0.0.1:15001:5000"]
+    networks: [lab]
+
+  node-b:
+    image: gridpool-release-lab:${GRIDPOOL_TAG}
+    environment:
+      BOOT_PORTAL_CONFIG_PATH: /data/config.json
+      BOOT_PORTAL_STATE_PATH: /data/pool_state.json
+      GRIDPOOL_RELEASE_VERSION: release-lab-${GRIDPOOL_TAG}
+    volumes: ["./node-b:/data"]
+    ports: ["127.0.0.1:15002:5000"]
+    networks: [lab]
+
+networks:
+  lab:
+    internal: true
+volumes:
+  bitcoin-data:
+```
+
+RPC and ZMQ are reachable only inside the private Compose network.
+
+## 4. Initialize Regtest
+
+```bash
+set -a; source "$LAB_ROOT/.env"; set +a
+docker compose --env-file .env up -d --build bitcoin
+until docker compose exec -T bitcoin bitcoin-cli \
+  -regtest -rpcuser="$RPC_USER" -rpcpassword="$RPC_PASSWORD" \
+  getblockchaininfo >/dev/null 2>&1; do sleep 1; done
+
+docker compose exec -T bitcoin bitcoin-cli \
+  -regtest -rpcuser="$RPC_USER" -rpcpassword="$RPC_PASSWORD" \
+  -named createwallet wallet_name=lab load_on_startup=true
+
+export LAB_PAYOUT_ADDRESS="$(docker compose exec -T bitcoin bitcoin-cli \
+  -regtest -rpcuser="$RPC_USER" -rpcpassword="$RPC_PASSWORD" \
+  -rpcwallet=lab getnewaddress "" bech32 | tr -d '\r')"
+case "$LAB_PAYOUT_ADDRESS" in bcrt1*) ;; *) exit 1 ;; esac
+
+docker compose exec -T bitcoin bitcoin-cli \
+  -regtest -rpcuser="$RPC_USER" -rpcpassword="$RPC_PASSWORD" \
+  -rpcwallet=lab generatetoaddress 101 "$LAB_PAYOUT_ADDRESS"
+```
+
+## 5. Node Configuration
+
+Render a mode-600 `/data/config.json` for each node. Use the `.env` values for
+credentials and network ID rather than literal placeholders:
+
+```json
+{
+  "NotificationSource": "BitcoinZmq",
+  "bitcoin_notification_mode": "attached-node",
+  "bitcoin_rpc_url": "http://bitcoin:18443",
+  "bitcoin_rpc_username": "FROM_ENV",
+  "bitcoin_rpc_password": "FROM_ENV",
+  "bitcoin_zmq_endpoint": "tcp://bitcoin:28332",
+  "bitcoin_zmq_rawblock_endpoint": "tcp://bitcoin:28333",
+  "bitcoin_network": "regtest",
+  "boot_network_id": "UNIQUE_SHARED_LAB_ID",
+  "boot_protocol_version": 22,
+  "v22_activation_block_height": 0,
+  "node_mode": "development",
+  "pool_payout_script": "DISPOSABLE_BCRT1_ADDRESS",
+  "grid_labs_support_fee_enabled": false,
+  "enable_web_ui": false,
+  "enable_admin_api": false,
+  "enable_peer_sync": true,
+  "peer_allow_private_advertisements": true,
+  "enable_peer_persistent_sessions": true,
+  "enable_peer_udp_fast_relay": false,
+  "enable_peer_tip_stale_protection": false,
+  "pause_mining_on_outbound_relay_stale": false,
+  "min_diff": 1,
+  "allow_empty_snapshot_bootstrap": true
+}
+```
+
+Use `http://node-a:5000` and `http://node-b:5000` as their respective
+`public_base_url` values. Configure `bootstrap_peers` with only the other node.
+Set file ownership to the image user, currently UID/GID `1000:1000`.
+
+`allow_empty_snapshot_bootstrap` is required only for the RT-2026-076
+completeness regression. It is rejected outside non-production regtest and
+must never appear in mainnet or appliance configuration.
+
+## 6. Start And Baseline
+
+```bash
+docker compose --env-file .env build --no-cache node-a
+docker compose --env-file .env up -d node-a node-b
+until curl -fsS http://127.0.0.1:15001/api/network/summary >/dev/null; do sleep 1; done
+until curl -fsS http://127.0.0.1:15002/api/network/summary >/dev/null; do sleep 1; done
+
+for port in 15001 15002; do
+  curl -fsS "http://127.0.0.1:${port}/api/network/summary" |
+    jq '{nodeId,networkId,bitcoinNetwork,currentTipBlockHeight,
+         currentTipBlockHash,currentStateId,candidateStateId,activeSnapshotId,
+         peerCount,miningWorkSafe,bitcoinNotification}'
+done
+```
+
+Expected baseline: `bitcoinNetwork=regtest`, synchronized RPC, both ZMQ topics
+active, one private peer per node, and matching tip/state identifiers. Generate
+one ordinary block and confirm both nodes advance exactly once:
+
+```bash
+docker compose exec -T bitcoin bitcoin-cli \
+  -regtest -rpcuser="$RPC_USER" -rpcpassword="$RPC_PASSWORD" \
+  -rpcwallet=lab generatetoaddress 1 "$LAB_PAYOUT_ADDRESS"
+sleep 3
+```
+
+## 7. Defensive Release Checks
+
+Using ordinary valid lab traffic, verify:
+
+1. Share-first and notification-first valid block orderings each record one
+   payment transition, never two.
+2. Paid proof IDs are removed once and absent from later payout plans.
+3. A node stopped across an ordinary boundary rejoins and converges from a
+   complete proof-backed sibling bundle.
+4. The explicit empty-bootstrap variant converges while enabled.
+5. Restarting either node preserves identity, state, and paid lineage.
+6. A one-block regtest reorganization follows the V2.2 rollback path and both
+   nodes reconverge.
+
+These are outcome checks, not instructions for malformed or hostile inputs.
+
+## 8. Evidence And Reset
+
+```bash
+export RUN_DIR="$LAB_ROOT/artifacts/$(date -u +%Y%m%dT%H%M%SZ)"
+mkdir -p "$RUN_DIR"; chmod 700 "$RUN_DIR"
+git -C "$GRIDPOOL_SOURCE" rev-parse HEAD > "$RUN_DIR/gridpool-commit.txt"
+docker compose images --format json > "$RUN_DIR/images.json"
+docker compose ps --format json > "$RUN_DIR/compose-ps.json"
+docker compose logs --no-color > "$RUN_DIR/compose.log" 2>&1
+curl -fsS http://127.0.0.1:15001/api/network/summary > "$RUN_DIR/node-a.json"
+curl -fsS http://127.0.0.1:15002/api/network/summary > "$RUN_DIR/node-b.json"
+sha256sum "$RUN_DIR"/* > "$RUN_DIR/SHA256SUMS"
+```
+
+Review artifacts for credentials before sharing. Reset only after preserving
+evidence:
+
+```bash
+docker compose --env-file .env down -v --remove-orphans
+rm -rf "$LAB_ROOT/node-a" "$LAB_ROOT/node-b"
+mkdir -p "$LAB_ROOT/node-a" "$LAB_ROOT/node-b"
+chmod 700 "$LAB_ROOT/node-a" "$LAB_ROOT/node-b"
+```
+
+Every candidate run must start from a documented clean state. Never reuse a
+baseline state volume with a candidate image.
diff --git a/docs/security-hardening-rt-043-049.md b/docs/security-hardening-rt-043-049.md
new file mode 100644
index 0000000..c99c7f8
--- /dev/null
+++ b/docs/security-hardening-rt-043-049.md
@@ -0,0 +1,54 @@
+# Follow-on Security Hardening Candidate
+
+This branch is intentionally separate from
+`codex/security-rt-041-042@400fc6e`. Commit `400fc6e` remains immutable for the
+independent retest of RT-2026-041 and RT-2026-042. The controls below are a
+follow-on candidate and must not be described as independently verified until
+that review is recorded and the branches are deliberately integrated.
+
+## Implemented Controls
+
+- DATUM connections, declared message length, and read time are bounded before
+  allocating or waiting for a message body.
+- Miner labels are bounded and normalized before storage; legacy dynamic HTML
+  output escapes miner-controlled labels and responses carry a restrictive CSP.
+- Reachability tests require authenticated administration, reject non-public
+  destinations, disable redirects, validate the actual connection address, and
+  no longer implement unauthenticated UDP callbacks.
+- A fresh mining proof cannot teach the node a Bitcoin parent. Parent authority
+  comes from the attached Bitcoin source; retained proof recovery remains in the
+  validating state reconciliation path.
+- Payout configuration fails closed. DATUM work is unavailable without a valid,
+  explicitly configured payout identity.
+- Snapshot payout validation accepts the canonical configured variant only.
+- Candidate-state fetch decisions do not trust peer-claimed total difficulty,
+  and outbound state-bundle fetches have a per-peer budget.
+- One- and two-block RPC reconciliation use the reorganization path and unwind
+  removed snapshot families before applying a replacement boundary.
+- Repeated failed RPC polls cannot renew the attached-node safety grace period;
+  mining becomes unsafe after the configured grace until synchronized RPC
+  authority returns.
+- NuGet restores are locked, container bases are digest-pinned, mutable-branch
+  live updates are refused, and CI performs dependency, secret, and filesystem
+  vulnerability checks.
+
+The repository history contains retired prototype node identities from early
+tracked configuration files, plus audited test/command false positives. Their
+exact Gitleaks fingerprints are baselined in `.gitleaksignore`; those historical
+identities are considered compromised and must never be used by an active
+node. Any finding outside that immutable baseline fails CI.
+
+## Verification
+
+Run:
+
+```bash
+dotnet restore boot_portal.slnx --locked-mode
+dotnet test boot_portal.slnx --no-restore
+dotnet list boot_portal/boot_portal.csproj package --vulnerable --include-transitive
+dotnet list boot.tests/boot.tests.csproj package --vulnerable --include-transitive
+```
+
+Package deployment and the public soak remain blocked on the exact `400fc6e`
+retest, review of this follow-on branch, deliberate integration into the current
+runtime line, and appliance acceptance against digest-locked images.
diff --git a/docs/security-release-rt-2026-041-042.md b/docs/security-release-rt-2026-041-042.md
index df2bf0c..010218a 100644
--- a/docs/security-release-rt-2026-041-042.md
+++ b/docs/security-release-rt-2026-041-042.md
@@ -1,13 +1,16 @@
 # GridPool Critical State-Validation Security Release
 
-Status: release candidate for independent red-team verification.
+Status: original critical findings independently verified; follow-up candidate
+required for RT-2026-076 and complete regtest transition coverage.
 
 Integration note (2026-08-24): the exact candidate `400fc6e` is preserved at
 tag `security-rt-041-042-retest-candidate` and has been merged into `develop`
 through `d542af6` so feature work can proceed from the intended defensive
-behavior. Independent verification remains pending; development builds that
-contain it are not security-certified releases and must not be promoted to
-`main` or deployed as the public release candidate yet.
+behavior. Independent verification on 2026-08-26 confirmed RT-2026-041 and
+RT-2026-042 are closed. The same run surfaced RT-2026-076, a false rejection of
+complete sibling bundles containing a proof recorded against an empty
+bootstrap plan, plus regtest transition gaps. Development builds must not be
+promoted to `main` until the follow-up candidate passes the remaining gates.
 
 This release closes two critical state-transition classes found during the
 pre-beta security review. It does not change the V2.2 consensus version or
@@ -30,6 +33,11 @@ already intended to require.
 This handles both event orders: share before Bitcoin notification, and Bitcoin
 notification before share.
 
+The follow-up candidate additionally preserves a notification-first block
+share when the attached node has already validated that exact block onto its
+active chain. This is not a general stale-share exception: the block hash must
+match the locally retained header, current tip, and trusted local tip.
+
 ## State-Bundle Validation
 
 - Current-state and bootstrap bundles with a non-empty Winners List and no
@@ -57,18 +65,40 @@ A future bootstrap format may restore late-join synchronization after paid
 rounds by carrying independently verifiable block/payment lineage. Until then,
 the implementation fails closed rather than trusting peer assertions.
 
+## RT-2026-076 Completeness Path
+
+Production GridPool is not expected to have an empty payout plan: mainnet
+already has a populated Winners List, and an intentional restart must seed at
+least one shared payout address. Empty-plan support is therefore an explicit
+lab compatibility path, not a mainnet bootstrap mechanism.
+
+- `allow_empty_snapshot_bootstrap` defaults to `false`.
+- It is accepted only with `bitcoin_network: regtest` in a non-production mode.
+- The context must have zero proof IDs, empty normal and fee-free Winners Lists,
+  and the canonical state ID for that zero-proof plan.
+- Arbitrary empty peer contexts remain invalid; production/mainnet nodes remain
+  fail-closed.
+
+The runtime also supports the regtest PoW limit, `bcrt1` addresses, and explicit
+RPC chain-name matching. Do not use the historical testnet4-over-regtest shim.
+
 ## Verification Gate
 
 Before promotion to `main` or deployment:
 
 1. Run the full `boot.tests` suite.
-2. Repeat RT-2026-041 against the exact release-candidate commit and verify that
+2. Preserve the completed RT-2026-041 verdict and verify on the follow-up that
    the candidate share cannot change current state, round, trusted tip, Winners
    List, or paid lineage.
-3. Repeat RT-2026-042 through both HTTP polling and persistent peer gossip and
+3. Preserve the completed RT-2026-042 verdict and verify through both HTTP
+   polling and persistent peer gossip that
    verify that every node rejects the proofless bundle without state mutation.
 4. Verify one legitimate attached-node GridPool block transition on regtest,
    including both share-first and notification-first event orderings.
 5. Verify a valid V2.2 sibling merge still succeeds with complete proofs.
+6. In the isolated regtest profile only, enable
+   `allow_empty_snapshot_bootstrap`, retain a first proof tied to the canonical
+   empty context, cross a boundary while a sibling is offline, and verify the
+   rejoining sibling converges without deleting state.
 
 Do not publish a stable tag until the independent retest passes.
diff --git a/docs/umbrel-start9-launch-checklist.md b/docs/umbrel-start9-launch-checklist.md
index 596aa5a..fa76e72 100644
--- a/docs/umbrel-start9-launch-checklist.md
+++ b/docs/umbrel-start9-launch-checklist.md
@@ -312,10 +312,13 @@ Goal: make installation boring and reversible.
 - [x] Provide safe default ports for UI, peer HTTP/WebSocket, UDP relay, and the
   optional experimental DATUM listener.
 - [ ] Provide migration scripts for state files.
-- [ ] Provide backup and restore docs for node identity keys and pool state.
-- [ ] Test fresh install on a clean Linux VM.
+- [x] Provide backup and restore docs for node identity keys and pool state.
+- [x] Test the Umbrel wrapper's fresh-install and UI-driven payout flow in the
+  isolated Umbrel-dev VM/container environment.
 - [ ] Test fresh install on Raspberry Pi 5 or equivalent ARM64 host.
-- [ ] Test upgrade from previous release without wiping state.
+- [x] Test StartOS upgrade from `0.1.0:13` through `0.1.0:17` without wiping
+  state; the candidate harness retains node, payout, token, and SV2 authority
+  fingerprints for the final release run.
 - [ ] Test uninstall leaves keys/state backed up or clearly prompts before deletion.
 - [ ] Run the Umbrel and StartOS package builds for seven days overlapping the
   protocol soak, including at least one planned restart and one upgrade.
@@ -333,6 +336,26 @@ Completion criteria:
 
 Current evidence:
 
+- A private acceptance orchestrator now provides StartOS, Umbrel-dev, regtest,
+  and operator-assisted Umbrel backends with smoke, lifecycle, destructive, and
+  release profiles plus sanitized JSON/Markdown evidence.
+- StartOS `0.1.0:19` upgraded from `0.1.0:13`; a package-generation bug that
+  replaced node identity keys was found and fixed. Identity then survived a
+  package restart and full StartOS reboot. The operator explicitly replaced
+  the earlier RDTS Knots dependency with synchronized main-chain Core 31. RPC,
+  both ZMQ topics, native SV2, per-channel slot-0 attribution, named Bitaxe
+  mining, interfaces, and restart persistence now pass. Encrypted
+  uninstall/restore remains blocked until the operator supplies the existing
+  server backup password.
+- Umbrel-dev `0.1.0-beta.7` upgraded through Umbrel's package RPC with state
+  persistence and correct private-port exposure. A copied-data recovery
+  preserved node identity, payout, adapter-token, and SV2-authority
+  fingerprints. Its disposable Bitcoin dependency remains in IBD, so the
+  synchronized-SV2 gate cannot pass yet.
+- Candidate workflows build both package architectures, produce checksums,
+  SPDX SBOMs and provenance, and verify digest-locked image inputs. A real
+  ARM64 install remains a separate gate from a successful ARM64 build.
+
 - Docker sample config exists at `docker/boot_portal_config.sample.json`.
 - Testnet4 sample config exists at `docker/boot_portal_config.testnet4.sample.json`.
 - GitHub Actions publishes branch, tag, SHA, and `latest` images to GHCR; `develop` is available for staging once that branch exists.
@@ -344,11 +367,12 @@ Current evidence:
   and upgrade/backup tests pass.
 - `gridpool-sv2-pool` RPC mode passed unit tests, the wider SRI miner-workspace
   compile, and a live Core 31 mainnet template/tip-transition smoke test.
-- The StartOS package passes TypeScript checking and JavaScript bundling. Final
-  `.s9pk` packing and sideload testing require a reachable StartOS build target.
-- The Umbrel wrapper passes structural/template checks. Its first-run shell
-  configuration is acceptable for sideload testing but must become an in-app
-  payout-address setup screen before official app-store submission.
+- The StartOS package passes TypeScript checking, bundling, x86_64/aarch64
+  packing, upgrade, restart, and reboot checks. Final digest-pinned artifacts
+  must be rebuilt after security integration.
+- The Umbrel wrapper passes structural/template checks, uses an in-app one-time
+  payout-address setup flow, and passed a copied-data recovery in Umbrel-dev. A
+  real-operator candidate run remains open.
 
 ## G5.5: Miner Firmware, Rental, And Stratum V2 Compatibility
 
@@ -542,9 +566,9 @@ or cryptographic secrets.
 - [x] Keep duplicate share suppression tested.
 - [x] Keep firmware coinbase truncation detection tested.
 - [x] Keep DATUM quickdiff reconstruction observable through diagnostics.
-- [ ] Add malformed peer bundle tests.
+- [x] Add malformed and proofless peer bundle tests.
 - [ ] Add rate limits for low-difficulty peer spam.
-- [ ] Add rate limits for state bundle fetches.
+- [x] Add per-peer rate limits for outbound state bundle fetches.
 - [x] Add health-monitor checks for GridPool block found, service down, peer divergence, version mismatch, coinbase stress mode, and DATUM acceptance drops.
 - [x] Add alert suppression so ordinary snapshot transitions and brief
   different-height propagation lag do not page the operator as consensus forks.
@@ -570,10 +594,17 @@ or cryptographic secrets.
   bindings, log retention, and support-bundle sanitization.
 - [ ] Obtain a second-developer review of the threat inventory and high-risk
   findings before one-click package launch.
-- [ ] Promote the RT-2026-041/042 security release only after independent
-  regtest confirms that declared-target candidates cannot rotate payout state
-  and proofless bundles cannot alter winners or paid lineage. See
+- [ ] Promote the RT-2026-041/042 security release only after the follow-up
+  candidate closes RT-2026-076 and independently confirms regtest paid-once,
+  notification-first, and complete-proof sibling convergence. The 2026-08-26
+  retest already confirmed that declared-target candidates cannot rotate payout
+  state and proofless bundles cannot alter winners or paid lineage. See
   [security-release-rt-2026-041-042.md](security-release-rt-2026-041-042.md).
+- [ ] Review and integrate the separate RT-2026-043 through RT-2026-049
+  hardening candidate after the exact `400fc6e` critical retest is recorded.
+  The candidate adds DATUM bounds, fail-closed payout and parent authority,
+  SSRF/UDP protections, canonical payout validation, shallow-reorg coverage,
+  locked dependencies, and package supply-chain gates.
 - [ ] Design an independently verifiable paid-lineage bootstrap format before
   treating node-less `external-fallback` peers as payout-state authorities.
 
@@ -592,7 +623,10 @@ Current evidence:
 - Duplicate and firmware-truncation regression tests live in `boot.tests/ShareAttributionTests.cs`.
 - Multi-node monitoring lives in `scripts/gridpool-health-monitor.mjs` and writes compact JSONL logs for review.
 - `coinbase_uncondensed_outputs_enabled` is available for non-production firmware stress testing and rejected in production configs.
-- Low-difficulty peer-spam policy and state-bundle fetch abuse tests still need dedicated implementation.
+- Low-difficulty peer submissions are bounded by proof validation and the
+  peer-write limiter; a dedicated middleware integration test remains open.
+- Outbound state-bundle fetch abuse now has a deterministic per-peer limiter
+  test. Proofless and malformed bundle rejection is covered in the state tests.
 - The active audit and disclosure model are tracked in
   [security-privacy-review.md](security-privacy-review.md).
 
diff --git a/update_server.sh b/update_server.sh
index 7036316..1e75413 100755
--- a/update_server.sh
+++ b/update_server.sh
@@ -12,14 +12,33 @@ sed_escape() {
     printf '%s' "$1" | sed -e 's/[&|]/\\&/g'
 }
 
-echo "--- Starting Update Process ---"
+RELEASE_REF="${GRIDPOOL_RELEASE_REF:-${1:-}}"
+if [[ -z "$RELEASE_REF" ]]; then
+    echo "usage: GRIDPOOL_RELEASE_REF=<signed-tag-or-40-char-commit> $0" >&2
+    echo "Refusing to update a live node from a mutable branch." >&2
+    exit 2
+fi
+
+echo "--- Starting revision-pinned update ---"
 
 echo "Stopping service..."
 sudo systemctl stop $SERVICE_NAME
 
-echo "Pulling from Git..."
-cd $APP_DIR
-git pull origin main
+echo "Fetching selected release revision..."
+cd "$ROOT_DIR"
+git fetch --tags origin
+if [[ "$RELEASE_REF" == refs/tags/* || "$RELEASE_REF" == v* ]]; then
+    TAG="${RELEASE_REF#refs/tags/}"
+    git verify-tag "$TAG"
+    RESOLVED_REF="$TAG^{commit}"
+elif [[ "$RELEASE_REF" =~ ^[0-9a-fA-F]{40}$ ]]; then
+    RESOLVED_REF="$RELEASE_REF"
+else
+    echo "release ref must be a signed v* tag or full 40-character commit" >&2
+    exit 2
+fi
+git checkout --detach "$RESOLVED_REF"
+cd "$APP_DIR"
 
 echo "Rebuilding..."
 dotnet publish boot_portal.csproj -c Release -o "$TEMP_PUBLISH_DIR"
@@ -40,4 +59,4 @@ sudo systemctl daemon-reload
 echo "Restarting service..."
 sudo systemctl start $SERVICE_NAME
 
-echo "--- Update Complete ---"
+echo "--- Revision-pinned update complete: $(git rev-parse HEAD) ---"