fix(PPO_Bot): SIGSEGV crash fixes + static buffers for thread safety

- bullets: seq[InFlightBullet] → array[4, InFlightBullet] + bulletCount
  (eliminates cross-thread heap realloc under ORC)
- hasFired: edge-triggered (cleared after state build, not level-triggered)
- round_counter parseInt: wrapped for empty/torn file → 0
- Static SVG + intent buffers to kill cross-thread heap realloc
- Tick-local alive/bulletData also fixed arrays

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

PPO_Bot/PPO_Bot.nim

@@ -1,7 +1,7 @@
 ## PPO_Bot — enemy tracker + state vector wired into the game loop.
 ## Training: trajectory collected per tick, PPO update in background thread.
 
-import std/[os, strformat, strutils, math, times]
+import std/[os, strformat, strutils, math, times, algorithm]
 import arraymancer
 import tankroyale_botapi
 import network
@@ -35,6 +35,7 @@ var
 
 # Wire logStd tunable params into network module vars (read before initActorCritic)
 logStdFloor   = getEnvFloat("PPOB_LOG_STD_FLOOR", -3.0'f32)
+logStdCeiling = getEnvFloat("PPOB_LOG_STD_CEILING", 0.5'f32)
 initialLogStd = getEnvFloat("PPOB_INITIAL_LOG_STD", 0.0'f32)
 
 # ── Structured log output ─────────────────────────────────────────────────────
@@ -59,11 +60,17 @@ proc hyperparmSnapshot(): string =
   &"\"entropyCoeff\":{hpEntropyCoeff},\"valueLossCoeff\":{hpValueLossCoeff}," &
   &"\"maxGradNorm\":{hpMaxGradNorm},\"gamma\":{hpGamma},\"lam\":{hpLam}," &
   &"\"epochs\":{hpEpochs},\"miniBatchSize\":{hpMiniBatchSize}," &
-  &"\"logStdFloor\":{logStdFloor},\"initialLogStd\":{initialLogStd}"
+  &"\"logStdFloor\":{logStdFloor},\"logStdCeiling\":{logStdCeiling},\"initialLogStd\":{initialLogStd}"
 
 const botJsonPath = currentSourcePath().parentDir / "PPO_Bot.json"
 const weightsRoot = currentSourcePath().parentDir / "weights"
 
+type
+  InFlightBullet = object
+    x, y:   float64  # current position
+    vx, vy: float64  # velocity (pixels/tick)
+    power:  float64
+
 type PPOBot = ref object of Bot
   tracker:       EnemyTracker
   buffer:        TrajectoryBuffer
@@ -77,6 +84,12 @@ type PPOBot = ref object of Bot
   lastActions:   BotActions    # previous tick's decoded actions (for state vector)
   roundRewardSum: float32      # cumulative reward this round (for live display)
   roundTicks:     int          # ticks this round
+  # Fixed-size bullet buffer — NO heap on the shared bot object. A seq here is
+  # allocated by the per-round bot thread and freed by the next round's thread
+  # (bot.bullets = @[] on round start) → foreign-heap free under --threads:on +
+  # ORC → SIGSEGV. N=4: the state vector only consumes the closest 3 slots.
+  bullets:       array[4, InFlightBullet]
+  bulletCount:   int
 
 var ac = initActorCritic()
 var gAdamStates: ACAdamStates  # persists across rounds
@@ -98,6 +111,7 @@ method onRoundStarted*(bot: PPOBot, e: RoundStartedEvent) =
   bot.hasLastTrans   = false
   bot.roundRewardSum = 0.0'f32
   bot.roundTicks     = 0
+  bot.bulletCount    = 0
 
 method onRoundEnded*(bot: PPOBot, e: RoundEndedEventForBot) =
   inc roundCounter
@@ -184,6 +198,53 @@ method run(bot: PPOBot) =
   while isRunning():
     bot.tracker.deadReckon()
 
+    # Spawn bullet when enemy fired last scan tick. Edge-triggered: the flag is
+    # consumed later (after the state build) so a radar gap (deadReckon ticks)
+    # can't spawn k phantom bullets from one shot — exactly one bullet, and
+    # state index 12 still pulses 1 on the detection tick.
+    if bot.tracker.hasContact and bot.tracker.current.hasFired:
+      if bot.bulletCount < 4:
+        let power = bot.tracker.current.lastFirePower
+        let speed = 20.0 - 3.0 * power
+        # Approximate gun direction: bearing from enemy toward our position
+        let myX = getX(); let myY = getY()
+        let ang = arctan2(myY - bot.tracker.current.y, myX - bot.tracker.current.x)
+        bot.bullets[bot.bulletCount] = InFlightBullet(
+          x:     bot.tracker.current.x,
+          y:     bot.tracker.current.y,
+          vx:    speed * cos(ang),
+          vy:    speed * sin(ang),
+          power: power,
+        )
+        inc bot.bulletCount
+
+    # Advance in-flight bullets and prune those off-arena (in-place compaction
+    # into the fixed buffer — no per-tick heap churn).
+    let aW = float64(getArenaWidth()); let aH = float64(getArenaHeight())
+    var n = 0
+    for i in 0 ..< bot.bulletCount:
+      let b = bot.bullets[i]
+      let nx = b.x + b.vx; let ny = b.y + b.vy
+      if nx >= 0.0 and nx <= aW and ny >= 0.0 and ny <= aH:
+        bot.bullets[n] = InFlightBullet(x: nx, y: ny, vx: b.vx, vy: b.vy, power: b.power)
+        inc n
+    bot.bulletCount = n
+
+    # Convert to BulletData for state vector (closest 3 by distance to us)
+    let myX2 = getX(); let myY2 = getY()
+    var bulletData: array[4, BulletData]
+    var bulletDataCount = 0
+    for i in 0 ..< bot.bulletCount:
+      let b = bot.bullets[i]
+      bulletData[bulletDataCount] = BulletData(x: b.x, y: b.y, power: b.power)
+      inc bulletDataCount
+    # sort ascending by distance so the nearest threats fill slots 0-2
+    if bulletDataCount > 1:
+      bulletData.toOpenArray(0, bulletDataCount - 1).sort(proc(a, b: BulletData): int =
+        let da = hypot(a.x - myX2, a.y - myY2)
+        let db = hypot(b.x - myX2, b.y - myY2)
+        cmp(da, db))
+
     setRadarTurnRate(bot.tracker.getRadarTurnRate(getX(), getY(), getDirection(), getRadarDirection()))
 
     let botData = BotStateData(
@@ -203,7 +264,11 @@ method run(bot: PPOBot) =
     let remainingGunAngle = abs(normalizeRelativeAngle(
       directionTo(botData.x, botData.y, bot.lastActions.aimToX, bot.lastActions.aimToY) -
       botData.gunDirection))
-    let state = buildStateVector(botData, bot.tracker, remainingGotoDistance, remainingGunAngle)
+    let state = buildStateVector(botData, bot.tracker, remainingGotoDistance, remainingGunAngle, bulletData, bulletDataCount)
+    # Consume the fired flag AFTER the state build: state index 12 saw the
+    # detection-tick pulse, and the next iteration's spawn check sees false —
+    # one shot → exactly one bullet, even across deadReckon gaps.
+    bot.tracker.current.hasFired = false
     let (rawActs, logP) = ac.actorForward(state)
     let value = ac.criticForward(state)
     let ex = if bot.tracker.hasContact: bot.tracker.current.x else: botData.arenaWidth  / 2.0