Polish dashboard: real retarget prediction, symmetric 5x2, Kamado theme

The diff-adjustment tile was showing raw epoch progress (blocks-so-far
/ 2016 * 100%), which is never what anyone wants to see there. Compute
the real predicted change server-side: fetch the timestamp of the
first block in the current retarget epoch once per epoch, then each
refresh derive (expected_interval / actual_interval - 1) * 100,
clamped to Bitcoin's consensus bounds of [-75%, +300%]. The tile now
renders the signed percent, green when positive, red when negative.

Tile layout is forced to an explicit 5x2 grid so the number of
columns doesn't depend on viewport width. Reordering puts the
difficulty tile at (row 1, col 5) with the next-adjustment tile
directly below it at (row 2, col 5); block height, block reward,
total work, and expected block fill the rest of the second row.
Mobile breakpoints fall back to 3 and then 2 columns.

Header keeps only a live/connecting/offline status dot — the chain
name and block height badges were redundant now that the height tile
exists and animates on its own.

Stat-sub text bumped from 0.85em to 0.95em for readability.

Background: a warm ember-glow radial at the top of the viewport
layered with two accent radials and a low-opacity haori-checker tile
pattern (inline SVG data URI). Cards get a translucent backdrop so
the texture peeks through between them.

api/internal/state/aggregator.go

@@ -53,6 +53,11 @@ type Snapshot struct {
 	// in BTC. Refreshed at most once per minute.
 	NextBlockRewardBTC float64 `json:"next_block_reward_btc"`
 
+	// Predicted percent change at the next difficulty retarget, clamped
+	// to Bitcoin's consensus range of [-75, +300]. Derived from the
+	// observed block interval since the current epoch started.
+	NextDifficultyPercent float64 `json:"next_difficulty_percent"`
+
 	// Bitcoin Core fields
 	Chain                *bitcoind.BlockchainInfo `json:"chain"`
 	NetworkHashrateHs    float64                  `json:"network_hashrate_hs"`
@@ -115,6 +120,12 @@ type Aggregator struct {
 	nextBlockReward   float64
 	lastTemplateFetch time.Time
 
+	// Retarget epoch-start timestamp cache. Updated when we cross a
+	// new retarget boundary (every 2016 blocks); within an epoch we
+	// just re-use the cached value and re-extrapolate each refresh.
+	retargetEpoch     int64
+	retargetStartUnix int64
+
 	// ckFailStreak counts consecutive refreshes where CKPool returned an
 	// error. The first failure after a streak of successes is logged at
 	// DEBUG (likely a transient warm-up or lock hiccup); repeated failures
@@ -220,6 +231,45 @@ func (a *Aggregator) refresh(ctx context.Context) {
 		}
 	}
 
+	// --- predicted difficulty adjustment ---
+	// Fetch the timestamp of the first block in the current retarget
+	// epoch (height - height%2016) once per epoch and cache it, then
+	// compute (expected / elapsed - 1) * 100 where expected = blocks_in *
+	// 600 seconds. Bitcoin clamps the consensus adjustment factor to
+	// [1/4, 4x], i.e. [-75%, +300%].
+	if next.Chain != nil && next.Chain.Blocks > 0 {
+		height := next.Chain.Blocks
+		epoch := height / 2016
+		inEpoch := height % 2016
+		if inEpoch > 0 {
+			if a.retargetEpoch != epoch || a.retargetStartUnix == 0 {
+				startHeight := epoch * 2016
+				lookupCtx, cancelLookup := context.WithTimeout(ctx, 3*time.Second)
+				if hash, err := a.RPC.GetBlockHash(lookupCtx, startHeight); err == nil {
+					if blk, err := a.RPC.GetBlock(lookupCtx, hash); err == nil {
+						a.retargetEpoch = epoch
+						a.retargetStartUnix = blk.Time
+					}
+				}
+				cancelLookup()
+			}
+			if a.retargetStartUnix > 0 {
+				elapsed := float64(time.Now().Unix() - a.retargetStartUnix)
+				expected := float64(inEpoch) * 600
+				if elapsed > 0 {
+					factor := expected / elapsed
+					if factor > 4 {
+						factor = 4
+					}
+					if factor < 0.25 {
+						factor = 0.25
+					}
+					next.NextDifficultyPercent = (factor - 1) * 100
+				}
+			}
+		}
+	}
+
 	// Compute pool-wide best-ever share diff from workers.
 	for _, w := range next.Workers {
 		d := w.BestEver