debug: delay zero scan and log handicap drift for diagnosis

The race fix landed correctly (the latest report's level matches
(total - initialCount)/level_cost so initialCount is being read right),
but a 3,358-point gap still appears on a fresh island with no Poseidon
pregens and no player builds. That points at decoration evolution inside
already-scanned chunks (lava+water forming obsidian late, fluid
simulation, trial-spawner state, chunk-border ore patches) — value the
zero scan didn't see because it ran too early.

Two debugging changes to narrow down what's drifting:
- Lengthen the IslandCreatedEvent zero-scan delay from 150 ticks to
  whatever zero-scan-delay-ticks is set to (default 600 = 30s). Reuses
  the listener's decoration-settle window so both code paths give the
  world the same chance to finish generating before snapshotting.
  Floored at 150 so admins lowering the setting don't break the original
  "wait a few seconds" intent.
- Log per-chunk drift on every reconcile that finds any new/growing/
  shrinking chunks: counts of each plus the top 5 growing chunks by
  delta. Once we can see whether the gap is a handful of chunks
  evolving by a lot or many chunks evolving by a little, we can pick
  the right fix (longer delay vs absorb-on-first-scan vs something
  else).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tastybento

src/main/java/world/bentobox/level/LevelsManager.java

@@ -769,22 +769,59 @@ public long reconcileHandicapChunks(@NonNull Island island,
             }
         }
         long delta = 0L;
+        int newChunks = 0;
+        int growingChunks = 0;
+        int shrinkingChunks = 0;
+        long totalGrowth = 0L;
+        long totalShrinkage = 0L;
+        java.util.List<java.util.Map.Entry<String, Long>> topDiffs = new java.util.ArrayList<>();
         for (Map.Entry<String, Long> e : scannedChunkValues.entrySet()) {
-            if (!persisted.containsKey(e.getKey())) {
-                long value = e.getValue() == null ? 0L : e.getValue();
-                persisted.put(e.getKey(), value);
-                delta += value;
+            long scanned = e.getValue() == null ? 0L : e.getValue();
+            Long current = persisted.get(e.getKey());
+            if (current == null) {
+                // Self-heal: any chunk the scan saw but the persisted map
+                // didn't know about gets folded into both the map and the
+                // initialCount in the same write, so the next scan reads a
+                // level of zero for that previously-missing terrain.
+                persisted.put(e.getKey(), scanned);
+                delta += scanned;
+                newChunks++;
+            } else {
+                long diff = scanned - current;
+                if (diff > 0) {
+                    growingChunks++;
+                    totalGrowth += diff;
+                    topDiffs.add(new java.util.AbstractMap.SimpleEntry<>(e.getKey(), diff));
+                } else if (diff < 0) {
+                    shrinkingChunks++;
+                    totalShrinkage += -diff;
+                }
             }
         }
         if (delta != 0L) {
-            // Self-heal: any chunk the scan saw but the persisted map didn't
-            // know about gets folded into both the map and the initialCount
-            // in the same write, so the next scan reads a level of zero for
-            // that previously-missing terrain.
             long existing = data.getInitialCount() == null ? 0L : data.getInitialCount();
             data.setInitialCount(existing + delta);
             handler.saveObjectAsync(data);
         }
+        // Diagnostic: surface any drift between what the live scan saw and
+        // what the persisted handicap says. Growing chunks usually mean
+        // decoration evolution (lava+water → obsidian forming late, fluid
+        // simulation spreading, trial spawners activating, chunk-border ore
+        // patches completing); shrinking chunks mean a player broke
+        // naturally-generated blocks. Only logged when a delta exists so
+        // routine /level commands don't spam.
+        if (newChunks + growingChunks + shrinkingChunks > 0) {
+            addon.log(String.format(
+                    "Handicap diagnostic for island %s: new=%d (+%,d) growing=%d (+%,d) shrinking=%d (-%,d)",
+                    island.getUniqueId(), newChunks, delta, growingChunks, totalGrowth,
+                    shrinkingChunks, totalShrinkage));
+            topDiffs.sort((a, b) -> Long.compare(b.getValue(), a.getValue()));
+            int top = Math.min(5, topDiffs.size());
+            for (int i = 0; i < top; i++) {
+                addon.log(String.format("  Top growth chunk #%d: %s +%,d",
+                        i + 1, topDiffs.get(i).getKey(), topDiffs.get(i).getValue()));
+            }
+        }
         return delta;
     }
 

src/main/java/world/bentobox/level/listeners/IslandActivitiesListeners.java

@@ -41,8 +41,15 @@ public IslandActivitiesListeners(Level addon) {
     @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
     public void onNewIsland(IslandCreatedEvent e) {
         if (addon.getSettings().isZeroNewIslandLevels()) {
-            // Wait a few seconds before performing the zero
-            Bukkit.getScheduler().runTaskLater(addon.getPlugin(), () -> zeroIsland(e.getIsland()), 150L);
+            // Delay the zero scan so decoration (fluid simulation,
+            // late-arriving obsidian/portal frames, trial-spawner setup,
+            // chunk-border ore patches) has time to settle before we
+            // snapshot the baseline. Reuses the listener's decoration-settle
+            // setting (zero-scan-delay-ticks, default 600 = 30s) so both
+            // paths honour the same "give the world a chance to finish
+            // generating" window.
+            long delay = Math.max(150L, addon.getSettings().getZeroScanDelayTicks());
+            Bukkit.getScheduler().runTaskLater(addon.getPlugin(), () -> zeroIsland(e.getIsland()), delay);
         }
     }